fix blank : there have more than one resultat display
[scilab.git] / scilab / modules / ast / src / cpp / types / implicitlist.cpp
1 /*
2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 *  Copyright (C) 2008-2008 - DIGITEO - Antoine ELIAS
4 *
5 *  This file must be used under the terms of the CeCILL.
6 *  This source file is licensed as described in the file COPYING, which
7 *  you should have received as part of this distribution.  The terms
8 *  are also available at
9 *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10 *
11 */
12 #include <sstream>
13 #include <math.h>
14 #include "double.hxx"
15 #include "polynom.hxx"
16 #include "implicitlist.hxx"
17 #include "int.hxx"
18 #include "configvariable.hxx"
19 #include "scilabWrite.hxx"
20
21 #ifndef NDEBUG
22 #include "inspector.hxx"
23 #endif
24
25 #include "tostring_common.hxx"
26
27 extern "C"
28 {
29 #include "core_math.h"
30 #include "elem_common.h"
31 #include "finite.h"
32 }
33
34 std::wstring printInLinePoly(types::SinglePoly* _pPoly, std::wstring _stVar);
35 std::wstring printDouble(types::Double* _pD);
36 long long convert_input(types::InternalType* _poIT);
37 unsigned long long convert_unsigned_input(types::InternalType* _poIT);
38
39 namespace types
40 {
41 ImplicitList::~ImplicitList()
42 {
43     if (isDeletable() == true)
44     {
45         if (m_poStart)
46         {
47             m_poStart->DecreaseRef();
48             m_poStart->killMe();
49         }
50
51         if (m_poStep)
52         {
53             m_poStep->DecreaseRef();
54             m_poStep->killMe();
55         }
56
57         if (m_poEnd)
58         {
59             m_poEnd->DecreaseRef();
60             m_poEnd->killMe();
61         }
62     }
63 #ifndef NDEBUG
64     Inspector::removeItem(this);
65 #endif
66 }
67
68 ImplicitList::ImplicitList()
69 {
70     m_iSize     = -1;
71     m_eOutType  = ScilabGeneric;
72     m_bComputed = false;
73     m_poStart   = NULL;
74     m_poStep    = NULL;
75     m_poEnd     = NULL;
76     m_pDblStart = NULL;
77     m_pDblStep  = NULL;
78     m_pDblEnd   = NULL;
79
80 #ifndef NDEBUG
81     Inspector::addItem(this);
82 #endif
83 }
84
85 ImplicitList::ImplicitList(InternalType* _poStart, InternalType* _poStep, InternalType* _poEnd)
86 {
87     m_iSize     = -1;
88     m_eOutType  = ScilabGeneric;
89     m_bComputed = false;
90     m_poStart   = NULL;
91     m_poStep    = NULL;
92     m_poEnd     = NULL;
93     m_pDblStart = NULL;
94     m_pDblStep  = NULL;
95     m_pDblEnd   = NULL;
96
97     setStart(_poStart);
98     setStep(_poStep);
99     setEnd(_poEnd);
100     compute();
101 #ifndef NDEBUG
102     Inspector::addItem(this);
103 #endif
104 }
105
106 InternalType* ImplicitList::clone()
107 {
108     return new ImplicitList(m_poStart, m_poStep, m_poEnd);
109 }
110
111 InternalType::ScilabType ImplicitList::getStartType()
112 {
113     return m_poStart->getType();
114 }
115
116 InternalType::ScilabType ImplicitList::getStepType()
117 {
118     return m_poStep->getType();
119 }
120
121 InternalType::ScilabType ImplicitList::getEndType()
122 {
123     return m_poEnd->getType();
124 }
125
126 void ImplicitList::setStart(InternalType *_poIT)
127 {
128     if (m_poStart)
129     {
130         //clear previous value
131         m_poStart->DecreaseRef();
132         m_poStart->killMe();
133         m_poStart = NULL;
134     }
135
136     m_poStart = _poIT;
137     if (m_poStart != NULL)
138     {
139         m_poStart->IncreaseRef();
140         m_eStartType = m_poStart->getType();
141     }
142     m_bComputed = false;
143 }
144
145 void ImplicitList::setStep(InternalType *_poIT)
146 {
147     if (m_poStep)
148     {
149         //clear previous value
150         m_poStep->DecreaseRef();
151         m_poStep->killMe();
152         m_poStep = NULL;
153     }
154
155     m_poStep = _poIT;
156     if (m_poStep != NULL)
157     {
158         m_poStep->IncreaseRef();
159         m_eStepType = m_poStep->getType();
160     }
161     m_bComputed = false;
162 }
163
164 void ImplicitList::setEnd(InternalType* _poIT)
165 {
166     if (m_poEnd)
167     {
168         //clear previous value
169         m_poEnd->DecreaseRef();
170         m_poEnd->killMe();
171         m_poEnd = NULL;
172     }
173
174     m_poEnd = _poIT;
175     if (m_poEnd != NULL)
176     {
177         m_poEnd->IncreaseRef();
178         m_eEndType = m_poEnd->getType();
179     }
180     m_bComputed = false;
181 }
182
183 bool ImplicitList::compute()
184 {
185     if (m_bComputed == true)
186     {
187         return true;
188     }
189
190     m_iSize = -1;
191     if (isComputable() == true)
192     {
193         m_iSize = 0;
194         if (m_eOutType == ScilabDouble)
195         {
196             m_pDblStart = m_poStart->getAs<Double>();
197             double dblStart     = m_pDblStart->get(0);
198
199             m_pDblStep = m_poStep->getAs<Double>();
200             double dblStep      = m_pDblStep->get(0);
201
202             m_pDblEnd = m_poEnd->getAs<Double>();
203             double dblEnd       = m_pDblEnd->get(0);
204             // othe way to compute
205
206             // nan value
207             if (ISNAN(dblStart) || ISNAN(dblStep) || ISNAN(dblEnd))
208             {
209                 m_iSize = -1;
210                 m_bComputed = true;
211                 return true;
212             }
213
214             // no finite values
215             if ( finite(dblStart) == 0 || finite(dblStep) == 0 || finite(dblEnd) == 0)
216             {
217                 if ((dblStep > 0 && dblStart < dblEnd) ||
218                         (dblStep < 0 && dblStart > dblEnd))
219                 {
220                     // return nan
221                     m_iSize = -1;
222                 }
223                 // else return []
224
225                 m_bComputed = true;
226                 return true;
227             }
228
229             // step null
230             if (dblStep == 0) // return []
231             {
232                 m_bComputed = true;
233                 return true;
234             }
235
236             double dblVal = dblStart; // temp value
237             double dblEps = getRelativeMachinePrecision();
238             double dblPrec = 2 * std::max(fabs(dblStart), fabs(dblEnd)) * dblEps;
239
240             while (dblStep * (dblVal - dblEnd) <= 0)
241             {
242                 m_iSize++;
243                 dblVal = dblStart + m_iSize * dblStep;
244             }
245
246             if (fabs(dblVal - dblEnd) < dblPrec)
247             {
248                 m_iSize++;
249             }
250
251             //if(dblStep > 0)
252             //{
253             //    m_iSize = static_cast<int>(floor((dblEnd - dblStart) / dblStep)) + 1;
254             //}
255             //else if(dblStep < 0)
256             //{
257             //    m_iSize = static_cast<int>(floor((dblStart - dblEnd) / -dblStep)) + 1;
258             //}
259             //else
260             //{
261             //    m_iSize = 0;
262             //}
263
264             //if(m_iSize < 0)
265             //{
266             //    m_iSize = 0;
267             //}
268             //                m_iSize = static_cast<long long>(floor(fabs(dblEnd - dblStart) / fabs(dblStep))) + 1;
269         }
270         else //m_eOutType == ScilabInt
271         {
272             if (m_eOutType == ScilabInt8 ||
273                     m_eOutType == ScilabInt16 ||
274                     m_eOutType == ScilabInt32 ||
275                     m_eOutType == ScilabInt64)
276             {
277                 //signed
278                 long long llStart   = convert_input(m_poStart);
279                 long long llStep    = convert_input(m_poStep);
280                 long long llEnd     = convert_input(m_poEnd);
281
282 #ifdef _MSC_VER
283                 m_iSize = static_cast<int>(floor( static_cast<double>(_abs64(llEnd - llStart) / _abs64(llStep)) )) + 1;
284 #else
285                 m_iSize = static_cast<int>(floor( static_cast<double>(llabs(llEnd - llStart) / llabs(llStep)) )) + 1;
286 #endif
287             }
288             else
289             {
290                 //unsigned
291                 unsigned long long ullStart = convert_unsigned_input(m_poStart);
292                 unsigned long long ullStep      = convert_unsigned_input(m_poStep);
293                 unsigned long long ullEnd   = convert_unsigned_input(m_poEnd);
294
295 #ifdef _MSC_VER
296                 m_iSize = static_cast<int>(floor(static_cast<double>(_abs64(ullEnd - ullStart) / _abs64(ullStep)) )) + 1;
297 #else
298                 m_iSize = static_cast<int>(floor(static_cast<double>(llabs(ullEnd - ullStart) / llabs(ullStep)) )) + 1;
299 #endif
300             }
301         }
302         m_bComputed = true;
303         return true;
304     }
305     else
306     {
307         return false;
308     }
309 }
310
311 bool ImplicitList::isComputable()
312 {
313     if (m_eStartType != ScilabDouble && m_poStart->isInt() == false)
314     {
315         return false;
316     }
317
318     if (m_eStepType != ScilabDouble && m_poStep->isInt() == false)
319     {
320         return false;
321     }
322
323     if (m_eEndType != ScilabDouble && m_poEnd->isInt() == false)
324     {
325         return false;
326     }
327
328     //"compute" output type
329     m_eOutType = ScilabGeneric; //not defined type
330     if (m_poStart->isInt())
331     {
332         m_eOutType  = m_poStart->getType();
333     }
334     else if (m_poStep->isInt())
335     {
336         m_eOutType  = m_poStep->getType();
337     }
338     else if (m_poEnd->isInt())
339     {
340         m_eOutType  = m_poEnd->getType();
341     }
342     else
343     {
344         m_eOutType  = ScilabDouble;
345     }
346
347     return true;
348 }
349
350 bool ImplicitList::toString(std::wostringstream& ostr)
351 {
352     if (isComputable())
353     {
354         types::InternalType* pIT = extractFullMatrix();
355         bool ret = pIT->toString(ostr);
356         delete pIT;
357         return ret;
358     }
359     else
360     {
361         ostr << L" ";
362         if (m_eStartType == ScilabDouble)
363         {
364             Double *pD = m_poStart->getAs<Double>();
365             ostr << printDouble(pD);
366         }
367         else //Polynom
368         {
369             Polynom* pMP = m_poStart->getAs<types::Polynom>();
370             ostr << printInLinePoly(pMP->get(0), pMP->getVariableName());
371         }
372
373         ostr << L":";
374
375         if (m_eStepType == ScilabDouble)
376         {
377             Double *pD = m_poStep->getAs<Double>();
378             ostr << printDouble(pD);
379         }
380         else //Polynom
381         {
382             Polynom* pMP = m_poStep->getAs<types::Polynom>();
383             ostr << printInLinePoly(pMP->get(0), pMP->getVariableName());
384         }
385
386         ostr << L":";
387
388         if (m_eEndType == ScilabDouble)
389         {
390             Double *pD = m_poEnd->getAs<Double>();
391             ostr << printDouble(pD);
392         }
393         else //Polynom
394         {
395             Polynom* pMP = m_poEnd->getAs<types::Polynom>();
396             ostr << printInLinePoly(pMP->get(0), pMP->getVariableName());
397         }
398         ostr << std::endl;
399         scilabWriteW(ostr.str().c_str());
400         // reset ostr after scilabWriteW call
401         ostr.str(L"");
402
403         return true;
404     }
405 }
406
407 InternalType::ScilabType ImplicitList::getOutputType()
408 {
409     return m_eOutType;
410 }
411
412 double ImplicitList::extractValueInDouble(int _iOccur)
413 {
414     double dblStart             = m_pDblStart->get(0);
415     double dblStep              = m_pDblStep->get(0);
416     return dblStart + _iOccur * dblStep;
417 }
418
419 long long ImplicitList::extractValueInInteger(int _iOccur)
420 {
421     return convert_input(m_poStart) + _iOccur * convert_input(m_poStep);
422 }
423
424 unsigned long long ImplicitList::extractValueInUnsignedInteger(int _iOccur)
425 {
426     return convert_unsigned_input(m_poStart) + _iOccur * convert_unsigned_input(m_poStep);
427 }
428
429 //extract single value in a InternalType
430 InternalType* ImplicitList::extractValue(int _iOccur)
431 {
432     InternalType* pIT = NULL;
433     if (compute())
434     {
435         long long llVal             = extractValueInInteger(_iOccur);
436         unsigned long long ullVal   = extractValueInUnsignedInteger(_iOccur);
437         if (m_eOutType == ScilabInt8)
438         {
439             pIT = new Int8((char)llVal);
440         }
441         else if (m_eOutType == ScilabUInt8)
442         {
443             pIT = new UInt8((unsigned char)ullVal);
444         }
445         else if (m_eOutType == ScilabInt16)
446         {
447             pIT = new Int16((short)llVal);
448         }
449         else if (m_eOutType == ScilabUInt16)
450         {
451             pIT = new UInt16((unsigned short)ullVal);
452         }
453         else if (m_eOutType == ScilabInt32)
454         {
455             pIT = new Int32((int)llVal);
456         }
457         else if (m_eOutType == ScilabUInt32)
458         {
459             pIT = new UInt32((unsigned int)ullVal);
460         }
461         else if (m_eOutType == ScilabInt64)
462         {
463             pIT = new Int64((long long)llVal);
464         }
465         else if (m_eOutType == ScilabUInt64)
466         {
467             pIT = new UInt64((unsigned long long)ullVal);
468         }
469         else //ScilabDouble
470         {
471             double dblStart = m_poStart->getAs<Double>()->getReal(0, 0);
472             double dblStep  = m_poStep->getAs<Double>()->getReal(0, 0);
473             Double* pD      = new Double(dblStart + _iOccur * dblStep);
474             pIT = pD;
475         }
476     }
477     return pIT;
478 }
479
480 //extract matrix in a Internaltype
481 InternalType* ImplicitList::extractFullMatrix()
482 {
483     InternalType* pIT = NULL;
484     if (compute())
485     {
486         if (getSize() == 0) // return []
487         {
488             pIT = Double::Empty();
489         }
490         else if (getSize() == -1) // return nan
491         {
492             unsigned long long raw = 0x7ff8000000000000;
493             double not_a_number = *( double* )&raw;
494             pIT = new Double(not_a_number);
495         }
496         else if (m_eOutType == ScilabDouble)
497         {
498             pIT = new Double(1, m_iSize);
499             extractFullMatrix(pIT->getAs<Double>()->get());
500         }
501         else if (m_eOutType == ScilabInt8)
502         {
503             pIT = new Int8(1, m_iSize);
504             extractFullMatrix(pIT->getAs<Int8>()->get());
505         }
506         else if (m_eOutType == ScilabUInt8)
507         {
508             pIT = new UInt8(1, m_iSize);
509             extractFullMatrix(pIT->getAs<UInt8>()->get());
510         }
511         else if (m_eOutType == ScilabInt16)
512         {
513             pIT = new Int16(1, m_iSize);
514             extractFullMatrix(pIT->getAs<Int16>()->get());
515         }
516         else if (m_eOutType == ScilabUInt16)
517         {
518             pIT = new UInt16(1, m_iSize);
519             extractFullMatrix(pIT->getAs<UInt16>()->get());
520         }
521         else if (m_eOutType == ScilabInt32)
522         {
523             pIT = new Int32(1, m_iSize);
524             extractFullMatrix(pIT->getAs<Int32>()->get());
525         }
526         else if (m_eOutType == ScilabUInt32)
527         {
528             pIT = new UInt32(1, m_iSize);
529             extractFullMatrix(pIT->getAs<UInt32>()->get());
530         }
531         else if (m_eOutType == ScilabInt64)
532         {
533             pIT = new Int64(1, m_iSize);
534             extractFullMatrix(pIT->getAs<Int64>()->get());
535         }
536         else if (m_eOutType == ScilabUInt64)
537         {
538             pIT = new UInt64(1, m_iSize);
539             extractFullMatrix(pIT->getAs<UInt64>()->get());
540         }
541     }
542     return pIT;
543 }
544
545 void ImplicitList::extractFullMatrix(double *_pdbl)
546 {
547     double dblStart = m_poStart->getAs<Double>()->get(0);
548     double dblStep  = m_poStep->getAs<Double>()->get(0);
549
550     for (int i = 0 ; i < m_iSize ; i++)
551     {
552         _pdbl[i] = dblStart + i * dblStep;
553     }
554 }
555
556 template<typename T>
557 void ImplicitList::extractFullMatrix(T *_pT)
558 {
559     T tStart = static_cast<T>(convert_input(m_poStart));
560     T tStep     = static_cast<T>(convert_input(m_poStep));
561
562     for (int i = 0 ; i < m_iSize ; i++)
563     {
564         _pT[i] = tStart + i * tStep;
565     }
566 }
567
568 bool ImplicitList::transpose(InternalType *& out)
569 {
570     if (compute())
571     {
572         Double * pIT = new Double(m_iSize, 1);
573         out = pIT;
574         extractFullMatrix(pIT->get());
575
576         return true;
577     }
578
579     return false;
580 }
581
582 bool ImplicitList::neg(InternalType *& out)
583 {
584     if (compute() && m_poStart->isDouble() && m_poStep->isDouble() && m_poEnd->isDouble())
585     {
586         out = new Bool(1, m_iSize);
587         type_traits::neg(m_poStart->getAs<Double>()->get(0), m_poStep->getAs<Double>()->get(0), m_poEnd->getAs<Double>()->get(0), static_cast<Bool *>(out)->get());
588
589         return true;
590     }
591
592     return false;
593 }
594
595 bool ImplicitList::invoke(typed_list & in, optional_list & /*opt*/, int /*_iRetCount*/, typed_list & out, ast::ConstVisitor & /*execFunc*/, const ast::CallExp & e)
596 {
597     if (in.size() == 0)
598     {
599         out.push_back(this);
600     }
601     else
602     {
603         InternalType * _out = extract(&in);
604         if (!_out)
605         {
606             std::wostringstream os;
607             os << _W("Invalid index.\n");
608             throw ast::ScilabError(os.str(), 999, (*e.getArgs().begin())->getLocation());
609         }
610         out.push_back(_out);
611     }
612
613     return true;
614 }
615
616 InternalType* ImplicitList::extract(typed_list* _pArgs)
617 {
618     int iDims = (int)_pArgs->size();
619     typed_list pArg;
620     InternalType* pOut = NULL;
621     int index = 0;
622
623     int* piMaxDim = new int[iDims];
624     int* piCountDim = new int[iDims];
625
626     //evaluate each argument and replace by appropriate value and compute the count of combinations
627     int iSeqCount = checkIndexesArguments(this, _pArgs, &pArg, piMaxDim, piCountDim);
628     if (iSeqCount == 0)
629     {
630         //free pArg content
631         cleanIndexesArguments(_pArgs, &pArg);
632         return createEmptyDouble();
633     }
634
635     if (iDims == 1 && iSeqCount == 1)
636     {
637         if (piMaxDim[0] > 0 && piMaxDim[0] <= 3)
638         {
639             //standard case a(1)
640             Double* pDbl = pArg[0]->getAs<Double>();
641             index = (int)pDbl->get()[0] - 1;
642         }
643         else
644         {
645             index = 0;
646         }
647     }
648     else
649     {
650         int* piDims = new int[iDims];
651         for (int i = 0 ; i < iDims ; i++)
652         {
653             piDims[i] = 1;
654         }
655
656         for (int i = 0 ; i < iSeqCount ; i++)
657         {
658             int* pIndex = new int[iDims];
659             for (int j = 0 ; j < iDims ; j++)
660             {
661                 Double* pDbl = pArg[j]->getAs<Double>();
662                 pIndex[j] = (int)pDbl->get()[i] - 1;
663             }
664
665             index = getIndexWithDims(pIndex, piDims, iDims);
666         }
667     }
668
669     switch (index)
670     {
671         case 0 :
672             pOut = getStart();
673             break;
674         case 1 :
675             pOut = getStep();
676             break;
677         case 2 :
678             pOut = getEnd();
679             break;
680         default :
681             pOut = NULL;
682             break;
683     }
684
685     //free pArg content
686     cleanIndexesArguments(_pArgs, &pArg);
687
688     delete[] piMaxDim;
689     delete[] piCountDim;
690     return pOut;
691 }
692 }
693
694 std::wstring printInLinePoly(types::SinglePoly* _pPoly, std::wstring _stVar)
695 {
696     std::wostringstream ostr;
697     double* pdblIn = _pPoly->get();
698     for (int i = 0 ; i < _pPoly->getSize() ; i++)
699     {
700
701         if (pdblIn[i] != 0)
702         {
703             DoubleFormat df;
704             getDoubleFormat(pdblIn[i], &df);
705             df.bPrintPoint = ostr.str().size() != 0;
706             df.bPrintPlusSign = true;
707             df.bPrintOne = i == 0;
708             df.bPaddSign = false;
709             addDoubleValue(&ostr, pdblIn[i], &df);
710             if (i != 0)
711             {
712                 ostr << _stVar;
713                 if (i > 1)
714                 {
715                     ostr << "^" << i;
716                 }
717             }
718         }
719     }
720     return ostr.str();
721 }
722
723 std::wstring printDouble(types::Double* _pD)
724 {
725     std::wostringstream ostr;
726     DoubleFormat df;
727     getDoubleFormat(_pD->get(0), &df);
728     df.bPaddSign = true;
729     addDoubleValue(&ostr, _pD->get(0), &df);
730     return ostr.str();
731 }
732
733 long long convert_input(types::InternalType* _poIT)
734 {
735     long long llValue = 0;
736     switch (_poIT->getType())
737     {
738         case types::GenericType::ScilabDouble :
739             llValue = static_cast<long long>(_poIT->getAs<types::Double>()->get(0));
740             break;
741         case types::GenericType::ScilabInt8 :
742             llValue = static_cast<long long>(_poIT->getAs<types::Int8>()->get(0));
743             break;
744         case types::GenericType::ScilabUInt8 :
745             llValue = static_cast<long long>(_poIT->getAs<types::UInt8>()->get(0));
746             break;
747         case types::GenericType::ScilabInt16 :
748             llValue = static_cast<long long>(_poIT->getAs<types::Int16>()->get(0));
749             break;
750         case types::GenericType::ScilabUInt16 :
751             llValue = static_cast<long long>(_poIT->getAs<types::UInt16>()->get(0));
752             break;
753         case types::GenericType::ScilabInt32 :
754             llValue = static_cast<long long>(_poIT->getAs<types::Int32>()->get(0));
755             break;
756         case types::GenericType::ScilabUInt32 :
757             llValue = static_cast<long long>(_poIT->getAs<types::UInt32>()->get(0));
758             break;
759         case types::GenericType::ScilabInt64 :
760             llValue = static_cast<long long>(_poIT->getAs<types::Int64>()->get(0));
761             break;
762         case types::GenericType::ScilabUInt64 :
763             llValue = static_cast<long long>(_poIT->getAs<types::UInt64>()->get(0));
764             break;
765         default:
766             // FIXME : Trigger an error ??
767             break;
768     }
769     return llValue;
770 }
771
772 unsigned long long convert_unsigned_input(types::InternalType* _poIT)
773 {
774     unsigned long long ullValue = 0;
775     switch (_poIT->getType())
776     {
777         case types::GenericType::ScilabDouble :
778             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::Double>()->get(0));
779             break;
780         case types::GenericType::ScilabInt8 :
781             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::Int8>()->get(0));
782             break;
783         case types::GenericType::ScilabUInt8 :
784             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::UInt8>()->get(0));
785             break;
786         case types::GenericType::ScilabInt16 :
787             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::Int16>()->get(0));
788             break;
789         case types::GenericType::ScilabUInt16 :
790             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::UInt16>()->get(0));
791             break;
792         case types::GenericType::ScilabInt32 :
793             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::Int32>()->get(0));
794             break;
795         case types::GenericType::ScilabUInt32 :
796             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::UInt32>()->get(0));
797             break;
798         case types::GenericType::ScilabInt64 :
799             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::Int64>()->get(0));
800             break;
801         case types::GenericType::ScilabUInt64 :
802             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::UInt64>()->get(0));
803             break;
804         default:
805             // FIXME : Trigger an error ??
806             break;
807     }
808     return ullValue;
809
810 }