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