f5fcf31a917800318f6acae0b5b660e62057ccd6
[scilab.git] / scilab / modules / api_scilab / src / cpp / api_list.cpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2009 - 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.1-en.txt
10 *
11 * Please note that piece of code will be rewrited for the Scilab 6 family
12 * However, the API (profile of the functions in the header files) will be
13 * still available and supported in Scilab 6.
14 */
15
16 #include <vector>
17 #include <map>
18 #include <string>
19 #include "list.hxx"
20 #include "tlist.hxx"
21 #include "mlist.hxx"
22 #include "gatewaystruct.hxx"
23 #include "double.hxx"
24 #include "string.hxx"
25 #include "int.hxx"
26 #include "context.hxx"
27
28 extern "C"
29 {
30 #include <stdio.h>
31 #include <string.h>
32 #include "call_scilab.h"
33 #include "doublecomplex.h"
34 #include "api_scilab.h"
35 #include "api_internal_common.h"
36 #include "api_internal_double.h"
37 #include "api_internal_poly.h"
38 #include "api_internal_int.h"
39 #include "api_internal_sparse.h"
40 #include "api_internal_boolean_sparse.h"
41 #include "api_internal_pointer.h"
42 #include "localization.h"
43 }
44
45 using namespace types;
46
47 //internal functions
48 static SciErr createCommonList(void* _pvCtx, int _iVar, int _iListType, int _iNbItem, int** _piAddress);
49 static SciErr createCommonListInList(void* _pvCtx, int _iVar, const char* _pstName, int* _piParent, int _iItemPos, int _iListType, int _iNbItem, int** _piAddress, int iNamed);
50 static SciErr createCommonNamedList(void* _pvCtx, const char* _pstName, int _iListType, int _iNbItem, int** _piAddress);
51 static SciErr createCommonListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iListType, int _iNbItem, int** _piAddress);
52 static SciErr getCommonListInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iListType, int** _piAddress);
53 static SciErr getCommomListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iListType, int** _piAddress);
54 static SciErr readCommonNamedList(void* _pvCtx, const char* _pstName, int _iListType, int* _piNbItem, int** _piAddress);
55 static SciErr fillCommonList(void* _pvCtx, int* _piAddress, int _iListType, int _iNbItem);
56 static int isKindOfList(int* _piNode);
57 static int getParentList(void* _pvCtx, int* _piStart, int* _piToFind, int* _piDepth, int** _piParent);
58 static void closeList(int _iVar, int *_piEnd);
59 static void updateListOffset(void* _pvCtx, int _iVar, int *_piCurrentNode, int _iItemPos, int *_piEnd);
60 static void updateNamedListOffset(void* _pvCtx, int _iVar, const char* _pstName, int *_piCurrentNode, int _iItemPos, int *_piEnd);
61 static void updateCommunListOffset(void* _pvCtx, int _iVar, const char* _pstName, int *_piCurrentNode, int _iItemPos, int *_piEnd);
62
63 static SciErr allocCommonMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, double **_pdblReal, double **_pdblImg);
64 static SciErr getCommonMatrixOfDoubleInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg);
65 static SciErr createCommonMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg);
66 static SciErr fillCommonMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg);
67 static SciErr createCommomMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg);
68 static SciErr readCommonMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, double* _pdblReal, double* _pdblImg);
69 static SciErr allocCommonItemInList(void* _pvCtx, int* _piParent, int _iItemPos, int** _piChildAddr);
70 static SciErr fillMatrixOfBoolInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int** _piBool);
71 static SciErr getCommonMatrixOfPolyInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg);
72 static SciErr createCommonMatrixOfPolyInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, char* _pstVarName, int _iComplex, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg);
73 static SciErr createCommonMatrixOfPolyInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, char* _pstVarName, int _iComplex, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg);
74 static SciErr readCommonMatrixOfPolyInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg);
75 static SciErr fillCommonMatrixOfPolyInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, char* _pstVarName, int _iComplex, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg, int* _piTotalLen);
76 static SciErr fillCommonMatrixOfStringInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const char* const* _pstStrings, int* _piTotalLen);
77 static SciErr readCommonSparseMatrixInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg);
78 static SciErr createCommonSparseMatrixInList(void* _pvCtx, int _iVar, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal, const double* _pdblImg);
79 static SciErr createCommonSparseMatrixInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal, const double* _pdblImg);
80
81 struct ListInfo
82 {
83     ListInfo(int* _piAddr, int _iLast) : m_piAddr(_piAddr), m_iLast(_iLast) {};
84     int* m_piAddr;
85     int m_iLast;
86 };
87
88 typedef std::vector<ListInfo*> VectListInfo;
89 typedef std::map<int, VectListInfo*> StackList;
90 typedef std::map<std::string, VectListInfo*> StackNamedList;
91 static StackList stackListPosition;
92 static StackNamedList stackNamedListPosition;
93
94
95 // Push a list address on the stackListPosition
96 static void pushListAddress(int _iRhsPos, int* _piAddr)
97 {
98     if (stackListPosition.find(_iRhsPos) == stackListPosition.end())
99     {
100         VectListInfo* pVect = new VectListInfo();
101         pVect->push_back(new ListInfo(_piAddr, 0));
102         stackListPosition[_iRhsPos] = pVect;
103     }
104     else
105     {
106         stackListPosition[_iRhsPos]->push_back(new ListInfo(_piAddr, 0));
107     }
108 }
109
110 static void pushNamedListAddress(std::string _stNamedList, int* _piAddr)
111 {
112     if (stackNamedListPosition.find(_stNamedList) == stackNamedListPosition.end())
113     {
114         VectListInfo* pVect = new VectListInfo();
115         pVect->push_back(new ListInfo(_piAddr, 0));
116         stackNamedListPosition[_stNamedList] = pVect;
117     }
118     else
119     {
120         stackNamedListPosition[_stNamedList]->push_back(new ListInfo(_piAddr, 0));
121     }
122 }
123
124 // Pop a list address from the stackListPosition
125 static void popListAddress(int _iRhsPos)
126 {
127     StackList::iterator it = stackListPosition.find(_iRhsPos);
128     if (it != stackListPosition.end())
129     {
130         delete it->second->back();
131         it->second->pop_back();
132         if (it->second->size() > 0 && it->second->back()->m_iLast == 1)
133         {
134             //close cascade
135             popListAddress(_iRhsPos);
136         }
137
138         StackList::iterator jt = stackListPosition.find(_iRhsPos);
139         if (jt != stackListPosition.end() && jt->second->empty())
140         {
141             delete jt->second;
142             stackListPosition.erase(jt);
143             //TODO : check to close list
144         }
145     }
146 }
147
148 static void popNamedListAddress(std::string _stNamedList)
149 {
150     StackNamedList::iterator it = stackNamedListPosition.find(_stNamedList);
151     // FIXME
152     //    if (it != stackNamedListPosition.end())
153     //    {
154     //        delete it->second->back();
155     //        it->second->pop_back();
156     //        if (it->second->size() > 0 && it->second->back()->m_iLast == 1)
157     //        {
158     //            //close cascade
159     //            popNamedListAddress(_stNamedList);
160     //        }
161     //
162     //        StackNamedList::iterator jt = stackNamedListPosition.find(_stNamedList);
163     //        if (jt != stackNamedListPosition.end() && jt->second->empty())
164     //        {
165     //            int iVarID[nsiz];
166     //            delete jt->second;
167     //            stackNamedListPosition.erase(jt);
168     //            C2F(str2name)(_stNamedList.c_str(), iVarID, (unsigned long)_stNamedList.size());
169     //            createNamedVariable(iVarID);
170     //        }
171     //    }
172 }
173
174 /*get last store address*/
175 int* getLastListAddress(int _iRhsPos, int _iItemPos)
176 {
177     StackList::iterator it = stackListPosition.find(_iRhsPos);
178     if (it == stackListPosition.end() || it->second->empty())
179     {
180         return NULL;
181     }
182
183     if (_iItemPos == it->second->back()->m_piAddr[1])
184     {
185         it->second->back()->m_iLast = 1;
186     }
187
188     return it->second->back()->m_piAddr;
189 }
190
191 static int* getLastNamedListAddress(std::string _stNamedList, int _iItemPos)
192 {
193     StackNamedList::iterator it = stackNamedListPosition.find(_stNamedList);
194     if (it == stackNamedListPosition.end() || it->second->empty())
195     {
196         return NULL;
197     }
198
199     if (_iItemPos == it->second->back()->m_piAddr[1])
200     {
201         it->second->back()->m_iLast = 1;
202     }
203
204     return it->second->back()->m_piAddr;
205 }
206
207
208 //get address list
209 static void getListAdressses(int _iRhsPos, int** _piAddresses)
210 {
211     StackList::iterator it = stackListPosition.find(_iRhsPos);
212     if (it == stackListPosition.end() || it->second->empty() || _piAddresses == NULL)
213     {
214         return;
215     }
216
217     VectListInfo::iterator vit;
218     int i = 0;
219     for (vit = it->second->begin() ; vit != it->second->end() ; vit++, i++)
220     {
221         _piAddresses[i] = (*vit)->m_piAddr;
222     }
223 }
224
225 static void getNamedListAdressses(std::string _stName, int** _piAddresses)
226 {
227     StackNamedList::iterator it = stackNamedListPosition.find(_stName);
228     if (it == stackNamedListPosition.end() || it->second->empty() || _piAddresses == NULL)
229     {
230         return;
231     }
232
233     VectListInfo::iterator vit;
234     int i = 0;
235     for (vit = it->second->begin() ; vit != it->second->end() ; vit++, i++)
236     {
237         _piAddresses[i] = (*vit)->m_piAddr;
238     }
239 }
240
241 //get Depth of list
242 static int getDepthList(int _iRhsPos)
243 {
244     StackList::iterator it = stackListPosition.find(_iRhsPos);
245     if (it == stackListPosition.end() || it->second->empty())
246     {
247         return 0;
248     }
249     return (int)it->second->size();
250 }
251
252 static int getDepthNamedList(std::string _stNamedList)
253 {
254     StackNamedList::iterator it = stackNamedListPosition.find(_stNamedList);
255     if (it == stackNamedListPosition.end() || it->second->empty())
256     {
257         return 0;
258     }
259     return (int)it->second->size();
260 }
261
262 const char* getListTypeName(int _iType)
263 {
264     switch (_iType)
265     {
266         case sci_list :
267             return "list";
268             break;
269         case sci_tlist :
270             return "tlist";
271             break;
272         case sci_mlist :
273             return "mlist";
274             break;
275         default:
276             break;
277     }
278     return "";
279 }
280
281 SciErr getListItemNumber(void* _pvCtx, int* _piAddress, int* _piNbItem)
282 {
283     int iType = 0;
284
285     SciErr sciErr = getVarType(_pvCtx, _piAddress, &iType);
286     if (sciErr.iErr)
287     {
288         addErrorMessage(&sciErr, API_ERROR_LIST_ITEM_NUMBER, _("%s: Unable to get item number of list"), "getListItemNumber");
289         return sciErr;
290     }
291
292     List* pL = (List*)_piAddress;
293     switch (iType)
294     {
295         case sci_list :
296         case sci_mlist :
297         case sci_tlist :
298             *_piNbItem = pL->getSize();
299             break;
300         default :
301             addErrorMessage(&sciErr, API_ERROR_INVALID_LIST_TYPE, _("%s: Invalid argument type, %s expected"), "getListItemNumber", _("list"));
302             return sciErr;
303     }
304     return sciErr;
305 }
306
307 SciErr getListItemAddress(void* _pvCtx, int* _piAddress, int _iItemNum, int** _piItemAddress)
308 {
309     int iItem      = 0;
310     int* piOffset    = NULL;
311     int* piItemAddress = NULL;
312
313     SciErr sciErr = sciErrInit();
314
315     //get item count
316     sciErr = getListItemNumber(_pvCtx, _piAddress, &iItem);
317     if (sciErr.iErr)
318     {
319         addErrorMessage(&sciErr, API_ERROR_GET_ITEM_ADDRESS, _("%s: Unable to get address of item #%d in argument #%d"), "getListItemAddress", _iItemNum + 1, getRhsFromAddress(_pvCtx, _piAddress));
320         return sciErr;
321     }
322
323     if (_iItemNum > iItem)
324     {
325         addErrorMessage(&sciErr, API_ERROR_GET_ITEM_ADDRESS, _("%s: Unable to get address of item #%d in argument #%d"), "getListItemAddress", _iItemNum + 1, getRhsFromAddress(_pvCtx, _piAddress));
326         return sciErr;
327     }
328
329     List* pL = (List*)_piAddress;
330     //get offset of item array
331     InternalType* pIT = pL->get(_iItemNum - 1);
332     if (pIT->isListUndefined())
333     {
334         *_piItemAddress = NULL;
335     }
336     else
337     {
338         *_piItemAddress = (int*)pIT;
339     }
340     return sciErr;
341 }
342
343 SciErr createList(void* _pvCtx, int _iVar, int _iNbItem, int** _piAddress)
344 {
345     return createCommonList(_pvCtx, _iVar, sci_list, _iNbItem, _piAddress);
346 }
347
348 SciErr createMList(void* _pvCtx, int _iVar, int _iNbItem, int** _piAddress)
349 {
350     return createCommonList(_pvCtx, _iVar, sci_mlist, _iNbItem, _piAddress);
351 }
352
353 SciErr createTList(void* _pvCtx, int _iVar, int _iNbItem, int** _piAddress)
354 {
355     return createCommonList(_pvCtx, _iVar, sci_tlist, _iNbItem, _piAddress);
356 }
357
358 SciErr createNamedList(void* _pvCtx, const char* _pstName, int _iNbItem, int** _piAddress)
359 {
360     return createCommonNamedList(_pvCtx, _pstName, sci_list, _iNbItem, _piAddress);
361 }
362
363 SciErr createNamedTList(void* _pvCtx, const char* _pstName, int _iNbItem, int** _piAddress)
364 {
365     return createCommonNamedList(_pvCtx, _pstName, sci_tlist, _iNbItem, _piAddress);
366 }
367
368 SciErr createNamedMList(void* _pvCtx, const char* _pstName, int _iNbItem, int** _piAddress)
369 {
370     return createCommonNamedList(_pvCtx, _pstName, sci_mlist, _iNbItem, _piAddress);
371 }
372
373 SciErr createNamedList(void* _pvCtx, const char* _pstName, int _iNbItem, int** _piAddress, bool useStack)
374 {
375
376     return createCommonNamedList(_pvCtx, _pstName, sci_list, _iNbItem, _piAddress);
377 }
378
379 SciErr createNamedTList(void* _pvCtx, const char* _pstName, int _iNbItem, int** _piAddress, bool useStack)
380 {
381     return createCommonNamedList(_pvCtx, _pstName, sci_tlist, _iNbItem, _piAddress);
382 }
383
384 SciErr createNamedMList(void* _pvCtx, const char* _pstName, int _iNbItem, int** _piAddress, bool useStack)
385 {
386     return createCommonNamedList(_pvCtx, _pstName, sci_mlist, _iNbItem, _piAddress);
387 }
388
389 static SciErr createCommonNamedList(void* _pvCtx, const char* _pstName, int _iListType, int _iNbItem, int** _piAddress)
390 {
391     SciErr sciErr = sciErrInit();
392 #if 0
393     int iVarID[nsiz];
394     int iSaveRhs   = Rhs;
395     int iSaveTop   = Top;
396     int *piAddr    = NULL;
397     int* piEnd    = NULL;
398
399     if (!checkNamedVarFormat(_pvCtx, _pstName))
400     {
401         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createCommonNamedList", _pstName);
402         return sciErr;
403     }
404
405     C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
406     Top = Top + Nbvars + 1;
407
408     getNewVarAddressFromPosition(_pvCtx, Top, &piAddr);
409
410     sciErr = fillCommonList(_pvCtx, piAddr, _iListType, _iNbItem);
411     if (sciErr.iErr)
412     {
413         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_LIST, _("%s: Unable to create %s named \"%s\""), "createNamedList", getListTypeName(_iListType), _pstName);
414         return sciErr;
415     }
416
417     piEnd = piAddr + 3 + _iNbItem + !(_iNbItem % 2);
418     closeList(Top, piEnd);
419
420     Rhs = 0;
421
422     if (_iNbItem != 0)
423     {
424         pushNamedListAddress(_pstName, piAddr);
425     }
426     else
427     {
428         //Add name in stack reference list
429         createNamedVariable(iVarID);
430     }
431
432     Top      = iSaveTop;
433     Rhs      = iSaveRhs;
434 #endif
435
436     return sciErr;
437 }
438
439 static SciErr createCommonList(void* _pvCtx, int _iVar, int _iListType, int _iNbItem, int** _piAddress)
440 {
441     SciErr sciErr = sciErrInit();
442     if (_pvCtx == NULL)
443     {
444         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "createCommonList");
445         return sciErr;
446     }
447
448     GatewayStruct* pStr = (GatewayStruct*)_pvCtx;
449     typed_list in = *pStr->m_pIn;
450     InternalType** out = pStr->m_pOut;
451
452     List* pL = NULL;
453     try
454     {
455         if (_iListType == sci_list)
456         {
457             pL = new List();
458         }
459         else if (_iListType == sci_mlist)
460         {
461             pL = new MList();
462         }
463         else if (_iListType == sci_tlist)
464         {
465             pL = new TList();
466         }
467     }
468     catch (const ast::ScilabError& se)
469     {
470         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: %ls"), "createCommonList", se.GetErrorMessage().c_str());
471         return sciErr;
472     }
473
474     if (pL == NULL)
475     {
476         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), "createCommonList");
477         return sciErr;
478     }
479
480     int rhs = _iVar - *getNbInputArgument(_pvCtx);
481     out[rhs - 1] = pL;
482     *_piAddress = (int*)pL;
483     return sciErr;
484 }
485
486 SciErr fillCommonList(void* _pvCtx, int* _piAddress, int _iListType, int _iNbItem)
487 {
488     SciErr sciErr = sciErrInit();
489     int* piOffset = NULL;
490
491     _piAddress[0] = _iListType;
492     _piAddress[1] = _iNbItem;
493
494     piOffset  = _piAddress + 2;
495     piOffset[0] = 1; //always
496
497     for (int i = 0 ; i < _iNbItem; i++)
498     {
499         //initialize item offset
500         piOffset[i + 1] = -1;
501     }
502     return sciErr;
503 }
504
505 SciErr readNamedList(void* _pvCtx, const char* _pstName, int* _piNbItem, int** _piAddress)
506 {
507     return readCommonNamedList(_pvCtx, _pstName, sci_list, _piNbItem, _piAddress);
508 }
509
510 SciErr readNamedTList(void* _pvCtx, const char* _pstName, int* _piNbItem, int** _piAddress)
511 {
512     return readCommonNamedList(_pvCtx, _pstName, sci_tlist, _piNbItem, _piAddress);
513 }
514
515 SciErr readNamedMList(void* _pvCtx, const char* _pstName, int* _piNbItem, int** _piAddress)
516 {
517     return readCommonNamedList(_pvCtx, _pstName, sci_mlist, _piNbItem, _piAddress);
518 }
519
520 static SciErr readCommonNamedList(void* _pvCtx, const char* _pstName, int _iListType, int* _piNbItem, int** _piAddress)
521 {
522     int* piAddr  = NULL;
523     int iNbItem  = 0;
524
525     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
526     if (sciErr.iErr)
527     {
528         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_LIST, _("%s: Unable to get variable \"%s\""), "readNamedList", _pstName);
529         return sciErr;
530     }
531
532     if (piAddr[0] != _iListType)
533     {
534         addErrorMessage(&sciErr, API_ERROR_INVALID_LIST_TYPE, _("%s: Invalid argument type, %s expected"), "readNamedList", getListTypeName(_iListType));
535         return sciErr;
536     }
537
538     sciErr = getListItemNumber(_pvCtx, piAddr, &iNbItem);
539     if (sciErr.iErr)
540     {
541         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_LIST, _("%s: Unable to get variable \"%s\""), "readNamedList", _pstName);
542         return sciErr;
543     }
544
545     *_piNbItem = iNbItem;
546     *_piAddress = piAddr;
547
548     return sciErr;
549 }
550
551 SciErr getListInList(void* _pvCtx, int* _piParent, int _iItemPos, int** _piAddress)
552 {
553     return getCommonListInList(_pvCtx, _piParent, _iItemPos, sci_list, _piAddress);
554 }
555
556 SciErr getTListInList(void* _pvCtx, int* _piParent, int _iItemPos, int** _piAddress)
557 {
558     return getCommonListInList(_pvCtx, _piParent, _iItemPos, sci_tlist, _piAddress);
559 }
560
561 SciErr getMListInList(void* _pvCtx, int* _piParent, int _iItemPos, int** _piAddress)
562 {
563     return getCommonListInList(_pvCtx, _piParent, _iItemPos, sci_mlist, _piAddress);
564 }
565
566 SciErr getCommonListInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iListType, int** _piAddress)
567 {
568     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, _piAddress);
569     if (sciErr.iErr)
570     {
571         addErrorMessage(&sciErr, API_ERROR_GET_LIST_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "getListInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
572         return sciErr;
573     }
574
575     if ((*_piAddress)[0] != _iListType)
576     {
577         addErrorMessage(&sciErr, API_ERROR_INVALID_LIST_TYPE, _("%s: Invalid argument type, %s expected"), "getListInList", getListTypeName(_iListType));
578         return sciErr;
579     }
580     return sciErr;
581 }
582
583 SciErr getListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int** _piAddress)
584 {
585     return getCommomListInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, sci_list, _piAddress);
586 }
587
588 SciErr getTListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int** _piAddress)
589 {
590     return getCommomListInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, sci_tlist, _piAddress);
591 }
592
593 SciErr getMListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int** _piAddress)
594 {
595     return getCommomListInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, sci_mlist, _piAddress);
596 }
597
598 SciErr getCommomListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iListType, int** _piAddress)
599 {
600     SciErr sciErr = sciErrInit();
601     int* piAddr  = NULL;
602
603     sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
604     if (sciErr.iErr)
605     {
606         addErrorMessage(&sciErr, API_ERROR_GET_LIST_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "getListInNamedList", _iItemPos + 1, _pstName);
607         return sciErr;
608     }
609
610     if (piAddr[0] != _iListType)
611     {
612         addErrorMessage(&sciErr, API_ERROR_INVALID_LIST_TYPE, _("%s: Invalid argument type, %s expected"), "getListInNamedList", getListTypeName(_iListType));
613         return sciErr;
614     }
615
616     *_piAddress = piAddr;
617     return sciErr;
618 }
619
620 SciErr createListInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iNbItem, int** _piAddress)
621 {
622     return createCommonListInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, sci_list, _iNbItem, _piAddress, 0);
623 }
624
625 SciErr createTListInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iNbItem, int** _piAddress)
626 {
627     return createCommonListInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, sci_tlist, _iNbItem, _piAddress, 0);
628 }
629
630 SciErr createMListInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iNbItem, int** _piAddress)
631 {
632     return createCommonListInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, sci_mlist, _iNbItem, _piAddress, 0);
633 }
634
635 static SciErr createCommonListInList(void* _pvCtx, int _iVar, const char* _pstName, int* _piParent, int _iItemPos, int _iListType, int _iNbItem, int** _piAddress, int iNamed)
636 {
637     SciErr sciErr = sciErrInit();
638     List* pParent = (List*)_piParent;
639     List* pChild = NULL;
640
641     if (_iListType == sci_list)
642     {
643         pChild = new List();
644     }
645     else if (_iListType == sci_mlist)
646     {
647         pChild = new MList();
648     }
649     else if (_iListType == sci_tlist)
650     {
651         pChild = new TList();
652     }
653
654     pParent->set(_iItemPos - 1, pChild);
655     *_piAddress = (int*)pChild;
656     return sciErr;
657 }
658
659 SciErr createListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iNbItem, int** _piAddress)
660 {
661     return createCommonListInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, sci_list, _iNbItem, _piAddress);
662 }
663
664 SciErr createTListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iNbItem, int** _piAddress)
665 {
666     return createCommonListInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, sci_tlist, _iNbItem, _piAddress);
667 }
668
669 SciErr createMListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iNbItem, int** _piAddress)
670 {
671     return createCommonListInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, sci_mlist, _iNbItem, _piAddress);
672 }
673
674 SciErr createCommonListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iListType, int _iNbItem, int** _piAddress)
675 {
676     SciErr sciErr = sciErrInit();
677 #if 0
678     int iVarID[nsiz];
679     int iSaveTop = Top;
680     int* piParent = getLastNamedListAddress(_pstName, _iItemPos);
681
682     if (!checkNamedVarFormat(_pvCtx, _pstName))
683     {
684         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createCommonListInNamedList", _pstName);
685         return sciErr;
686     }
687
688     C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
689     Top = Top + Nbvars + 1;
690
691     sciErr = createCommonListInList(_pvCtx, Top, _pstName, piParent, _iItemPos, _iListType, _iNbItem, _piAddress, 1);
692     if (sciErr.iErr)
693     {
694         addErrorMessage(&sciErr, API_ERROR_CREATE_LIST_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), "createListInList", _iItemPos + 1, _pstName);
695         return sciErr;
696     }
697
698     if (_iNbItem == 0 && _iItemPos == piParent[1])
699     {
700         popNamedListAddress(_pstName);
701     }
702
703     if (_iNbItem != 0)
704     {
705         //add new child address in stacklist
706         pushNamedListAddress(_pstName, *_piAddress);
707     }
708 #endif
709
710     return sciErr;
711 }
712
713 SciErr allocCommonItemInList(void* _pvCtx, int* _piParent, int _iItemPos, int** _piChildAddr)
714 {
715     SciErr sciErr = sciErrInit();
716     int* piOffset = NULL;
717
718     //Does previous items was already inserted
719     piOffset  = _piParent + 2;
720     if (piOffset[_iItemPos - 1] == -1)
721     {
722         //Previous items wasn't inserted
723         addErrorMessage(&sciErr, API_ERROR_NON_ORDERED_INSERTION, _("%s: Items must be inserted in order"), "allocItemInList");
724         return sciErr;
725     }
726
727     sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, _piChildAddr);
728     if (sciErr.iErr)
729     {
730         addErrorMessage(&sciErr, API_ERROR_ALLOC_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "allocItemInList", _iItemPos + 1);
731         return sciErr;
732     }
733
734     return sciErr;
735 }
736
737 /******************************
738 * Void and defined functions *
739 ******************************/
740 SciErr createVoidInNamedList(void* _pvCtx, const char* _pstName, int* /*_piParent*/, int _iItemPos)
741 {
742     SciErr sciErr = sciErrInit();
743 #if 0
744     int iVarID[nsiz];
745     int iNbItem         = 0;
746     int iSaveRhs        = Rhs;
747     int iSaveTop        = Top;
748     int* piEnd          = NULL;
749     int* piChildAddr    = NULL;
750     int* piOffset       = NULL;
751     int* piParent       = getLastNamedListAddress(_pstName, _iItemPos);
752
753     if (!checkNamedVarFormat(_pvCtx, _pstName))
754     {
755         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createVoidInNamedList", _pstName);
756         return sciErr;
757     }
758
759     C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
760     Top = Top + Nbvars + 1;
761
762     //Does item can be added in the list
763     sciErr = getListItemNumber(_pvCtx, piParent, &iNbItem);
764     if (sciErr.iErr)
765     {
766         addErrorMessage(&sciErr, API_ERROR_CREATE_VOID_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "createVoidInNamedList", _iItemPos + 1, getRhsFromAddress(_pvCtx, piParent));
767         return sciErr;
768     }
769
770     if (iNbItem < _iItemPos)
771     {
772         addErrorMessage(&sciErr, API_ERROR_ITEM_LIST_NUMBER, _("%s: Unable to create list item #%d in Scilab memory"), "createVoidInNamedList", _iItemPos + 1);
773         return sciErr;
774     }
775
776     sciErr = allocCommonItemInList(_pvCtx, piParent, _iItemPos, &piChildAddr);
777     if (sciErr.iErr)
778     {
779         addErrorMessage(&sciErr, API_ERROR_ALLOC_DOUBLE_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "createVoidInNamedList", _iItemPos + 1, getRhsFromAddress(_pvCtx, piParent));
780         return sciErr;
781     }
782
783     //set type, rows, cols complex at 0
784     piChildAddr[0]  = 0;
785     piChildAddr[1]  = 0;
786     piChildAddr[2]  = 0;
787     piChildAddr[3]  = 0;
788
789     piOffset            = piParent + 2;
790     piOffset[_iItemPos] = piOffset[_iItemPos - 1] + 2;
791
792     piEnd = piChildAddr + 4;
793     closeList(Top, piEnd);
794
795     if (_iItemPos == piParent[1])
796     {
797         updateNamedListOffset(_pvCtx, Top, _pstName, piParent, _iItemPos, piEnd);
798         popNamedListAddress(_pstName);
799     }
800
801     Top = iSaveTop;
802     Rhs = iSaveRhs;
803 #endif
804
805     return sciErr;
806 }
807
808 SciErr createUndefinedInNamedList(void* _pvCtx, const char* _pstName, int* /*_piParent*/, int _iItemPos)
809 {
810     SciErr sciErr = sciErrInit();
811 #if 0
812     int iVarID[nsiz];
813     int iNbItem         = 0;
814     int iSaveRhs        = Rhs;
815     int iSaveTop        = Top;
816     int* piEnd          = NULL;
817     int* piChildAddr    = NULL;
818     int* piOffset       = NULL;
819     int* piParent       = getLastNamedListAddress(_pstName, _iItemPos);
820
821     if (!checkNamedVarFormat(_pvCtx, _pstName))
822     {
823         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createUndefinedInNamedList", _pstName);
824         return sciErr;
825     }
826
827     C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
828     Top = Top + Nbvars + 1;
829
830     //Does item can be added in the list
831     sciErr = getListItemNumber(_pvCtx, piParent, &iNbItem);
832     if (sciErr.iErr)
833     {
834         addErrorMessage(&sciErr, API_ERROR_CREATE_VOID_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "createVoidInNamedList", _iItemPos + 1, getRhsFromAddress(_pvCtx, piParent));
835         return sciErr;
836     }
837
838     if (iNbItem < _iItemPos)
839     {
840         addErrorMessage(&sciErr, API_ERROR_ITEM_LIST_NUMBER, _("%s: Unable to create list item #%d in Scilab memory"), "createVoidInNamedList", _iItemPos + 1);
841         return sciErr;
842     }
843
844     sciErr = allocCommonItemInList(_pvCtx, piParent, _iItemPos, &piChildAddr);
845     if (sciErr.iErr)
846     {
847         addErrorMessage(&sciErr, API_ERROR_ALLOC_DOUBLE_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "createVoidInNamedList", _iItemPos + 1, getRhsFromAddress(_pvCtx, piParent));
848         return sciErr;
849     }
850
851     //undefined size == 0, so put previous offset
852     piOffset            = piParent + 2;
853     piOffset[_iItemPos] = piOffset[_iItemPos - 1];
854
855     piEnd = piChildAddr;
856     closeList(Top, piEnd);
857
858     if (_iItemPos == piParent[1])
859     {
860         updateNamedListOffset(_pvCtx, Top, _pstName, piParent, _iItemPos, piEnd);
861         popNamedListAddress(_pstName);
862     }
863
864     Top = iSaveTop;
865     Rhs = iSaveRhs;
866 #endif
867     return sciErr;
868 }
869
870 /*********************
871 * Double functions *
872 *********************/
873
874 SciErr getMatrixOfDoubleInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, double** _pdblReal)
875 {
876     return getCommonMatrixOfDoubleInList(_pvCtx, _piParent, _iItemPos, 0, _piRows, _piCols, _pdblReal, NULL);
877 }
878
879 SciErr getComplexMatrixOfDoubleInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg)
880 {
881     return getCommonMatrixOfDoubleInList(_pvCtx, _piParent, _iItemPos, 1, _piRows, _piCols, _pdblReal, _pdblImg);
882 }
883
884 static SciErr getCommonMatrixOfDoubleInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg)
885 {
886     int* piAddr  = NULL;
887
888     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
889     if (sciErr.iErr)
890     {
891         addErrorMessage(&sciErr, API_ERROR_GET_DOUBLE_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), _iComplex ? "getComplexMatrixOfDoubleInList" : "getMatrixOfDoubleInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
892         return sciErr;
893     }
894
895     sciErr = getCommonMatrixOfDouble(_pvCtx, piAddr, '$', _iComplex, _piRows, _piCols, _pdblReal, _pdblImg);
896     if (sciErr.iErr)
897     {
898         addErrorMessage(&sciErr, API_ERROR_GET_DOUBLE_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), _iComplex ? "getComplexMatrixOfDoubleInList" : "getMatrixOfDoubleInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
899         return sciErr;
900     }
901     return sciErr;
902 }
903
904 SciErr allocMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, double** _pdblReal)
905 {
906     return allocCommonMatrixOfDoubleInList(_pvCtx, _iVar, _piParent, _iItemPos, 0, _iRows, _iCols, _pdblReal, NULL);
907 }
908
909 SciErr allocComplexMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg)
910 {
911     return allocCommonMatrixOfDoubleInList(_pvCtx, _iVar, _piParent, _iItemPos, 1, _iRows, _iCols, _pdblReal, _pdblImg);
912 }
913
914 static SciErr allocCommonMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* /*_piParent*/, int _iItemPos, int _iComplex, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg)
915 {
916     SciErr sciErr = sciErrInit();
917 #if 0
918     int iNewPos     = Top - Rhs + _iVar;
919     int* piEnd      = NULL;
920     int* piParent   = getLastListAddress(_iVar, _iItemPos);
921
922     SciErr sciErr = fillCommonMatrixOfDoubleInList(_pvCtx, _iVar, piParent, _iItemPos, _iComplex, _iRows, _iCols, _pdblReal, _pdblImg);
923     if (sciErr.iErr)
924     {
925         addErrorMessage(&sciErr, API_ERROR_ALLOC_DOUBLE_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), _iComplex ? "allocComplexMatrixOfDoubleInList" : "allocMatrixOfDoubleInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, piParent));
926         return sciErr;
927     }
928
929     piEnd = (int*) (*_pdblReal + _iRows * _iCols * (_iComplex + 1));
930     closeList(iNewPos, piEnd);
931
932     if (_iItemPos == piParent[1])
933     {
934         updateListOffset(_pvCtx, _iVar, piParent, _iItemPos, piEnd);
935         popListAddress(_iVar);
936     }
937
938 #endif
939     return sciErr;
940 }
941
942 static SciErr fillCommonMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg)
943 {
944     int iNbItem    = 0;
945     int* piOffset   = NULL;
946     int* piChildAddr = NULL;
947
948     //Does item can be added in the list
949     SciErr sciErr = getListItemNumber(_pvCtx, _piParent, &iNbItem);
950     if (sciErr.iErr)
951     {
952         addErrorMessage(&sciErr, API_ERROR_ALLOC_DOUBLE_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), _iComplex ? "allocComplexMatrixOfDoubleInList" : "allocMatrixOfDoubleInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
953         return sciErr;
954     }
955
956     if (iNbItem < _iItemPos)
957     {
958         addErrorMessage(&sciErr, API_ERROR_ITEM_LIST_NUMBER, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexMatrixOfDoubleInList" : "createMatrixOfDoubleInList", _iItemPos + 1);
959         return sciErr;
960     }
961
962
963     sciErr = allocCommonItemInList(_pvCtx, _piParent, _iItemPos, &piChildAddr);
964     if (sciErr.iErr)
965     {
966         addErrorMessage(&sciErr, API_ERROR_ALLOC_DOUBLE_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), _iComplex ? "allocComplexMatrixOfDoubleInList" : "allocMatrixOfDoubleInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
967         return sciErr;
968     }
969
970     //sciErr = fillCommonMatrixOfDouble(_pvCtx, piChildAddr, _iComplex, _iRows, _iCols, _pdblReal, _pdblImg);
971     if (sciErr.iErr)
972     {
973         addErrorMessage(&sciErr, API_ERROR_ALLOC_DOUBLE_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), _iComplex ? "allocComplexMatrixOfDoubleInList" : "allocMatrixOfDoubleInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
974         return sciErr;
975     }
976
977     piOffset      = _piParent + 2;
978     piOffset[_iItemPos] = piOffset[_iItemPos - 1] + _iRows * _iCols * (_iComplex + 1) + 2;
979
980     return sciErr;
981 }
982
983 SciErr createMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const double* _pdblReal)
984 {
985     return createCommonMatrixOfDoubleInList(_pvCtx, _iVar, _piParent, _iItemPos, 0, _iRows, _iCols, _pdblReal, NULL);
986 }
987
988 SciErr createComplexMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg)
989 {
990     return createCommonMatrixOfDoubleInList(_pvCtx, _iVar, _piParent, _iItemPos, 1, _iRows, _iCols, _pdblReal, _pdblImg);
991 }
992
993 SciErr createComplexZMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const doublecomplex* _pdblData)
994 {
995     double *pdblReal = NULL;
996     double *pdblImg  = NULL;
997
998     SciErr sciErr = allocCommonMatrixOfDoubleInList(_pvCtx, _iVar, _piParent, _iItemPos, 1, _iRows, _iCols, &pdblReal, &pdblImg);
999     if (sciErr.iErr)
1000     {
1001         addErrorMessage(&sciErr, API_ERROR_CREATE_DOUBLE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createComplexZMatrixOfDoubleInList", _iItemPos + 1);
1002         return sciErr;
1003     }
1004
1005     vGetPointerFromDoubleComplex(_pdblData, _iRows * _iCols, pdblReal, pdblImg);
1006
1007     return sciErr;
1008 }
1009
1010 SciErr createCommonMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* /*_piParent*/, int _iItemPos, int _iComplex, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg)
1011 {
1012     double *pdblReal = NULL;
1013     double *pdblImg  = NULL;
1014
1015     SciErr sciErr = allocCommonMatrixOfDoubleInList(_pvCtx, _iVar, NULL/*_piParent*/, _iItemPos, _iComplex, _iRows, _iCols, &pdblReal, &pdblImg);
1016     if (sciErr.iErr)
1017     {
1018         addErrorMessage(&sciErr, API_ERROR_CREATE_DOUBLE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexMatrixOfDoubleInList" : "createMatrixOfDoubleInList", _iItemPos + 1);
1019         return sciErr;
1020     }
1021
1022     if (_pdblReal != NULL)
1023     {
1024         memcpy(pdblReal, _pdblReal, _iRows * _iCols * sizeof(double));
1025     }
1026
1027     if (_iComplex && _pdblImg != NULL)
1028     {
1029         memcpy(pdblImg, _pdblImg, _iRows * _iCols * sizeof(double));
1030     }
1031     return sciErr;
1032 }
1033
1034 SciErr createMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const double* _pdblReal)
1035 {
1036     return createCommomMatrixOfDoubleInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 0, _iRows, _iCols, _pdblReal, NULL);
1037 }
1038
1039 SciErr createComplexMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg)
1040 {
1041     return createCommomMatrixOfDoubleInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 1, _iRows, _iCols, _pdblReal, _pdblImg);
1042 }
1043
1044 SciErr createComplexZMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* /*_piParent*/, int _iItemPos, int _iRows, int _iCols, const doublecomplex* _pdblData)
1045 {
1046     SciErr sciErr = sciErrInit();
1047 #if 0
1048     int iVarID[nsiz];
1049     int iSaveRhs        = Rhs;
1050     int iSaveTop        = Top;
1051     int *piAddr         = NULL;
1052     double *pdblReal    = NULL;
1053     double *pdblImg     = NULL;
1054     int* piEnd          = NULL;
1055     int* piChildAddr    = NULL;
1056     int* piParent       = getLastNamedListAddress(_pstName, _iItemPos);
1057
1058     if (!checkNamedVarFormat(_pvCtx, _pstName))
1059     {
1060         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createComplexZMatrixOfDoubleInNamedList", _pstName);
1061         return sciErr;
1062     }
1063
1064     C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
1065     Top = Top + Nbvars + 1;
1066
1067     getNewVarAddressFromPosition(_pvCtx, Top, &piAddr);
1068
1069     sciErr = fillCommonMatrixOfDoubleInList(_pvCtx, Top, piParent, _iItemPos, 1, _iRows, _iCols, &pdblReal, &pdblImg);
1070     if (sciErr.iErr)
1071     {
1072         addErrorMessage(&sciErr, API_ERROR_CREATE_ZDOUBLE_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), "createComplexZMatrixOfDoubleInNamedList", _iItemPos + 1, _pstName);
1073         return sciErr;
1074     }
1075
1076     vGetPointerFromDoubleComplex(_pdblData, _iRows * _iCols, pdblReal, pdblImg);
1077
1078     sciErr = allocCommonItemInList(_pvCtx, piParent, _iItemPos, &piChildAddr);
1079     if (sciErr.iErr)
1080     {
1081         addErrorMessage(&sciErr, API_ERROR_CREATE_ZDOUBLE_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), "createComplexZMatrixOfDoubleInNamedList", _iItemPos + 1, _pstName);
1082         return sciErr;
1083     }
1084
1085     piEnd = piChildAddr + 4 + (_iRows * _iCols * 4);//4 -> 2*2 real + img * double
1086     closeList(Top, piEnd);
1087
1088     if (_iItemPos == piParent[1])
1089     {
1090         updateNamedListOffset(_pvCtx, Top, _pstName, piParent, _iItemPos, piEnd);
1091         popNamedListAddress(_pstName);
1092     }
1093
1094     Top = iSaveTop;
1095     Rhs = iSaveRhs;
1096 #endif
1097
1098     return sciErr;
1099 }
1100
1101 SciErr createCommomMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* /*_piParent*/, int _iItemPos, int _iComplex, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg)
1102 {
1103     SciErr sciErr = sciErrInit();
1104 #if 0
1105     int iVarID[nsiz];
1106     int iSaveRhs        = Rhs;
1107     int iSaveTop        = Top;
1108     int *piAddr         = NULL;
1109     double *pdblReal    = NULL;
1110     double *pdblImg     = NULL;
1111     int* piEnd          = NULL;
1112     int* piChildAddr    = NULL;
1113     int* piParent       = getLastNamedListAddress(_pstName, _iItemPos);
1114
1115     if (!checkNamedVarFormat(_pvCtx, _pstName))
1116     {
1117         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createCommomMatrixOfDoubleInNamedList", _pstName);
1118         return sciErr;
1119     }
1120
1121     C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
1122     Top = Top + Nbvars + 1;
1123
1124     getNewVarAddressFromPosition(_pvCtx, Top, &piAddr);
1125
1126     sciErr = fillCommonMatrixOfDoubleInList(_pvCtx, Top, piParent, _iItemPos, _iComplex, _iRows, _iCols, &pdblReal, &pdblImg);
1127     if (sciErr.iErr)
1128     {
1129         addErrorMessage(&sciErr, API_ERROR_CREATE_DOUBLE_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), _iComplex ? "createComplexMatrixOfDoubleInNamedList" : "createMatrixOfDoubleInNamedList", _iItemPos + 1, _pstName);
1130         return sciErr;
1131     }
1132
1133     memcpy(pdblReal, _pdblReal, sizeof(double) * _iRows * _iCols);
1134     if (_iComplex)
1135     {
1136         memcpy(pdblImg, _pdblImg, sizeof(double) * _iRows * _iCols);
1137     }
1138
1139     sciErr = allocCommonItemInList(_pvCtx, piParent, _iItemPos, &piChildAddr);
1140     if (sciErr.iErr)
1141     {
1142         addErrorMessage(&sciErr, API_ERROR_CREATE_DOUBLE_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), _iComplex ? "createComplexMatrixOfDoubleInNamedList" : "createMatrixOfDoubleInNamedList", _iItemPos + 1, _pstName);
1143         return sciErr;
1144     }
1145
1146     piEnd = piChildAddr + 4 + (_iRows * _iCols * 2 * (_iComplex + 1));
1147     closeList(Top, piEnd);
1148
1149     if (_iItemPos == piParent[1])
1150     {
1151         updateNamedListOffset(_pvCtx, Top, _pstName, piParent, _iItemPos, piEnd);
1152         popNamedListAddress(_pstName);
1153     }
1154
1155     Top = iSaveTop;
1156     Rhs = iSaveRhs;
1157 #endif
1158
1159     return sciErr;
1160 }
1161
1162 SciErr readMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, double* _pdblReal)
1163 {
1164     return readCommonMatrixOfDoubleInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 0, _piRows, _piCols, _pdblReal, NULL);
1165 }
1166
1167 SciErr readComplexMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, double* _pdblReal, double* _pdblImg)
1168 {
1169     return readCommonMatrixOfDoubleInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 1, _piRows, _piCols, _pdblReal, _pdblImg);
1170 }
1171
1172 static SciErr readCommonMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, double* _pdblReal, double* _pdblImg)
1173 {
1174     SciErr sciErr = sciErrInit();
1175     int iNbItem    = 0;
1176     int* piAddr    = NULL;
1177     int* piRoot    = NULL;
1178     double* pdblReal = NULL;
1179     double* pdblImg  = NULL;
1180
1181     if (_piParent == NULL)
1182     {
1183         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
1184         if (sciErr.iErr)
1185         {
1186             addErrorMessage(&sciErr, API_ERROR_READ_DOUBLE_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), _iComplex ? "readComplexMatrixOfDoubleInNamedList" : "readMatrixOfDoubleInNamedList", _iItemPos + 1, _pstName);
1187             return sciErr;
1188         }
1189
1190         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
1191     }
1192     else
1193     {
1194         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1195     }
1196
1197     if (sciErr.iErr)
1198     {
1199         addErrorMessage(&sciErr, API_ERROR_READ_DOUBLE_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), _iComplex ? "readComplexMatrixOfDoubleInNamedList" : "readMatrixOfDoubleInNamedList", _iItemPos + 1, _pstName);
1200         return sciErr;
1201     }
1202
1203     sciErr = getCommonMatrixOfDouble(_pvCtx, piAddr, '$', _iComplex, _piRows, _piCols, &pdblReal, &pdblImg);
1204     if (sciErr.iErr)
1205     {
1206         addErrorMessage(&sciErr, API_ERROR_READ_DOUBLE_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), _iComplex ? "readComplexMatrixOfDoubleInNamedList" : "readMatrixOfDoubleInNamedList", _iItemPos + 1, _pstName);
1207         return sciErr;
1208     }
1209
1210     if (_pdblReal == NULL || (_iComplex && _pdblImg == NULL))
1211     {
1212         return sciErr;
1213     }
1214
1215     memcpy(_pdblReal, pdblReal, sizeof(double) **_piRows **_piCols);
1216     if (_iComplex)
1217     {
1218         memcpy(_pdblImg, pdblImg, sizeof(double) **_piRows **_piCols);
1219     }
1220     return sciErr;
1221 }
1222
1223
1224 /*********************
1225 * Strings functions *
1226 *********************/
1227
1228 SciErr getMatrixOfStringInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piLength, char** _pstStrings)
1229 {
1230     int* piAddr  = NULL;
1231
1232     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1233     if (sciErr.iErr)
1234     {
1235         addErrorMessage(&sciErr, API_ERROR_GET_STRING_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "getMatrixOfStringInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
1236         return sciErr;
1237     }
1238
1239     sciErr = getMatrixOfString(_pvCtx, piAddr, _piRows, _piCols, _piLength, _pstStrings);
1240     if (sciErr.iErr)
1241     {
1242         addErrorMessage(&sciErr, API_ERROR_GET_STRING_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "getMatrixOfStringInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
1243         return sciErr;
1244     }
1245
1246     return sciErr;
1247 }
1248
1249
1250 SciErr createMatrixOfStringInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const char* const* _pstStrings)
1251 {
1252     SciErr sciErr = sciErrInit();
1253     List* pParent = (List*)_piParent;
1254
1255     if (_iRows == 0 || _iCols == 0)
1256     {
1257         pParent->set(_iItemPos - 1, Double::Empty());
1258         return sciErr;
1259     }
1260
1261     String* pS = new String(_iRows, _iCols);
1262     for (int i = 0 ; i < _iRows * _iCols ; i++)
1263     {
1264         wchar_t* pwst = to_wide_string(_pstStrings[i]);
1265         pS->set(i, pwst);
1266         FREE(pwst);
1267     }
1268
1269     pParent->set(_iItemPos - 1, pS);
1270     return sciErr;
1271 }
1272
1273 SciErr fillCommonMatrixOfStringInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const char* const* _pstStrings, int* _piTotalLen)
1274 {
1275     SciErr sciErr = sciErrInit();
1276 #if 0
1277     == == == =
1278         SciErr sciErr;
1279     sciErr.iErr = 0;
1280     sciErr.iMsgCount = 0;
1281     int iNbItem   = 0;
1282     int* piAddr   = NULL;
1283     int* piOffset  = NULL;
1284
1285     //Does item can be added in the list
1286     getListItemNumber(_pvCtx, _piParent, &iNbItem);
1287     if (iNbItem < _iItemPos)
1288     {
1289         addErrorMessage(&sciErr, API_ERROR_ITEM_LIST_NUMBER, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfStringInList", _iItemPos + 1);
1290         return sciErr;
1291     }
1292
1293     sciErr = allocCommonItemInList(_pvCtx, _piParent, _iItemPos, &piAddr);
1294     if (sciErr.iErr)
1295     {
1296         addErrorMessage(&sciErr, API_ERROR_FILL_STRING_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "fillMatrixOfStringInList", _iItemPos + 1);
1297         return sciErr;
1298     }
1299
1300     //sciErr = fillMatrixOfString(_pvCtx, piAddr, _iRows, _iCols, _pstStrings, _piTotalLen);
1301     if (sciErr.iErr)
1302     {
1303         addErrorMessage(&sciErr, API_ERROR_FILL_STRING_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "fillMatrixOfStringInList", _iItemPos + 1);
1304         return sciErr;
1305     }
1306
1307     piOffset      = _piParent + 2;
1308     piOffset[_iItemPos] = piOffset[_iItemPos - 1] + (*_piTotalLen + 5 + _iRows * _iCols + !((*_piTotalLen + _iRows * _iCols) % 2)) / 2;
1309 #endif
1310     return sciErr;
1311 }
1312
1313 SciErr createMatrixOfStringInNamedList(void* _pvCtx, const char* _pstName, int* /*_piParent*/, int _iItemPos, int _iRows, int _iCols, const char* const* _pstStrings)
1314 {
1315     SciErr sciErr = sciErrInit();
1316 #if 0
1317     int iVarID[nsiz];
1318     int iTotalLen       = 0;
1319     int iSaveRhs        = Rhs;
1320     int iSaveTop        = Top;
1321     int* piItemAddr     = NULL;
1322     int* piEnd          = NULL;
1323     int* piParent       = getLastNamedListAddress(_pstName, _iItemPos);
1324
1325     if (!checkNamedVarFormat(_pvCtx, _pstName))
1326     {
1327         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createMatrixOfStringInNamedList", _pstName);
1328         return sciErr;
1329     }
1330
1331     C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
1332     Top = Top + Nbvars + 1;
1333
1334     sciErr = getListItemAddress(_pvCtx, piParent, _iItemPos, &piItemAddr);
1335     if (sciErr.iErr)
1336     {
1337         addErrorMessage(&sciErr, API_ERROR_CREATE_STRING_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), "createMatrixOfStringInNamedList", _iItemPos + 1, _pstName);
1338         return sciErr;
1339     }
1340
1341     sciErr = fillCommonMatrixOfStringInList(_pvCtx, Top, piParent, _iItemPos, _iRows, _iCols, _pstStrings, &iTotalLen);
1342     if (sciErr.iErr)
1343     {
1344         addErrorMessage(&sciErr, API_ERROR_CREATE_STRING_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), "createMatrixOfStringInNamedList", _iItemPos + 1, _pstName);
1345         return sciErr;
1346     }
1347
1348     piEnd = piItemAddr + iTotalLen + 5 + _iRows * _iCols + !((iTotalLen + _iRows * _iCols) % 2);
1349     closeList(Top, piEnd);
1350
1351     if (_iItemPos == piParent[1])
1352     {
1353         updateNamedListOffset(_pvCtx, Top, _pstName, piParent, _iItemPos, piEnd);
1354         popNamedListAddress(_pstName);
1355     }
1356
1357     Top = iSaveTop;
1358     Rhs = iSaveRhs;
1359 #endif
1360
1361     return sciErr;
1362 }
1363
1364 SciErr readMatrixOfStringInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piLength, char** _pstStrings)
1365 {
1366     SciErr sciErr = sciErrInit();
1367     int* piAddr    = NULL;
1368     int* piRoot    = NULL;
1369     int iNbItem    = 0;
1370
1371     if (_piParent == NULL)
1372     {
1373         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
1374         if (sciErr.iErr)
1375         {
1376             addErrorMessage(&sciErr, API_ERROR_READ_STRING_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfStringInNamedList", _iItemPos + 1, _pstName);
1377             return sciErr;
1378         }
1379
1380         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
1381     }
1382     else
1383     {
1384         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1385     }
1386
1387     if (sciErr.iErr)
1388     {
1389         addErrorMessage(&sciErr, API_ERROR_READ_STRING_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfStringInNamedList", _iItemPos + 1, _pstName);
1390         return sciErr;
1391     }
1392
1393     sciErr = getMatrixOfString(_pvCtx, piAddr, _piRows, _piCols, _piLength, _pstStrings);
1394     if (sciErr.iErr)
1395     {
1396         addErrorMessage(&sciErr, API_ERROR_READ_STRING_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfStringInNamedList", _iItemPos + 1, _pstName);
1397         return sciErr;
1398     }
1399
1400     return sciErr;
1401 }
1402
1403 /*********************
1404 * boolean functions *
1405 *********************/
1406
1407 SciErr getMatrixOfBooleanInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int** _piBool)
1408 {
1409     int* piAddr  = NULL;
1410
1411     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1412     if (sciErr.iErr)
1413     {
1414         addErrorMessage(&sciErr, API_ERROR_GET_BOOLEAN_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "getMatrixOfBooleanInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
1415         return sciErr;
1416     }
1417
1418     sciErr = getMatrixOfBoolean(_pvCtx, piAddr, _piRows, _piCols, _piBool);
1419     if (sciErr.iErr)
1420     {
1421         addErrorMessage(&sciErr, API_ERROR_GET_BOOLEAN_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "getMatrixOfBooleanInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
1422         return sciErr;
1423     }
1424
1425     return sciErr;
1426 }
1427
1428 SciErr createMatrixOfBooleanInList(void* _pvCtx, int _iVar, int* /*_piParent*/, int _iItemPos, int _iRows, int _iCols, const int* _piBool)
1429 {
1430     int *piBool   = NULL;
1431
1432     SciErr sciErr = allocMatrixOfBooleanInList(_pvCtx, _iVar, NULL/*_piParent*/, _iItemPos, _iRows, _iCols, &piBool);
1433     if (sciErr.iErr)
1434     {
1435         addErrorMessage(&sciErr, API_ERROR_CREATE_BOOLEAN_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfBooleanInList", _iItemPos + 1);
1436         return sciErr;
1437     }
1438
1439     if (_piBool != NULL)
1440     {
1441         memcpy(piBool, _piBool, _iRows * _iCols * sizeof(int));
1442     }
1443     return sciErr;
1444 }
1445
1446 SciErr allocMatrixOfBooleanInList(void* _pvCtx, int _iVar, int* /*_piParent*/, int _iItemPos, int _iRows, int _iCols, int** _piBool)
1447 {
1448     SciErr sciErr = sciErrInit();
1449 #if 0
1450     int iNewPos     = Top - Rhs + _iVar;
1451     int* piEnd      = NULL;
1452     int* piParent   = getLastListAddress(_iVar, _iItemPos);
1453
1454     SciErr sciErr = fillMatrixOfBoolInList(_pvCtx, _iVar, piParent, _iItemPos, _iRows, _iCols, _piBool);
1455     if (sciErr.iErr)
1456     {
1457         addErrorMessage(&sciErr, API_ERROR_ALLOC_BOOLEAN_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "allocMatrixOfBooleanInList", _iItemPos + 1);
1458         return sciErr;
1459     }
1460
1461     piEnd = *_piBool + _iRows * _iCols + !((_iRows * _iCols) % 2);
1462     closeList(iNewPos, piEnd);
1463
1464     if (_iItemPos == piParent[1])
1465     {
1466         updateListOffset(_pvCtx, _iVar, piParent, _iItemPos, piEnd);
1467         popListAddress(_iVar);
1468     }
1469 #endif
1470     return sciErr;
1471 }
1472
1473 static SciErr fillMatrixOfBoolInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int** _piBool)
1474 {
1475     SciErr sciErr = sciErrInit();
1476 #if 0
1477     int iNbItem    = 0;
1478     int* piOffset   = NULL;
1479     int* piChildAddr = NULL;
1480
1481     //Does item can be added in the list
1482     SciErr sciErr = getListItemNumber(_pvCtx, _piParent, &iNbItem);
1483     if (sciErr.iErr)
1484     {
1485         addErrorMessage(&sciErr, API_ERROR_FILL_BOOLEAN_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfBoolInList", _iItemPos + 1);
1486         return sciErr;
1487     }
1488
1489     if (iNbItem < _iItemPos)
1490     {
1491         addErrorMessage(&sciErr, API_ERROR_ITEM_LIST_NUMBER, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfBooleanInList", _iItemPos + 1);
1492         return sciErr;
1493     }
1494
1495
1496     sciErr = allocCommonItemInList(_pvCtx, _piParent, _iItemPos, &piChildAddr);
1497     if (sciErr.iErr)
1498     {
1499         addErrorMessage(&sciErr, API_ERROR_FILL_BOOLEAN_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfBoolInList", _iItemPos + 1);
1500         return sciErr;
1501     }
1502
1503     sciErr = fillMatrixOfBoolean(_pvCtx, piChildAddr, _iRows, _iCols, _piBool);
1504     if (sciErr.iErr)
1505     {
1506         addErrorMessage(&sciErr, API_ERROR_FILL_BOOLEAN_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfBoolInList", _iItemPos + 1);
1507         return sciErr;
1508     }
1509
1510     piOffset      = _piParent + 2;
1511     piOffset[_iItemPos] = piOffset[_iItemPos - 1] + ((3 + _iRows * _iCols + !((_iRows * _iCols) % 2)) / 2);
1512
1513 #endif
1514     return sciErr;
1515 }
1516
1517 SciErr createMatrixOfBooleanInNamedList(void* _pvCtx, const char* _pstName, int* /*_piParent*/, int _iItemPos, int _iRows, int _iCols, const int* _piBool)
1518 {
1519     SciErr sciErr = sciErrInit();
1520 #if 0
1521     int iVarID[nsiz];
1522     int iSaveRhs        = Rhs;
1523     int iSaveTop        = Top;
1524     int *piAddr         = NULL;
1525     int* piBool         = NULL;
1526     int* piEnd          = NULL;
1527     int* piChildAddr    = NULL;
1528     int* piParent       = getLastNamedListAddress(_pstName, _iItemPos);
1529
1530     if (!checkNamedVarFormat(_pvCtx, _pstName))
1531     {
1532         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createMatrixOfBooleanInNamedList", _pstName);
1533         return sciErr;
1534     }
1535
1536     C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
1537     Top = Top + Nbvars + 1;
1538
1539     getNewVarAddressFromPosition(_pvCtx, Top, &piAddr);
1540
1541     sciErr = fillMatrixOfBoolInList(_pvCtx, Top, piParent, _iItemPos, _iRows, _iCols, &piBool);
1542     if (sciErr.iErr)
1543     {
1544         addErrorMessage(&sciErr, API_ERROR_CREATE_BOOLEAN_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), "createMatrixOfBooleanInNamedList", _iItemPos + 1, _pstName);
1545         return sciErr;
1546     }
1547
1548     memcpy(piBool, _piBool, sizeof(int) * _iRows * _iCols);
1549
1550     sciErr = allocCommonItemInList(_pvCtx, piParent, _iItemPos, &piChildAddr);
1551     if (sciErr.iErr)
1552     {
1553         addErrorMessage(&sciErr, API_ERROR_CREATE_BOOLEAN_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), "createMatrixOfBooleanInNamedList", _iItemPos + 1, _pstName);
1554         return sciErr;
1555     }
1556
1557     piEnd = piChildAddr + 4 + (_iRows * _iCols) + ((_iRows * _iCols) % 2);
1558     closeList(Top, piEnd);
1559
1560     if (_iItemPos == piParent[1])
1561     {
1562         updateNamedListOffset(_pvCtx, Top, _pstName, piParent, _iItemPos, piEnd);
1563         popNamedListAddress(_pstName);
1564     }
1565
1566     Top = iSaveTop;
1567     Rhs = iSaveRhs;
1568 #endif
1569
1570     return sciErr;
1571 }
1572
1573 SciErr readMatrixOfBooleanInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piBool)
1574 {
1575     SciErr sciErr = sciErrInit();
1576     int* piAddr    = NULL;
1577     int* piRoot    = NULL;
1578     int iNbItem    = 0;
1579     int* piBool    = NULL;
1580
1581
1582     if (_piParent == NULL)
1583     {
1584         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
1585         if (sciErr.iErr)
1586         {
1587             addErrorMessage(&sciErr, API_ERROR_READ_BOOLEAN_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfBooleanInNamedList", _iItemPos + 1, _pstName);
1588             return sciErr;
1589         }
1590
1591         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
1592     }
1593     else
1594     {
1595         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1596     }
1597
1598     if (sciErr.iErr)
1599     {
1600         addErrorMessage(&sciErr, API_ERROR_READ_BOOLEAN_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfBooleanInNamedList", _iItemPos + 1, _pstName);
1601         return sciErr;
1602     }
1603
1604     sciErr = getMatrixOfBoolean(_pvCtx, piAddr, _piRows, _piCols, &piBool);
1605     if (sciErr.iErr)
1606     {
1607         addErrorMessage(&sciErr, API_ERROR_READ_BOOLEAN_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfBooleanInNamedList", _iItemPos + 1, _pstName);
1608         return sciErr;
1609     }
1610
1611     if (_piBool == NULL)
1612     {
1613         return sciErr;
1614     }
1615
1616     memcpy(_piBool, piBool, *_piRows **_piCols * sizeof(int));
1617     return sciErr;
1618 }
1619
1620
1621 /*************************
1622 * polynomials functions *
1623 *************************/
1624
1625 SciErr getMatrixOfPolyInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal)
1626 {
1627     return getCommonMatrixOfPolyInList(_pvCtx, _piParent, _iItemPos, 0, _piRows, _piCols, _piNbCoef, _pdblReal, NULL);
1628 }
1629
1630 SciErr getComplexMatrixOfPolyInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
1631 {
1632     return getCommonMatrixOfPolyInList(_pvCtx, _piParent, _iItemPos, 1, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
1633 }
1634
1635 SciErr getCommonMatrixOfPolyInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
1636 {
1637     int* piAddr  = NULL;
1638
1639     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1640     if (sciErr.iErr)
1641     {
1642         addErrorMessage(&sciErr, API_ERROR_GET_POLY_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), _iComplex ? "getComplexMatrixOfPolyInList" : "getMatrixOfPolyInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
1643         return sciErr;
1644     }
1645
1646     sciErr = getCommonMatrixOfPoly(_pvCtx, piAddr, _iComplex, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
1647     if (sciErr.iErr)
1648     {
1649         addErrorMessage(&sciErr, API_ERROR_GET_POLY_IN_LIST, _("API_ERROR_GET_POLY_IN_LIST"));
1650         return sciErr;
1651     }
1652
1653     return sciErr;
1654 }
1655
1656 SciErr createMatrixOfPolyInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal)
1657 {
1658     return createCommonMatrixOfPolyInList(_pvCtx, _iVar, _piParent, _iItemPos, _pstVarName, 0, _iRows, _iCols, _piNbCoef, _pdblReal, NULL);
1659 }
1660
1661 SciErr createComplexMatrixOfPolyInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg)
1662 {
1663     return createCommonMatrixOfPolyInList(_pvCtx, _iVar, _piParent, _iItemPos, _pstVarName, 1, _iRows, _iCols, _piNbCoef, _pdblReal, _pdblImg);
1664 }
1665
1666 SciErr createCommonMatrixOfPolyInList(void* _pvCtx, int _iVar, int* /*_piParent*/, int _iItemPos, char* _pstVarName, int _iComplex, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg)
1667 {
1668     int* piItemAddr = NULL;
1669     int *piEnd      = NULL;
1670     int iItemLen    = 0;
1671     int iTotalLen   = 0;
1672     int* piParent   = getLastListAddress(_iVar, _iItemPos);
1673
1674     SciErr sciErr = getListItemAddress(_pvCtx, piParent, _iItemPos, &piItemAddr);
1675     if (sciErr.iErr)
1676     {
1677         addErrorMessage(&sciErr, API_ERROR_CREATE_POLY_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexMatrixOfPolyInList" : "createMatrixOfPolyInList", _iItemPos + 1);
1678         return sciErr;
1679     }
1680
1681     sciErr = fillCommonMatrixOfPolyInList(_pvCtx, _iVar, piParent, _iItemPos, _pstVarName, _iComplex, _iRows, _iCols, _piNbCoef, _pdblReal, _pdblImg, &iTotalLen);
1682     if (sciErr.iErr)
1683     {
1684         addErrorMessage(&sciErr, API_ERROR_CREATE_POLY_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexMatrixOfPolyInList" : "createMatrixOfPolyInList", _iItemPos + 1);
1685         return sciErr;
1686     }
1687
1688     iItemLen      = 9 + _iRows * _iCols + (9 + _iRows * _iCols) % 2;
1689     iItemLen      += iTotalLen;
1690     piEnd        = piItemAddr + iItemLen;
1691     if (_iItemPos == piParent[1])
1692     {
1693         updateListOffset(_pvCtx, _iVar, piParent, _iItemPos, piEnd);
1694         popListAddress(_iVar);
1695     }
1696
1697     closeList(_iVar, piEnd);
1698
1699     return sciErr;
1700 }
1701
1702 static SciErr fillCommonMatrixOfPolyInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, char* _pstVarName, int _iComplex, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg, int* _piTotalLen)
1703 {
1704     int iNbItem    = 0;
1705     int iTotalLen   = 0;
1706     int* piOffset   = NULL;
1707     int* piChildAddr = NULL;
1708     int iItemLen   = 0;
1709
1710     //Does item can be added in the list
1711     SciErr sciErr = getListItemNumber(_pvCtx, _piParent, &iNbItem);
1712     if (sciErr.iErr)
1713     {
1714         addErrorMessage(&sciErr, API_ERROR_FILL_POLY_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexMatrixOfPolyInList" : "createMatrixOfPolyInList", _iItemPos + 1);
1715         return sciErr;
1716     }
1717
1718     if (iNbItem < _iItemPos)
1719     {
1720         addErrorMessage(&sciErr, API_ERROR_ITEM_LIST_NUMBER, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexMatrixOfPolyInList" : "createMatrixOfPolyInList", _iItemPos + 1);
1721         return sciErr;
1722     }
1723
1724     sciErr = allocCommonItemInList(_pvCtx, _piParent, _iItemPos, &piChildAddr);
1725     if (sciErr.iErr)
1726     {
1727         addErrorMessage(&sciErr, API_ERROR_FILL_POLY_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexMatrixOfPolyInList" : "createMatrixOfPolyInList", _iItemPos + 1);
1728         return sciErr;
1729     }
1730
1731     //sciErr = fillCommonMatrixOfPoly(_pvCtx, piChildAddr, _pstVarName, _iComplex, _iRows, _iCols, _piNbCoef, _pdblReal, _pdblImg, &iTotalLen);
1732     if (sciErr.iErr)
1733     {
1734         addErrorMessage(&sciErr, API_ERROR_FILL_POLY_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexMatrixOfPolyInList" : "createMatrixOfPolyInList", _iItemPos + 1);
1735         return sciErr;
1736     }
1737
1738     piOffset      = _piParent + 2;
1739
1740     iItemLen      = 9 + _iRows * _iCols + (9 + _iRows * _iCols) % 2;
1741     iItemLen      += iTotalLen;
1742     piOffset[_iItemPos] = piOffset[_iItemPos - 1] + ((iItemLen + 1) / 2);
1743
1744     *_piTotalLen = iTotalLen;
1745     return sciErr;
1746 }
1747
1748
1749 SciErr createMatrixOfPolyInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal)
1750 {
1751     return createCommonMatrixOfPolyInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, _pstVarName, 0, _iRows, _iCols, _piNbCoef, _pdblReal, NULL);
1752 }
1753
1754 SciErr createComplexMatrixOfPolyInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg)
1755 {
1756     return createCommonMatrixOfPolyInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, _pstVarName, 1, _iRows, _iCols, _piNbCoef, _pdblReal, _pdblImg);
1757 }
1758
1759 SciErr createCommonMatrixOfPolyInNamedList(void* _pvCtx, const char* _pstName, int* /*_piParent*/, int _iItemPos, char* _pstVarName, int _iComplex, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg)
1760 {
1761     SciErr sciErr = sciErrInit();
1762 #if 0
1763     int iVarID[nsiz];
1764     int iSaveRhs        = Rhs;
1765     int iSaveTop        = Top;
1766     int *piAddr         = NULL;
1767     int* piEnd          = NULL;
1768     int* piChildAddr    = NULL;
1769     int iTotalLen       = 0;
1770     int iItemLen        = 0;
1771     int* piParent       = getLastNamedListAddress(_pstName, _iItemPos);
1772
1773
1774     if (!checkNamedVarFormat(_pvCtx, _pstName))
1775     {
1776         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createCommonMatrixOfPolyInNamedList", _pstName);
1777         return sciErr;
1778     }
1779
1780     C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
1781     Top = Top + Nbvars + 1;
1782
1783     getNewVarAddressFromPosition(_pvCtx, Top, &piAddr);
1784
1785     sciErr = fillCommonMatrixOfPolyInList(_pvCtx, Top, piParent, _iItemPos, _pstVarName, _iComplex, _iRows, _iCols, _piNbCoef, _pdblReal, _pdblImg, &iTotalLen);
1786     if (sciErr.iErr)
1787     {
1788         addErrorMessage(&sciErr, API_ERROR_CREATE_POLY_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), _iComplex ? "createComplexMatrixOfPolyInNamedList" : "createMatrixOfPolyInNamedList", _iItemPos + 1, _pstName);
1789         return sciErr;
1790     }
1791
1792     iItemLen      = 9 + _iRows * _iCols + (9 + _iRows * _iCols) % 2;
1793     iItemLen      += iTotalLen;
1794
1795     sciErr = getListItemAddress(_pvCtx, piParent, _iItemPos, &piChildAddr);
1796     if (sciErr.iErr)
1797     {
1798         addErrorMessage(&sciErr, API_ERROR_CREATE_POLY_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), _iComplex ? "createComplexMatrixOfPolyInNamedList" : "createMatrixOfPolyInNamedList", _iItemPos + 1, _pstName);
1799         return sciErr;
1800     }
1801
1802     piEnd        = piChildAddr + iItemLen;
1803     closeList(Top, piEnd);
1804
1805     if (_iItemPos == piParent[1])
1806     {
1807         updateNamedListOffset(_pvCtx, Top, _pstName, piParent, _iItemPos, piEnd);
1808         popNamedListAddress(_pstName);
1809     }
1810
1811
1812     Top = iSaveTop;
1813     Rhs = iSaveRhs;
1814 #endif
1815
1816     return sciErr;
1817 }
1818
1819 SciErr readMatrixOfPolyInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal)
1820 {
1821     return readCommonMatrixOfPolyInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 0, _piRows, _piCols, _piNbCoef, _pdblReal, NULL);
1822 }
1823
1824 SciErr readComplexMatrixOfPolyInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
1825 {
1826     return readCommonMatrixOfPolyInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 1, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
1827 }
1828
1829 SciErr readCommonMatrixOfPolyInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
1830 {
1831     SciErr sciErr = sciErrInit();
1832     int* piAddr    = NULL;
1833     int* piRoot    = NULL;
1834     int iNbItem    = 0;
1835
1836     if (_piParent == NULL)
1837     {
1838         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
1839         if (sciErr.iErr)
1840         {
1841             addErrorMessage(&sciErr, API_ERROR_READ_POLY_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), _iComplex ? "readComplexMatrixOfPolyInNamedList" : "readMatrixOfPolyInNamedList", _iItemPos + 1, _pstName);
1842             return sciErr;
1843         }
1844
1845         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
1846     }
1847     else
1848     {
1849         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1850     }
1851
1852     if (sciErr.iErr)
1853     {
1854         addErrorMessage(&sciErr, API_ERROR_READ_POLY_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), _iComplex ? "readComplexMatrixOfPolyInNamedList" : "readMatrixOfPolyInNamedList", _iItemPos + 1, _pstName);
1855         return sciErr;
1856     }
1857
1858     sciErr = getCommonMatrixOfPoly(_pvCtx, piAddr, _iComplex, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
1859     if (sciErr.iErr)
1860     {
1861         addErrorMessage(&sciErr, API_ERROR_READ_POLY_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), _iComplex ? "readComplexMatrixOfPolyInNamedList" : "readMatrixOfPolyInNamedList", _iItemPos + 1, _pstName);
1862         return sciErr;
1863     }
1864
1865     return sciErr;
1866 }
1867
1868 /**********************
1869 * integers functions *
1870 **********************/
1871
1872 static SciErr fillCommonMatrixOfIntegerInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iPrecision, int _iRows, int _iCols, void** _pvData)
1873 {
1874     int iNbItem    = 0;
1875     int* piOffset   = NULL;
1876     int* piChildAddr = NULL;
1877
1878     //Does item can be added in the list
1879     SciErr sciErr = getListItemNumber(_pvCtx, _piParent, &iNbItem);
1880     if (sciErr.iErr)
1881     {
1882         addErrorMessage(&sciErr, API_ERROR_FILL_INT_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfIntegerInList", _iItemPos + 1);
1883         return sciErr;
1884     }
1885
1886     if (iNbItem < _iItemPos)
1887     {
1888         addErrorMessage(&sciErr, API_ERROR_ITEM_LIST_NUMBER, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfIntegerInList", _iItemPos + 1);
1889         return sciErr;
1890     }
1891
1892
1893     sciErr = allocCommonItemInList(_pvCtx, _piParent, _iItemPos, &piChildAddr);
1894     if (sciErr.iErr)
1895     {
1896         addErrorMessage(&sciErr, API_ERROR_FILL_INT_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfIntegerInList", _iItemPos + 1);
1897         return sciErr;
1898     }
1899
1900     //sciErr = fillCommonMatrixOfInteger(_pvCtx, piChildAddr, _iPrecision, _iRows, _iCols, _pvData);
1901     if (sciErr.iErr)
1902     {
1903         addErrorMessage(&sciErr, API_ERROR_FILL_INT_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfIntegerInList", _iItemPos + 1);
1904         return sciErr;
1905     }
1906
1907     piOffset      = _piParent + 2;
1908
1909     //integer : size in double
1910     //1st case, 5 * 1 int8  -> (10,5) (1,1) (1,2,3,4,5,x,x,x)           -> 3 : 2 + 5/8 + !!(5%8) -> 2 + 0 + 1 -> 3
1911     //2nd case, 5 * 1 int16 -> (10,5) (1,2)   (1,2,3,4)    (5,x,x,x)     -> 4 : 2 + 5/4 + !!(5%4) -> 2 + 1 + 1 -> 4
1912     //3th case, 5 * 1 int32 -> (10,5) (1,3)    (1,2)      (3,4)   (5,x) -> 5 : 2 + 5/2 + !!(5%2) -> 2 + 2 + 1 -> 5
1913
1914     //with 5*5 int matrix
1915     //1st case, 5 * 5 int8  -> (10,5) (5,1) (1:25) -> 3 : 2 + 25/8 + !!(25%8) -> 2 + 3  + 1 -> 6
1916     //2nd case, 5 * 1 int16 -> (10,5) (5,2) (1:25) -> 4 : 2 + 25/4 + !!(25%4) -> 2 + 6  + 1 -> 9
1917     //3th case, 5 * 5 int32 -> (10,5) (5,3) (1:25) -> 5 : 2 + 25/2 + !!(25%2) -> 2 + 12 + 1 -> 15
1918     piOffset[_iItemPos] = piOffset[_iItemPos - 1] + 2 + _iRows * _iCols / (sizeof(double) / (_iPrecision % 10 )) + (int)(!!(_iRows * _iCols)) % (sizeof(double) / (_iPrecision % 10 ));
1919
1920     return sciErr;
1921 }
1922
1923 static SciErr allocCommonMatrixOfIntegerInList(void* _pvCtx, int _iVar, const char* _pstName, int* _piParent, int _iItemPos, int _iPrecision, int _iRows, int _iCols, void** _pvData)
1924 {
1925     SciErr sciErr = sciErrInit();
1926
1927     List* pParent = (List*)_piParent;
1928
1929     if (_iRows == 0 || _iCols == 0)
1930     {
1931         pParent->set(_iItemPos - 1, Double::Empty());
1932         return sciErr;
1933     }
1934
1935     InternalType* pIT = NULL;
1936
1937     switch (_iPrecision)
1938     {
1939         case SCI_INT8 :
1940         {
1941             Int8* pi = new Int8(_iRows, _iCols);
1942             *_pvData = pi->get();
1943             pIT = pi;
1944         }
1945         break;
1946         case SCI_UINT8 :
1947         {
1948             UInt8* pi = new UInt8(_iRows, _iCols);
1949             *_pvData = pi->get();
1950             pIT = pi;
1951         }
1952         break;
1953         case SCI_INT16 :
1954         {
1955             Int16* pi = new Int16(_iRows, _iCols);
1956             *_pvData = pi->get();
1957             pIT = pi;
1958         }
1959         break;
1960         case SCI_UINT16 :
1961         {
1962             UInt16* pi = new UInt16(_iRows, _iCols);
1963             *_pvData = pi->get();
1964             pIT = pi;
1965         }
1966         break;
1967         case SCI_INT32 :
1968         {
1969             Int32* pi = new Int32(_iRows, _iCols);
1970             *_pvData = pi->get();
1971             pIT = pi;
1972         }
1973         break;
1974         case SCI_UINT32 :
1975         {
1976             UInt32* pi = new UInt32(_iRows, _iCols);
1977             *_pvData = pi->get();
1978             pIT = pi;
1979         }
1980         break;
1981         case SCI_INT64 :
1982         {
1983             Int64* pi = new Int64(_iRows, _iCols);
1984             *_pvData = pi->get();
1985             pIT = pi;
1986         }
1987         break;
1988         case SCI_UINT64 :
1989         {
1990             UInt64* pi = new UInt64(_iRows, _iCols);
1991             *_pvData = pi->get();
1992             pIT = pi;
1993         }
1994         break;
1995     }
1996
1997     pParent->set(_iItemPos - 1, pIT);
1998     return sciErr;
1999 }
2000
2001 SciErr allocMatrixOfUnsignedInteger8InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, unsigned char** _pucData)
2002 {
2003     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT8, _iRows, _iCols, (void **)_pucData);
2004 }
2005
2006 SciErr allocMatrixOfUnsignedInteger16InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, unsigned short** _pusData)
2007 {
2008     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT16, _iRows, _iCols, (void**)_pusData);
2009 }
2010
2011 SciErr allocMatrixOfUnsignedInteger32InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, unsigned int** _puiData)
2012 {
2013     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT32, _iRows, _iCols, (void**)_puiData);
2014 }
2015
2016 #ifdef __SCILAB_INT64__
2017 SciErr allocMatrixOfUnsignedInteger64InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, unsigned long long** _pullData)
2018 {
2019     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT64, _iRows, _iCols, (void**)_pullData);
2020 }
2021 #endif
2022
2023 SciErr allocMatrixOfInteger8InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, char** _pcData)
2024 {
2025     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT8, _iRows, _iCols, (void**)_pcData);
2026 }
2027
2028 SciErr allocMatrixOfInteger16InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, short** _psData)
2029 {
2030     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT16, _iRows, _iCols, (void**)_psData);
2031 }
2032
2033 SciErr allocMatrixOfInteger32InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int** _piData)
2034 {
2035     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT32, _iRows, _iCols, (void**)_piData);
2036 }
2037
2038 #ifdef __SCILAB_INT64__
2039 SciErr allocMatrixOfInteger64InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, long long** _pllData)
2040 {
2041     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT64, _iRows, _iCols, (void**)_pllData);
2042 }
2043 #endif
2044
2045 static SciErr createCommomMatrixOfIntegerInList(void* _pvCtx, int _iVar, const char* _pstName, int* _piParent, int _iItemPos, int _iPrecision, int _iRows, int _iCols, const void* _pvData)
2046 {
2047     void *pvData = NULL;
2048
2049     SciErr sciErr = allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, _pstName, _piParent, _iItemPos, _iPrecision, _iRows, _iCols, &pvData);
2050     if (sciErr.iErr)
2051     {
2052         addErrorMessage(&sciErr, API_ERROR_CREATE_INT_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfIntegerInList", _iItemPos + 1);
2053         return sciErr;
2054     }
2055
2056     if (pvData != NULL)
2057     {
2058         memcpy(pvData, _pvData, _iRows * _iCols * (_iPrecision % 10));
2059     }
2060     return sciErr;
2061 }
2062
2063 SciErr createMatrixOfUnsignedInteger8InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned char* _pucData)
2064 {
2065     return createCommomMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT8, _iRows, _iCols, _pucData);
2066 }
2067
2068 SciErr createMatrixOfUnsignedInteger16InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned short* _pusData)
2069 {
2070     return createCommomMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT16, _iRows, _iCols, _pusData);
2071 }
2072
2073 SciErr createMatrixOfUnsignedInteger32InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned int* _puiData)
2074 {
2075     return createCommomMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT32, _iRows, _iCols, _puiData);
2076 }
2077
2078 #ifdef __SCILAB_INT64__
2079 SciErr createMatrixOfUnsignedInteger64InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned long long* _pullData)
2080 {
2081     return createCommomMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT64, _iRows, _iCols, _pullData);
2082 }
2083 #endif
2084
2085 SciErr createMatrixOfInteger8InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const char* _pcData)
2086 {
2087     return createCommomMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT8, _iRows, _iCols, _pcData);
2088 }
2089
2090 SciErr createMatrixOfInteger16InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const short* _psData)
2091 {
2092     return createCommomMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT16, _iRows, _iCols, _psData);
2093 }
2094
2095 SciErr createMatrixOfInteger32InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const int* _piData)
2096 {
2097     return createCommomMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT32, _iRows, _iCols, _piData);
2098 }
2099
2100 #ifdef __SCILAB_INT64__
2101 SciErr createMatrixOfInteger64InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const long long* _pllData)
2102 {
2103     return createCommomMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT64, _iRows, _iCols, _pllData);
2104 }
2105 #endif
2106
2107 static SciErr getCommonMatrixOfIntegerInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iPrecision, int* _piRows, int* _piCols, void** _pvData)
2108 {
2109     int* piAddr  = NULL;
2110
2111     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
2112     if (sciErr.iErr)
2113     {
2114         addErrorMessage(&sciErr, API_ERROR_GET_INT_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "getMatrixOfIntegerInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
2115         return sciErr;
2116     }
2117
2118     sciErr = getCommonMatrixOfInteger(_pvCtx, piAddr, _iPrecision, _piRows, _piCols, _pvData);
2119     if (sciErr.iErr)
2120     {
2121         addErrorMessage(&sciErr, API_ERROR_GET_INT_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "getMatrixOfIntegerInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
2122         return sciErr;
2123     }
2124
2125     return sciErr;
2126 }
2127
2128 SciErr getMatrixOfUnsignedInteger8InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned char** _pucData)
2129 {
2130     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_UINT8, _piRows, _piCols, (void**)_pucData);
2131 }
2132
2133 SciErr getMatrixOfUnsignedInteger16InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned short** _pusData)
2134 {
2135     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_UINT16, _piRows, _piCols, (void**)_pusData);
2136 }
2137
2138 SciErr getMatrixOfUnsignedInteger32InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned int** _puiData)
2139 {
2140     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_UINT32, _piRows, _piCols, (void**)_puiData);
2141 }
2142
2143 #ifdef __SCILAB_INT64__
2144 SciErr getMatrixOfUnsignedInteger64InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned long long** _pullData)
2145 {
2146     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_UINT64, _piRows, _piCols, (void**)_pullData);
2147 }
2148 #endif
2149
2150 SciErr getMatrixOfInteger8InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, char** _pcData)
2151 {
2152     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_INT8, _piRows, _piCols, (void**)_pcData);
2153 }
2154
2155 SciErr getMatrixOfInteger16InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, short** _psData)
2156 {
2157     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_INT16, _piRows, _piCols, (void**)_psData);
2158 }
2159
2160 SciErr getMatrixOfInteger32InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int** _piData)
2161 {
2162     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_INT32, _piRows, _piCols, (void**)_piData);
2163 }
2164
2165 #ifdef __SCILAB_INT64__
2166 SciErr getMatrixOfInteger64InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, long long** _pllData)
2167 {
2168     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_INT64, _piRows, _piCols, (void**)_pllData);
2169 }
2170 #endif
2171
2172 static SciErr createCommonMatrixOfIntegerInNamedList(void* _pvCtx, const char* _pstName, int* /*_piParent*/, int _iItemPos, int _iPrecision, int _iRows, int _iCols, const void* _pvData)
2173 {
2174     SciErr sciErr = sciErrInit();
2175 #if 0
2176     int iVarID[nsiz];
2177     int iSaveRhs        = Rhs;
2178     int iSaveTop        = Top;
2179     int *piAddr         = NULL;
2180     int* piEnd          = NULL;
2181     int* piChildAddr    = NULL;
2182     int* piParent       = getLastNamedListAddress(_pstName, _iItemPos);
2183
2184
2185     if (!checkNamedVarFormat(_pvCtx, _pstName))
2186     {
2187         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createCommonMatrixOfIntegerInNamedList", _pstName);
2188         return sciErr;
2189     }
2190
2191     C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
2192     Top = Top + Nbvars + 1;
2193
2194     getNewVarAddressFromPosition(_pvCtx, Top, &piAddr);
2195
2196     sciErr = createCommomMatrixOfIntegerInList(_pvCtx, Top, _pstName, piParent, _iItemPos, _iPrecision, _iRows, _iCols, _pvData);
2197     if (sciErr.iErr)
2198     {
2199         addErrorMessage(&sciErr, API_ERROR_CREATE_INT_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), "createMatrixOfIntegerInNamedList", _iItemPos + 1, _pstName);
2200         return sciErr;
2201     }
2202
2203     sciErr = allocCommonItemInList(_pvCtx, piParent, _iItemPos, &piChildAddr);
2204     if (sciErr.iErr)
2205     {
2206         addErrorMessage(&sciErr, API_ERROR_CREATE_INT_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), "createMatrixOfIntegerInNamedList", _iItemPos + 1, _pstName);
2207         return sciErr;
2208     }
2209
2210     //integer : size in int32
2211     //1st case, 5 * 1 int8  -> 10 5 1 1 (1,2,3,4) (5,x,x,x)      -> 6 : 4 + 5/4 + !!(5%4) -> 4 + 1 + 1 -> 6
2212     //2nd case, 5 * 1 int16 -> 10 5 1 2   (1,2)     (3,4)   (5,x)   -> 7 : 4 + 5/2 + !!(5%2) -> 4 + 2 + 1 -> 7
2213     //3th case, 5 * 1 int32 -> 10 5 1 4     1         2       3   4 5 -> 9 : 4 + 5/1 + !!(5%1) -> 4 + 5 + 0 -> 9
2214     piEnd = piChildAddr + 4 + _iRows * _iCols / (sizeof(int) / (_iPrecision % 10)) + (int)(!!(_iRows * _iCols)) % ((sizeof(int) / (_iPrecision % 10)));
2215     closeList(Top, piEnd);
2216
2217     if (_iItemPos == piParent[1])
2218     {
2219         updateNamedListOffset(_pvCtx, Top, _pstName, piParent, _iItemPos, piEnd);
2220         popNamedListAddress(_pstName);
2221     }
2222
2223     Top = iSaveTop;
2224     Rhs = iSaveRhs;
2225 #endif
2226
2227     return sciErr;
2228 }
2229
2230 SciErr createMatrixOfUnsignedInteger8InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned char* _pucData)
2231 {
2232     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT8, _iRows, _iCols, _pucData);
2233 }
2234
2235 SciErr createMatrixOfUnsignedInteger16InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned short* _pusData)
2236 {
2237     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT16, _iRows, _iCols, _pusData);
2238 }
2239
2240 SciErr createMatrixOfUnsignedInteger32InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned int* _puiData)
2241 {
2242     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT32, _iRows, _iCols, _puiData);
2243 }
2244
2245 #ifdef __SCILAB_INT64__
2246 SciErr createMatrixOfUnsignedInteger64InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned long long* _pullData)
2247 {
2248     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT64, _iRows, _iCols, _pullData);
2249 }
2250 #endif
2251
2252 SciErr createMatrixOfInteger8InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const char* _pcData)
2253 {
2254     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT8, _iRows, _iCols, _pcData);
2255 }
2256
2257 SciErr createMatrixOfInteger16InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const short* _psData)
2258 {
2259     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT16, _iRows, _iCols, _psData);
2260 }
2261
2262 SciErr createMatrixOfInteger32InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const int* _piData)
2263 {
2264     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT32, _iRows, _iCols, _piData);
2265 }
2266
2267 #ifdef __SCILAB_INT64__
2268 SciErr createMatrixOfInteger64InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const long long* _pllData)
2269 {
2270     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT64, _iRows, _iCols, _pllData);
2271 }
2272 #endif
2273
2274 static SciErr readCommonMatrixOfIntgerInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iPrecision, int* _piRows, int* _piCols, void* _pvData)
2275 {
2276     SciErr sciErr = sciErrInit();
2277     int iNbItem    = 0;
2278     int* piAddr    = NULL;
2279     int* piRoot    = NULL;
2280     void* pvData   = NULL;
2281
2282     if (_piParent == NULL)
2283     {
2284         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
2285         if (sciErr.iErr)
2286         {
2287             addErrorMessage(&sciErr, API_ERROR_READ_INT_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfIntgerInNamedList", _iItemPos + 1, _pstName);
2288             return sciErr;
2289         }
2290
2291         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
2292     }
2293     else
2294     {
2295         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
2296     }
2297
2298     if (sciErr.iErr)
2299     {
2300         addErrorMessage(&sciErr, API_ERROR_READ_INT_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfIntgerInNamedList", _iItemPos + 1, _pstName);
2301         return sciErr;
2302     }
2303
2304     sciErr = getCommonMatrixOfInteger(_pvCtx, piAddr, _iPrecision, _piRows, _piCols, &pvData);
2305     if (sciErr.iErr)
2306     {
2307         addErrorMessage(&sciErr, API_ERROR_READ_INT_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfIntgerInNamedList", _iItemPos + 1, _pstName);
2308         return sciErr;
2309     }
2310
2311     if (_pvData == NULL)
2312     {
2313         return sciErr;
2314     }
2315
2316     memcpy(_pvData, pvData, (_iPrecision % 10 ) **_piRows **_piCols);
2317     return sciErr;
2318 }
2319
2320 SciErr readMatrixOfUnsignedInteger8InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned char* _pucData)
2321 {
2322     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT8, _piRows, _piCols, _pucData);
2323 }
2324
2325 SciErr readMatrixOfUnsignedInteger16InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned short* _pusData)
2326 {
2327     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT16, _piRows, _piCols, _pusData);
2328 }
2329
2330 SciErr readMatrixOfUnsignedInteger32InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned int* _puiData)
2331 {
2332     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT32, _piRows, _piCols, _puiData);
2333 }
2334
2335 #ifdef __SCILAB_INT64__
2336 SciErr readMatrixOfUnsignedInteger64InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned long long* _pullData)
2337 {
2338     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT64, _piRows, _piCols, _pullData);
2339 }
2340 #endif
2341
2342 SciErr readMatrixOfIntger8InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, char* _pcData)
2343 {
2344     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT8, _piRows, _piCols, _pcData);
2345 }
2346
2347 SciErr readMatrixOfIntger16InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, short* _psData)
2348 {
2349     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT16, _piRows, _piCols, _psData);
2350 }
2351
2352 SciErr readMatrixOfIntger32InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piData)
2353 {
2354     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT32, _piRows, _piCols, _piData);
2355 }
2356
2357 #ifdef __SCILAB_INT64__
2358 SciErr readMatrixOfIntger64InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, long long* _pllData)
2359 {
2360     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT64, _piRows, _piCols, _pllData);
2361 }
2362 #endif
2363
2364 /*********************
2365 * sparses functions *
2366 *********************/
2367
2368 static SciErr fillCommonSparseMatrixInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal, const double* _pdblImg, int* _piTotalSize)
2369 {
2370     SciErr sciErr = sciErrInit();
2371 #if 0
2372     int iNbItem    = 0;
2373     int iTotalLen   = 0;
2374     int* piOffset   = NULL;
2375     int* piNbItemRow = NULL;
2376     int* piColPos   = NULL;
2377     int* piChildAddr = NULL;
2378     double* pdblReal = NULL;
2379     double* pdblImg  = NULL;
2380     int iItemLen   = 0;
2381
2382     //Does item can be added in the list
2383     SciErr sciErr = getListItemNumber(_pvCtx, _piParent, &iNbItem);
2384     if (sciErr.iErr)
2385     {
2386         addErrorMessage(&sciErr, API_ERROR_FILL_SPARSE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexSparseMatrixInList" : "createComplexSparseMatrixInList", _iItemPos + 1);
2387         return sciErr;
2388     }
2389
2390     if (iNbItem < _iItemPos)
2391     {
2392         addErrorMessage(&sciErr, API_ERROR_ITEM_LIST_NUMBER, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexSparseMatrixInList" : "createSparseMatrixInNamedList", _iItemPos + 1);
2393         return sciErr;
2394     }
2395
2396     sciErr = allocCommonItemInList(_pvCtx, _piParent, _iItemPos, &piChildAddr);
2397     if (sciErr.iErr)
2398     {
2399         addErrorMessage(&sciErr, API_ERROR_FILL_SPARSE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexSparseMatrixInList" : "createComplexSparseMatrixInList", _iItemPos + 1);
2400         return sciErr;
2401     }
2402
2403     sciErr = fillCommonSparseMatrix(_pvCtx, piChildAddr, _iComplex, _iRows, _iCols, _iNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg, &iTotalLen);
2404     if (sciErr.iErr)
2405     {
2406         addErrorMessage(&sciErr, API_ERROR_FILL_SPARSE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexSparseMatrixInList" : "createComplexSparseMatrixInList", _iItemPos + 1);
2407         return sciErr;
2408     }
2409
2410     piOffset      = _piParent + 2;
2411
2412     iItemLen      = 5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
2413     iItemLen      += iTotalLen * 2;
2414     piOffset[_iItemPos] = piOffset[_iItemPos - 1] + ((iItemLen + 1) / 2);
2415
2416     memcpy(piNbItemRow, _piNbItemRow, _iRows * sizeof(int));
2417     memcpy(piColPos, _piColPos, _iNbItem * sizeof(int));
2418
2419     memcpy(pdblReal, _pdblReal, _iNbItem * sizeof(double));
2420     if (_iComplex)
2421     {
2422         memcpy(pdblImg, _pdblImg, _iNbItem * sizeof(double));
2423     }
2424
2425     *_piTotalSize = iTotalLen;
2426 #endif
2427     return sciErr;
2428 }
2429
2430 static SciErr createCommonSparseMatrixInList(void* _pvCtx, int _iVar, const char* _pstName, int* /*_piParent*/, int _iItemPos, int _iComplex, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal, const double* _pdblImg)
2431 {
2432     SciErr sciErr = sciErrInit();
2433 #if 0
2434     int* piAddr     = NULL;
2435     int *piEnd      = NULL;
2436     int iItemLen    = 0;
2437     int iTotalLen   = 0;
2438     int* piParent   = NULL;
2439
2440     if (_pstName)
2441     {
2442         piParent = getLastNamedListAddress(_pstName, _iItemPos);
2443     }
2444     else
2445     {
2446         piParent = getLastListAddress(_iVar, _iItemPos);
2447     }
2448
2449     sciErr = getListItemAddress(_pvCtx, piParent, _iItemPos, &piAddr);
2450     if (sciErr.iErr)
2451     {
2452         addErrorMessage(&sciErr, API_ERROR_CREATE_SPARSE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexSparseMatrixInList" : "createComplexSparseMatrixInList", _iItemPos + 1);
2453         return sciErr;
2454     }
2455
2456     sciErr = fillCommonSparseMatrixInList(_pvCtx, _iVar, piParent, _iItemPos, _iComplex, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg, &iTotalLen);
2457     if (sciErr.iErr)
2458     {
2459         addErrorMessage(&sciErr, API_ERROR_CREATE_SPARSE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexSparseMatrixInList" : "createComplexSparseMatrixInList", _iItemPos + 1);
2460         return sciErr;
2461     }
2462
2463     iItemLen      = 5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
2464     iItemLen      += iTotalLen * 2;
2465     piEnd        = piAddr + iItemLen;
2466     if (_iItemPos == piParent[1])
2467     {
2468         updateListOffset(_pvCtx, _iVar, piParent, _iItemPos, piEnd);
2469         popListAddress(_iVar);
2470     }
2471
2472     closeList(_iVar, piEnd);
2473
2474 #endif
2475     return sciErr;
2476 }
2477
2478 SciErr createSparseMatrixInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal)
2479 {
2480     return createCommonSparseMatrixInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
2481 }
2482
2483 SciErr createComplexSparseMatrixInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal, const double* _pdblImg)
2484 {
2485     return createCommonSparseMatrixInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
2486 }
2487
2488 SciErr createCommonSparseMatrixInNamedList(void* _pvCtx, const char* _pstName, int* /*_piParent*/, int _iItemPos, int _iComplex, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal, const double* _pdblImg)
2489 {
2490     SciErr sciErr = sciErrInit();
2491 #if 0
2492     int iVarID[nsiz];
2493     int iSaveRhs        = Rhs;
2494     int iSaveTop        = Top;
2495     int iItemLen        = 0;
2496     int *piAddr         = NULL;
2497     int* piEnd          = NULL;
2498     int* piChildAddr    = NULL;
2499     int* piParent       = getLastNamedListAddress(_pstName, _iItemPos);
2500
2501     if (!checkNamedVarFormat(_pvCtx, _pstName))
2502     {
2503         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createCommonSparseMatrixInNamedList", _pstName);
2504         return sciErr;
2505     }
2506
2507     C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
2508     Top = Top + Nbvars + 1;
2509
2510     getNewVarAddressFromPosition(_pvCtx, Top, &piAddr);
2511
2512     sciErr = createCommonSparseMatrixInList(_pvCtx, Top, _pstName, piParent, _iItemPos, _iComplex, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
2513     if (sciErr.iErr)
2514     {
2515         addErrorMessage(&sciErr, API_ERROR_CREATE_SPARSE_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), _iComplex ? "createComplexSparseMatrixInNamedList" : "createSparseMatrixInNamedList", _iItemPos + 1, _pstName);
2516         return sciErr;
2517     }
2518
2519     sciErr = allocCommonItemInList(_pvCtx, piParent, _iItemPos, &piChildAddr);
2520     if (sciErr.iErr)
2521     {
2522         addErrorMessage(&sciErr, API_ERROR_CREATE_SPARSE_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), _iComplex ? "createComplexSparseMatrixInNamedList" : "createSparseMatrixInNamedList", _iItemPos + 1, _pstName);
2523         return sciErr;
2524     }
2525
2526     iItemLen      = 5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
2527     iItemLen      += _iNbItem * (_iComplex + 1) * 2;
2528     piEnd        = piChildAddr + iItemLen;
2529     closeList(Top, piEnd);
2530
2531     if (_iItemPos == piParent[1])
2532     {
2533         updateNamedListOffset(_pvCtx, Top, _pstName, piParent, _iItemPos, piEnd);
2534         popNamedListAddress(_pstName);
2535     }
2536
2537     Top = iSaveTop;
2538     Rhs = iSaveRhs;
2539 #endif
2540
2541     return sciErr;
2542 }
2543
2544 SciErr createSparseMatrixInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal)
2545 {
2546     return createCommonSparseMatrixInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
2547 }
2548
2549 SciErr createComplexSparseMatrixInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos, const double* _pdblReal, const double* _pdblImg)
2550 {
2551     return createCommonSparseMatrixInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
2552 }
2553
2554 static SciErr getCommonSparseMatrixInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
2555 {
2556     int* piAddr  = NULL;
2557
2558     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
2559     if (sciErr.iErr)
2560     {
2561         addErrorMessage(&sciErr, API_ERROR_GET_SPARSE_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), _iComplex ? "getComplexSparseMatrixInList" : "getSparseMatrixInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
2562         return sciErr;
2563     }
2564
2565     sciErr = getCommonSparseMatrix(_pvCtx, piAddr, _iComplex, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
2566     if (sciErr.iErr)
2567     {
2568         addErrorMessage(&sciErr, API_ERROR_GET_SPARSE_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), _iComplex ? "getComplexSparseMatrixInList" : "getSparseMatrixInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
2569         return sciErr;
2570     }
2571
2572     return sciErr;
2573 }
2574
2575 SciErr getSparseMatrixInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal)
2576 {
2577     return getCommonSparseMatrixInList(_pvCtx, _piParent, _iItemPos, 0, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
2578 }
2579
2580 SciErr getComplexSparseMatrixInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
2581 {
2582     return getCommonSparseMatrixInList(_pvCtx, _piParent, _iItemPos, 1, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
2583 }
2584
2585 static SciErr readCommonSparseMatrixInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
2586 {
2587     SciErr sciErr = sciErrInit();
2588     int iNbItem    = 0;
2589     int* piAddr    = NULL;
2590     int* piRoot    = NULL;
2591     int* piNbItemRow = NULL;
2592     int* piColPos   = NULL;
2593     double* pdblReal = NULL;
2594     double* pdblImg  = NULL;
2595
2596     if (_piParent == NULL)
2597     {
2598         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
2599         if (sciErr.iErr)
2600         {
2601             addErrorMessage(&sciErr, API_ERROR_READ_SPARSE_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), _iComplex ? "readComplexSparseMatrixInNamedList" : "readSparseMatrixInNamedList", _iItemPos + 1, _pstName);
2602             return sciErr;
2603         }
2604
2605         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
2606     }
2607     else
2608     {
2609         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
2610     }
2611
2612     if (sciErr.iErr)
2613     {
2614         addErrorMessage(&sciErr, API_ERROR_READ_SPARSE_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), _iComplex ? "readComplexSparseMatrixInNamedList" : "readSparseMatrixInNamedList", _iItemPos + 1, _pstName);
2615         return sciErr;
2616     }
2617
2618     sciErr = getCommonSparseMatrix(_pvCtx, piAddr, _iComplex, _piRows, _piCols, _piNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
2619     if (sciErr.iErr)
2620     {
2621         addErrorMessage(&sciErr, API_ERROR_READ_SPARSE_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), _iComplex ? "readComplexSparseMatrixInNamedList" : "readSparseMatrixInNamedList", _iItemPos + 1, _pstName);
2622         return sciErr;
2623     }
2624
2625     if (_piNbItemRow == NULL)
2626     {
2627         return sciErr;
2628     }
2629     memcpy(_piNbItemRow, piNbItemRow, *_piRows * sizeof(int));
2630
2631     if (_piColPos == NULL)
2632     {
2633         return sciErr;
2634     }
2635     memcpy(_piColPos, piColPos, *_piNbItem * sizeof(int));
2636
2637     if (_pdblReal == NULL || (_iComplex && _pdblImg == NULL))
2638     {
2639         return sciErr;
2640     }
2641
2642     memcpy(_pdblReal, pdblReal, sizeof(double) **_piNbItem);
2643     if (_iComplex)
2644     {
2645         memcpy(_pdblImg, pdblImg, sizeof(double) **_piNbItem);
2646     }
2647
2648     return sciErr;
2649 }
2650
2651 SciErr readSparseMatrixInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal)
2652 {
2653     return readCommonSparseMatrixInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 0, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
2654 }
2655
2656 SciErr readComplexSparseMatrixInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
2657 {
2658     return readCommonSparseMatrixInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 1, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
2659 }
2660
2661
2662 /*****************************
2663 * boolean sparses functions *
2664 *****************************/
2665 static SciErr fillBooleanSparseMatrixInList(void* _pvCtx, int _iVar, const char* _pstName, int* /*_piParent*/, int _iItemPos, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos)
2666 {
2667     SciErr sciErr = sciErrInit();
2668 #if 0
2669     int iNbItem    = 0;
2670     int* piOffset   = NULL;
2671     int* piNbItemRow = NULL;
2672     int* piColPos   = NULL;
2673     int* piChildAddr = NULL;
2674     int iItemLen   = 0;
2675
2676     int* piParent = NULL;
2677
2678     if (_pstName)
2679     {
2680         piParent = getLastNamedListAddress(_pstName, _iItemPos);
2681     }
2682     else
2683     {
2684         piParent = getLastListAddress(_iVar, _iItemPos);
2685     }
2686
2687     //Does item can be added in the list
2688     SciErr sciErr = getListItemNumber(_pvCtx, piParent, &iNbItem);
2689     if (sciErr.iErr)
2690     {
2691         addErrorMessage(&sciErr, API_ERROR_FILL_BOOLEAN_SPARSE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createBooleanSparseMatrixInList", _iItemPos + 1);
2692         return sciErr;
2693     }
2694
2695     if (iNbItem < _iItemPos)
2696     {
2697         addErrorMessage(&sciErr, API_ERROR_ITEM_LIST_NUMBER, _("%s: Unable to create list item #%d in Scilab memory"), "createBooleanSparseMatrixInList", _iItemPos + 1);
2698         return sciErr;
2699     }
2700
2701     sciErr = allocCommonItemInList(_pvCtx, piParent, _iItemPos, &piChildAddr);
2702     if (sciErr.iErr)
2703     {
2704         addErrorMessage(&sciErr, API_ERROR_FILL_BOOLEAN_SPARSE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createBooleanSparseMatrixInList", _iItemPos + 1);
2705         return sciErr;
2706     }
2707
2708     sciErr = fillBooleanSparseMatrix(_pvCtx, piChildAddr, _iRows, _iCols, _iNbItem, &piNbItemRow, &piColPos);
2709     if (sciErr.iErr)
2710     {
2711         addErrorMessage(&sciErr, API_ERROR_FILL_BOOLEAN_SPARSE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createBooleanSparseMatrixInList", _iItemPos + 1);
2712         return sciErr;
2713     }
2714
2715     piOffset      = piParent + 2;
2716
2717     iItemLen      = 5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
2718     piOffset[_iItemPos] = piOffset[_iItemPos - 1] + ((iItemLen + 1) / 2);
2719
2720     memcpy(piNbItemRow, _piNbItemRow, _iRows * sizeof(int));
2721     memcpy(piColPos, _piColPos, _iNbItem * sizeof(int));
2722 #endif
2723     return sciErr;
2724 }
2725
2726 SciErr createBooleanSparseMatrixInList(void* _pvCtx, int _iVar, int* /*_piParent*/, int _iItemPos, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos)
2727 {
2728     int* piAddr     = NULL;
2729     int *piEnd      = NULL;
2730     int iItemLen    = 0;
2731     int* piParent   = getLastListAddress(_iVar, _iItemPos);
2732
2733     SciErr sciErr = getListItemAddress(_pvCtx, piParent, _iItemPos, &piAddr);
2734     if (sciErr.iErr)
2735     {
2736         addErrorMessage(&sciErr, API_ERROR_CREATE_BOOLEAN_SPARSE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createBooleanSparseMatrixInList", _iItemPos + 1);
2737         return sciErr;
2738     }
2739
2740     sciErr = fillBooleanSparseMatrixInList(_pvCtx, _iVar, NULL, piParent, _iItemPos, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos);
2741     if (sciErr.iErr)
2742     {
2743         addErrorMessage(&sciErr, API_ERROR_CREATE_BOOLEAN_SPARSE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createBooleanSparseMatrixInList", _iItemPos + 1);
2744         return sciErr;
2745     }
2746
2747     iItemLen      = 5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
2748     piEnd        = piAddr + iItemLen;
2749     if (_iItemPos == piParent[1])
2750     {
2751         updateListOffset(_pvCtx, _iVar, piParent, _iItemPos, piEnd);
2752         popListAddress(_iVar);
2753     }
2754
2755     closeList(_iVar, piEnd);
2756
2757     return sciErr;
2758 }
2759
2760 SciErr createBooleanSparseMatrixInNamedList(void* _pvCtx, const char* _pstName, int* /*_piParent*/, int _iItemPos, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos)
2761 {
2762     SciErr sciErr = sciErrInit();
2763 #if 0
2764     int iVarID[nsiz];
2765     int iSaveRhs        = Rhs;
2766     int iSaveTop        = Top;
2767     int iItemLen        = 0;
2768     int *piAddr         = NULL;
2769     int* piEnd          = NULL;
2770     int* piChildAddr    = NULL;
2771     int* piParent       = getLastNamedListAddress(_pstName, _iItemPos);
2772
2773     if (!checkNamedVarFormat(_pvCtx, _pstName))
2774     {
2775         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createBooleanSparseMatrixInNamedList", _pstName);
2776         return sciErr;
2777     }
2778
2779     C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
2780     Top = Top + Nbvars + 1;
2781
2782     getNewVarAddressFromPosition(_pvCtx, Top, &piAddr);
2783
2784     sciErr = fillBooleanSparseMatrixInList(_pvCtx, Top, _pstName, piParent, _iItemPos, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos);
2785     if (sciErr.iErr)
2786     {
2787         addErrorMessage(&sciErr, API_ERROR_CREATE_BOOLEAN_SPARSE_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), "createBooleanSparseMatrixInNamedList", _iItemPos + 1, _pstName);
2788         return sciErr;
2789     }
2790
2791     sciErr = allocCommonItemInList(_pvCtx, piParent, _iItemPos, &piChildAddr);
2792     if (sciErr.iErr)
2793     {
2794         addErrorMessage(&sciErr, API_ERROR_CREATE_BOOLEAN_SPARSE_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), "createBooleanSparseMatrixInNamedList", _iItemPos + 1, _pstName);
2795         return sciErr;
2796     }
2797
2798     iItemLen      = 5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
2799     piEnd        = piChildAddr + iItemLen;
2800     closeList(Top, piEnd);
2801
2802     if (_iItemPos == piParent[1])
2803     {
2804         updateNamedListOffset(_pvCtx, Top, _pstName, piParent, _iItemPos, piEnd);
2805         popNamedListAddress(_pstName);
2806     }
2807
2808     Top = iSaveTop;
2809     Rhs = iSaveRhs;
2810 #endif
2811
2812     return sciErr;
2813 }
2814
2815 SciErr getBooleanSparseMatrixInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos)
2816 {
2817     int* piAddr  = NULL;
2818
2819     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
2820     if (sciErr.iErr)
2821     {
2822         addErrorMessage(&sciErr, API_ERROR_GET_BOOLEAN_SPARSE_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "getBooleanSparseMatrixInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
2823         return sciErr;
2824     }
2825
2826     sciErr = getBooleanSparseMatrix(_pvCtx, piAddr, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos);
2827     if (sciErr.iErr)
2828     {
2829         addErrorMessage(&sciErr, API_ERROR_GET_BOOLEAN_SPARSE_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "getBooleanSparseMatrixInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
2830         return sciErr;
2831     }
2832
2833     return sciErr;
2834 }
2835
2836 SciErr readBooleanSparseMatrixInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos)
2837 {
2838     SciErr sciErr = sciErrInit();
2839     int iNbItem    = 0;
2840     int* piAddr    = NULL;
2841     int* piRoot    = NULL;
2842     int* piNbItemRow = NULL;
2843     int* piColPos   = NULL;
2844
2845     if (_piParent == NULL)
2846     {
2847         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
2848         if (sciErr.iErr)
2849         {
2850             addErrorMessage(&sciErr, API_ERROR_READ_BOOLEAN_SPARSE_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readBooleanSparseMatrixInNamedList", _iItemPos + 1, _pstName);
2851             return sciErr;
2852         }
2853
2854         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
2855     }
2856     else
2857     {
2858         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
2859     }
2860
2861     if (sciErr.iErr)
2862     {
2863         addErrorMessage(&sciErr, API_ERROR_READ_BOOLEAN_SPARSE_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readBooleanSparseMatrixInNamedList", _iItemPos + 1, _pstName);
2864         return sciErr;
2865     }
2866
2867     sciErr = getBooleanSparseMatrix(_pvCtx, piAddr, _piRows, _piCols, _piNbItem, &piNbItemRow, &piColPos);
2868     if (sciErr.iErr)
2869     {
2870         addErrorMessage(&sciErr, API_ERROR_READ_BOOLEAN_SPARSE_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readBooleanSparseMatrixInNamedList", _iItemPos + 1, _pstName);
2871         return sciErr;
2872     }
2873
2874     if (_piNbItemRow == NULL)
2875     {
2876         return sciErr;
2877     }
2878     memcpy(_piNbItemRow, piNbItemRow, *_piRows * sizeof(int));
2879
2880     if (_piColPos == NULL)
2881     {
2882         return sciErr;
2883     }
2884     memcpy(_piColPos, piColPos, *_piNbItem * sizeof(int));
2885
2886     return sciErr;
2887 }
2888
2889 /*********************
2890 * Pointer functions *
2891 *********************/
2892 SciErr getPointerInList(void* _pvCtx, int* _piParent, int _iItemPos, void** _pvPtr)
2893 {
2894     int* piAddr  = NULL;
2895
2896     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
2897     if (sciErr.iErr)
2898     {
2899         addErrorMessage(&sciErr, API_ERROR_GET_POINTER_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "getPointerInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
2900         return sciErr;
2901     }
2902
2903     sciErr = getPointer(_pvCtx, piAddr, _pvPtr);
2904     if (sciErr.iErr)
2905     {
2906         addErrorMessage(&sciErr, API_ERROR_GET_POINTER_IN_LIST, _("%s: Unable to get address of item #%d in argument #%d"), "getPointerInList", _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
2907         return sciErr;
2908     }
2909
2910     return sciErr;
2911 }
2912
2913 SciErr createPointerInList(void* _pvCtx, int _iVar, int* /*_piParent*/, int _iItemPos, void* _pvPtr)
2914 {
2915     SciErr sciErr = sciErrInit();
2916 #if 0
2917     int iNbItem         = 0;
2918     int* piOffset       = NULL;
2919     int* piChildAddr    = NULL;
2920     void* pvPtr         = NULL;
2921     int* piEnd          = NULL;
2922     int iNewPos         = Top - Rhs + _iVar;
2923     int* piParent       = getLastListAddress(_iVar, _iItemPos);
2924
2925     //Does item can be added in the list
2926     SciErr sciErr = getListItemNumber(_pvCtx, piParent, &iNbItem);
2927     if (sciErr.iErr)
2928     {
2929         addErrorMessage(&sciErr, API_ERROR_CREATE_POINTER_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createListInList", _iItemPos + 1);
2930         return sciErr;
2931     }
2932
2933     if (iNbItem < _iItemPos)
2934     {
2935         addErrorMessage(&sciErr, API_ERROR_ITEM_LIST_NUMBER, _("%s: Unable to create list item #%d in Scilab memory"), "createPointerInList", _iItemPos + 1);
2936         return sciErr;
2937     }
2938
2939
2940     sciErr = allocCommonItemInList(_pvCtx, piParent, _iItemPos, &piChildAddr);
2941     if (sciErr.iErr)
2942     {
2943         addErrorMessage(&sciErr, API_ERROR_CREATE_POINTER_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createListInList", _iItemPos + 1);
2944         return sciErr;
2945     }
2946
2947     sciErr = fillPointer(_pvCtx, piChildAddr, &pvPtr);
2948     if (sciErr.iErr)
2949     {
2950         addErrorMessage(&sciErr, API_ERROR_CREATE_POINTER_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createListInList", _iItemPos + 1);
2951         return sciErr;
2952     }
2953
2954     ((double*)pvPtr)[0] = (double) ((unsigned long int) _pvPtr);
2955
2956     piOffset      = piParent + 2;
2957     piOffset[_iItemPos] = piOffset[_iItemPos - 1] + 3;//2 for header and 1 for data ( n * 64 bits )
2958
2959     piEnd = piChildAddr + 6;//4 for header and 2 for data ( n * 32 bits )
2960     closeList(iNewPos, piEnd);
2961
2962     if (_iItemPos == piParent[1])
2963     {
2964         updateListOffset(_pvCtx, _iVar, piParent, _iItemPos, piEnd);
2965         popListAddress(_iVar);
2966     }
2967 #endif
2968     return sciErr;
2969 }
2970
2971 SciErr readPointerInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, void** _pvPtr)
2972 {
2973     SciErr sciErr = sciErrInit();
2974     int iNbItem    = 0;
2975     int* piAddr    = NULL;
2976     int* piRoot    = NULL;
2977
2978     if (_piParent == NULL)
2979     {
2980         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
2981         if (sciErr.iErr)
2982         {
2983             addErrorMessage(&sciErr, API_ERROR_READ_POINTER_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readPointerInNamedList", _iItemPos + 1, _pstName);
2984             return sciErr;
2985         }
2986
2987         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
2988     }
2989     else
2990     {
2991         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
2992     }
2993
2994     if (sciErr.iErr)
2995     {
2996         addErrorMessage(&sciErr, API_ERROR_READ_POINTER_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readPointerInNamedList", _iItemPos + 1, _pstName);
2997         return sciErr;
2998     }
2999
3000     sciErr = getPointer(_pvCtx, piAddr, _pvPtr);
3001     if (sciErr.iErr)
3002     {
3003         addErrorMessage(&sciErr, API_ERROR_READ_POINTER_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readPointerInNamedList", _iItemPos + 1, _pstName);
3004         return sciErr;
3005     }
3006
3007     return sciErr;
3008 }
3009
3010 SciErr createPointerInNamedList(void* _pvCtx, const char* _pstName, int* /*_piParent*/, int _iItemPos, void* _pvPtr)
3011 {
3012     SciErr sciErr = sciErrInit();
3013 #if 0
3014     int iVarID[nsiz];
3015     int iSaveRhs        = Rhs;
3016     int iSaveTop        = Top;
3017     int *piAddr         = NULL;
3018     int* piEnd          = NULL;
3019     int* piChildAddr    = NULL;
3020     int* piParent       = getLastNamedListAddress(_pstName, _iItemPos);
3021
3022     if (!checkNamedVarFormat(_pvCtx, _pstName))
3023     {
3024         addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createPointerInNamedList", _pstName);
3025         return sciErr;
3026     }
3027
3028     C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
3029     Top = Top + Nbvars + 1;
3030
3031     getNewVarAddressFromPosition(_pvCtx, Top, &piAddr);
3032
3033     sciErr = createPointerInList(_pvCtx, Top, piParent, _iItemPos, _pvPtr);
3034     if (sciErr.iErr)
3035     {
3036         addErrorMessage(&sciErr, API_ERROR_CREATE_POINTER_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), "createPointerInNamedList", _iItemPos + 1, _pstName);
3037         return sciErr;
3038     }
3039
3040     sciErr = allocCommonItemInList(_pvCtx, piParent, _iItemPos, &piChildAddr);
3041     if (sciErr.iErr)
3042     {
3043         addErrorMessage(&sciErr, API_ERROR_CREATE_POINTER_IN_NAMED_LIST, _("%s: Unable to create list item #%d in variable \"%s\""), "createPointerInNamedList", _iItemPos + 1, _pstName);
3044         return sciErr;
3045     }
3046
3047     piEnd = piChildAddr + 6;//4 for header + 2 for data
3048     closeList(Top, piEnd);
3049
3050     if (_iItemPos == piParent[1])
3051     {
3052         updateNamedListOffset(_pvCtx, Top, _pstName, piParent, _iItemPos, piEnd);
3053         popNamedListAddress(_pstName);
3054     }
3055
3056     Top = iSaveTop;
3057     Rhs = iSaveRhs;
3058 #endif
3059
3060     return sciErr;
3061 }
3062
3063
3064
3065 /********************
3066 * tools  functions *
3067 ********************/
3068
3069 static void updateNamedListOffset(void* _pvCtx, int _iVar, const char* _pstName, int *_piCurrentNode, int _iItemPos, int *_piEnd)
3070 {
3071     updateCommunListOffset(_pvCtx, _iVar, _pstName, _piCurrentNode, _iItemPos, _piEnd);
3072 }
3073
3074 static void updateListOffset(void* _pvCtx, int _iVar, int *_piCurrentNode, int _iItemPos, int *_piEnd)
3075 {
3076     // FIXME
3077 }
3078
3079 //internal tool functions
3080 static void updateCommunListOffset(void* _pvCtx, int _iVar, const char* _pstName, int *_piCurrentNode, int _iItemPos, int *_piEnd)
3081 {
3082     // FIXME
3083 #if 0
3084     if (_pstName == NULL)
3085     {
3086         int iLocalVar = _iVar - Top + Rhs;
3087         iMaxDepth = getDepthList(iLocalVar);
3088         if (iMaxDepth == 0)
3089         {
3090             return;
3091         }
3092
3093         piParent = (int**)MALLOC(sizeof(int*) * iMaxDepth);
3094         getListAdressses(iLocalVar, piParent);
3095     }
3096     else
3097     {
3098         iMaxDepth = getDepthNamedList(_pstName);
3099         if (iMaxDepth == 0)
3100         {
3101             return;
3102         }
3103
3104         piParent = (int**)MALLOC(sizeof(int*) * iMaxDepth);
3105         getNamedListAdressses(_pstName, piParent);
3106     }
3107     //    }
3108
3109     for (i = iMaxDepth - 2 ; i >= 0 ; i--)
3110     {
3111         int j     = 0;
3112         int iItem   = piParent[i][1];
3113         int *piOffset = piParent[i] + 2;
3114         int *piData  = piOffset + iItem + 1 + !(iItem % 2);
3115
3116         //for all nodes
3117         for (j = iItem - 1 ; j >= 0 ; j--)
3118         {
3119             if (piOffset[j] == -1)
3120             {
3121                 continue;
3122             }
3123
3124             int* piItem = piData + ((piOffset[j] - 1) * 2);
3125
3126             if (piItem == piParent[i + 1])
3127             {
3128                 int iOffset = 0;
3129                 iOffset  = piOffset[j] + (int)((_piEnd - piItem + 1) / 2);
3130                 piOffset[j + 1] = iOffset;
3131                 break;
3132             }
3133             //else
3134             //{
3135             // break;
3136             // //if this item is not the last of the parent list
3137             // //we don't need to continue to check the uppers levels
3138             //}
3139         }
3140     }
3141
3142     FREE(piParent);
3143 #endif
3144 }
3145
3146 static void closeList(int _iVar, int *_piEnd)
3147 {
3148     // FIXME
3149 }
3150 /*--------------------------------------------------------------------------*/
3151
3152 int isListType(void* _pvCtx, int* _piAddress)
3153 {
3154     return checkVarType(_pvCtx, _piAddress, sci_list);
3155 }
3156
3157 /*--------------------------------------------------------------------------*/
3158 int isNamedListType(void* _pvCtx, const char* _pstName)
3159 {
3160     return checkNamedVarType(_pvCtx, _pstName, sci_list);
3161 }
3162
3163 /*--------------------------------------------------------------------------*/
3164 int isTListType(void* _pvCtx, int* _piAddress)
3165 {
3166     return checkVarType(_pvCtx, _piAddress, sci_tlist);
3167 }
3168
3169 /*--------------------------------------------------------------------------*/
3170 int isNamedTListType(void* _pvCtx, const char* _pstName)
3171 {
3172     return checkNamedVarType(_pvCtx, _pstName, sci_tlist);
3173 }
3174
3175 /*--------------------------------------------------------------------------*/
3176 int isMListType(void* _pvCtx, int* _piAddress)
3177 {
3178     return checkVarType(_pvCtx, _piAddress, sci_mlist);
3179 }
3180
3181 /*--------------------------------------------------------------------------*/
3182 int isNamedMListType(void* _pvCtx, const char* _pstName)
3183 {
3184     return checkNamedVarType(_pvCtx, _pstName, sci_mlist);
3185 }
3186
3187 /*--------------------------------------------------------------------------*/