fix string test :
[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         return true;
400     }
401 }
402
403 InternalType::ScilabType ImplicitList::getOutputType()
404 {
405     return m_eOutType;
406 }
407
408 double ImplicitList::extractValueInDouble(int _iOccur)
409 {
410     double dblStart             = m_pDblStart->get(0);
411     double dblStep              = m_pDblStep->get(0);
412     return dblStart + _iOccur * dblStep;
413 }
414
415 long long ImplicitList::extractValueInInteger(int _iOccur)
416 {
417     return convert_input(m_poStart) + _iOccur * convert_input(m_poStep);
418 }
419
420 unsigned long long ImplicitList::extractValueInUnsignedInteger(int _iOccur)
421 {
422     return convert_unsigned_input(m_poStart) + _iOccur * convert_unsigned_input(m_poStep);
423 }
424
425 //extract single value in a InternalType
426 InternalType* ImplicitList::extractValue(int _iOccur)
427 {
428     InternalType* pIT = NULL;
429     if (compute())
430     {
431         long long llVal             = extractValueInInteger(_iOccur);
432         unsigned long long ullVal   = extractValueInUnsignedInteger(_iOccur);
433         if (m_eOutType == ScilabInt8)
434         {
435             pIT = new Int8((char)llVal);
436         }
437         else if (m_eOutType == ScilabUInt8)
438         {
439             pIT = new UInt8((unsigned char)ullVal);
440         }
441         else if (m_eOutType == ScilabInt16)
442         {
443             pIT = new Int16((short)llVal);
444         }
445         else if (m_eOutType == ScilabUInt16)
446         {
447             pIT = new UInt16((unsigned short)ullVal);
448         }
449         else if (m_eOutType == ScilabInt32)
450         {
451             pIT = new Int32((int)llVal);
452         }
453         else if (m_eOutType == ScilabUInt32)
454         {
455             pIT = new UInt32((unsigned int)ullVal);
456         }
457         else if (m_eOutType == ScilabInt64)
458         {
459             pIT = new Int64((long long)llVal);
460         }
461         else if (m_eOutType == ScilabUInt64)
462         {
463             pIT = new UInt64((unsigned long long)ullVal);
464         }
465         else //ScilabDouble
466         {
467             double dblStart = m_poStart->getAs<Double>()->getReal(0, 0);
468             double dblStep  = m_poStep->getAs<Double>()->getReal(0, 0);
469             Double* pD      = new Double(dblStart + _iOccur * dblStep);
470             pIT = pD;
471         }
472     }
473     return pIT;
474 }
475
476 //extract matrix in a Internaltype
477 InternalType* ImplicitList::extractFullMatrix()
478 {
479     InternalType* pIT = NULL;
480     if (compute())
481     {
482         if (getSize() == 0) // return []
483         {
484             pIT = Double::Empty();
485         }
486         else if (getSize() == -1) // return nan
487         {
488             unsigned long long raw = 0x7ff8000000000000;
489             double not_a_number = *( double* )&raw;
490             pIT = new Double(not_a_number);
491         }
492         else if (m_eOutType == ScilabDouble)
493         {
494             pIT = new Double(1, m_iSize);
495             extractFullMatrix(pIT->getAs<Double>()->get());
496         }
497         else if (m_eOutType == ScilabInt8)
498         {
499             pIT = new Int8(1, m_iSize);
500             extractFullMatrix(pIT->getAs<Int8>()->get());
501         }
502         else if (m_eOutType == ScilabUInt8)
503         {
504             pIT = new UInt8(1, m_iSize);
505             extractFullMatrix(pIT->getAs<UInt8>()->get());
506         }
507         else if (m_eOutType == ScilabInt16)
508         {
509             pIT = new Int16(1, m_iSize);
510             extractFullMatrix(pIT->getAs<Int16>()->get());
511         }
512         else if (m_eOutType == ScilabUInt16)
513         {
514             pIT = new UInt16(1, m_iSize);
515             extractFullMatrix(pIT->getAs<UInt16>()->get());
516         }
517         else if (m_eOutType == ScilabInt32)
518         {
519             pIT = new Int32(1, m_iSize);
520             extractFullMatrix(pIT->getAs<Int32>()->get());
521         }
522         else if (m_eOutType == ScilabUInt32)
523         {
524             pIT = new UInt32(1, m_iSize);
525             extractFullMatrix(pIT->getAs<UInt32>()->get());
526         }
527         else if (m_eOutType == ScilabInt64)
528         {
529             pIT = new Int64(1, m_iSize);
530             extractFullMatrix(pIT->getAs<Int64>()->get());
531         }
532         else if (m_eOutType == ScilabUInt64)
533         {
534             pIT = new UInt64(1, m_iSize);
535             extractFullMatrix(pIT->getAs<UInt64>()->get());
536         }
537     }
538     return pIT;
539 }
540
541 void ImplicitList::extractFullMatrix(double *_pdbl)
542 {
543     double dblStart = m_poStart->getAs<Double>()->get(0);
544     double dblStep  = m_poStep->getAs<Double>()->get(0);
545
546     for (int i = 0 ; i < m_iSize ; i++)
547     {
548         _pdbl[i] = dblStart + i * dblStep;
549     }
550 }
551
552 template<typename T>
553 void ImplicitList::extractFullMatrix(T *_pT)
554 {
555     T tStart = static_cast<T>(convert_input(m_poStart));
556     T tStep     = static_cast<T>(convert_input(m_poStep));
557
558     for (int i = 0 ; i < m_iSize ; i++)
559     {
560         _pT[i] = tStart + i * tStep;
561     }
562 }
563
564 bool ImplicitList::transpose(InternalType *& out)
565 {
566     if (compute())
567     {
568         Double * pIT = new Double(m_iSize, 1);
569         out = pIT;
570         extractFullMatrix(pIT->get());
571
572         return true;
573     }
574
575     return false;
576 }
577
578 bool ImplicitList::neg(InternalType *& out)
579 {
580     if (compute() && m_poStart->isDouble() && m_poStep->isDouble() && m_poEnd->isDouble())
581     {
582         out = new Bool(1, m_iSize);
583         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());
584
585         return true;
586     }
587
588     return false;
589 }
590
591 bool ImplicitList::invoke(typed_list & in, optional_list & /*opt*/, int /*_iRetCount*/, typed_list & out, ast::ConstVisitor & /*execFunc*/, const ast::CallExp & e)
592 {
593     if (in.size() == 0)
594     {
595         out.push_back(this);
596     }
597     else
598     {
599         InternalType * _out = extract(&in);
600         if (!_out)
601         {
602             std::wostringstream os;
603             os << _W("Invalid index.\n");
604             throw ast::ScilabError(os.str(), 999, (*e.getArgs().begin())->getLocation());
605         }
606         out.push_back(_out);
607     }
608
609     return true;
610 }
611
612 InternalType* ImplicitList::extract(typed_list* _pArgs)
613 {
614     int iDims = (int)_pArgs->size();
615     typed_list pArg;
616     InternalType* pOut = NULL;
617     int index = 0;
618
619     int* piMaxDim = new int[iDims];
620     int* piCountDim = new int[iDims];
621
622     //evaluate each argument and replace by appropriate value and compute the count of combinations
623     int iSeqCount = checkIndexesArguments(this, _pArgs, &pArg, piMaxDim, piCountDim);
624     if (iSeqCount == 0)
625     {
626         //free pArg content
627         cleanIndexesArguments(_pArgs, &pArg);
628         return createEmptyDouble();
629     }
630
631     if (iDims == 1 && iSeqCount == 1)
632     {
633         if (piMaxDim[0] > 0 && piMaxDim[0] <= 3)
634         {
635             //standard case a(1)
636             Double* pDbl = pArg[0]->getAs<Double>();
637             index = (int)pDbl->get()[0] - 1;
638         }
639         else
640         {
641             index = 0;
642         }
643     }
644     else
645     {
646         int* piDims = new int[iDims];
647         for (int i = 0 ; i < iDims ; i++)
648         {
649             piDims[i] = 1;
650         }
651
652         for (int i = 0 ; i < iSeqCount ; i++)
653         {
654             int* pIndex = new int[iDims];
655             for (int j = 0 ; j < iDims ; j++)
656             {
657                 Double* pDbl = pArg[j]->getAs<Double>();
658                 pIndex[j] = (int)pDbl->get()[i] - 1;
659             }
660
661             index = getIndexWithDims(pIndex, piDims, iDims);
662         }
663     }
664
665     switch (index)
666     {
667         case 0 :
668             pOut = getStart();
669             break;
670         case 1 :
671             pOut = getStep();
672             break;
673         case 2 :
674             pOut = getEnd();
675             break;
676         default :
677             pOut = NULL;
678             break;
679     }
680
681     //free pArg content
682     cleanIndexesArguments(_pArgs, &pArg);
683
684     delete[] piMaxDim;
685     delete[] piCountDim;
686     return pOut;
687 }
688 }
689
690 std::wstring printInLinePoly(types::SinglePoly* _pPoly, std::wstring _stVar)
691 {
692     std::wostringstream ostr;
693     double* pdblIn = _pPoly->get();
694     for (int i = 0 ; i < _pPoly->getSize() ; i++)
695     {
696
697         if (pdblIn[i] != 0)
698         {
699             DoubleFormat df;
700             getDoubleFormat(pdblIn[i], &df);
701             df.bPrintPoint = ostr.str().size() != 0;
702             df.bPrintPlusSign = true;
703             df.bPrintOne = i == 0;
704             df.bPaddSign = false;
705             df.bPrintBlank = false;
706             df.bPrintPlusSign = false;
707
708             addDoubleValue(&ostr, pdblIn[i], &df);
709             if (i != 0)
710             {
711                 ostr << _stVar;
712                 if (i > 1)
713                 {
714                     ostr << "^" << i;
715                 }
716             }
717         }
718     }
719     return ostr.str();
720 }
721
722 std::wstring printDouble(types::Double* _pD)
723 {
724     std::wostringstream ostr;
725     DoubleFormat df;
726     getDoubleFormat(_pD->get(0), &df);
727     df.bPrintPoint = false;
728     df.bPaddSign = true;
729     df.bPaddSign = false;
730     df.bPrintBlank = false;
731     addDoubleValue(&ostr, _pD->get(0), &df);
732     return ostr.str();
733 }
734
735 long long convert_input(types::InternalType* _poIT)
736 {
737     long long llValue = 0;
738     switch (_poIT->getType())
739     {
740         case types::GenericType::ScilabDouble :
741             llValue = static_cast<long long>(_poIT->getAs<types::Double>()->get(0));
742             break;
743         case types::GenericType::ScilabInt8 :
744             llValue = static_cast<long long>(_poIT->getAs<types::Int8>()->get(0));
745             break;
746         case types::GenericType::ScilabUInt8 :
747             llValue = static_cast<long long>(_poIT->getAs<types::UInt8>()->get(0));
748             break;
749         case types::GenericType::ScilabInt16 :
750             llValue = static_cast<long long>(_poIT->getAs<types::Int16>()->get(0));
751             break;
752         case types::GenericType::ScilabUInt16 :
753             llValue = static_cast<long long>(_poIT->getAs<types::UInt16>()->get(0));
754             break;
755         case types::GenericType::ScilabInt32 :
756             llValue = static_cast<long long>(_poIT->getAs<types::Int32>()->get(0));
757             break;
758         case types::GenericType::ScilabUInt32 :
759             llValue = static_cast<long long>(_poIT->getAs<types::UInt32>()->get(0));
760             break;
761         case types::GenericType::ScilabInt64 :
762             llValue = static_cast<long long>(_poIT->getAs<types::Int64>()->get(0));
763             break;
764         case types::GenericType::ScilabUInt64 :
765             llValue = static_cast<long long>(_poIT->getAs<types::UInt64>()->get(0));
766             break;
767         default:
768             // FIXME : Trigger an error ??
769             break;
770     }
771     return llValue;
772 }
773
774 unsigned long long convert_unsigned_input(types::InternalType* _poIT)
775 {
776     unsigned long long ullValue = 0;
777     switch (_poIT->getType())
778     {
779         case types::GenericType::ScilabDouble :
780             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::Double>()->get(0));
781             break;
782         case types::GenericType::ScilabInt8 :
783             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::Int8>()->get(0));
784             break;
785         case types::GenericType::ScilabUInt8 :
786             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::UInt8>()->get(0));
787             break;
788         case types::GenericType::ScilabInt16 :
789             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::Int16>()->get(0));
790             break;
791         case types::GenericType::ScilabUInt16 :
792             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::UInt16>()->get(0));
793             break;
794         case types::GenericType::ScilabInt32 :
795             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::Int32>()->get(0));
796             break;
797         case types::GenericType::ScilabUInt32 :
798             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::UInt32>()->get(0));
799             break;
800         case types::GenericType::ScilabInt64 :
801             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::Int64>()->get(0));
802             break;
803         case types::GenericType::ScilabUInt64 :
804             ullValue = static_cast<unsigned long long>(_poIT->getAs<types::UInt64>()->get(0));
805             break;
806         default:
807             // FIXME : Trigger an error ??
808             break;
809     }
810     return ullValue;
811
812 }