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