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