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