Coverity #1321406, #1321407 fixed
[scilab.git] / scilab / modules / api_scilab / src / cpp / api_stack_list.cpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2009 - DIGITEO - Antoine ELIAS
4 *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13 *
14 * Please note that piece of code will be rewrited for the Scilab 6 family
15 * However, the API (profile of the functions in the header files) will be
16 * still available and supported in Scilab 6.
17 */
18
19 #include <vector>
20 #include <map>
21 #include <string>
22 #include "list.hxx"
23 #include "listundefined.hxx"
24 #include "tlist.hxx"
25 #include "mlist.hxx"
26 #include "pointer.hxx"
27 #include "polynom.hxx"
28 #include "gatewaystruct.hxx"
29 #include "double.hxx"
30 #include "string.hxx"
31 #include "int.hxx"
32 #include "context.hxx"
33 #include "void.hxx"
34 #include "sparse.hxx"
35
36 extern "C"
37 {
38 #include <stdio.h>
39 #include <string.h>
40 #include "call_scilab.h"
41 #include "doublecomplex.h"
42 #include "api_scilab.h"
43 #include "api_internal_common.h"
44 #include "api_internal_double.h"
45 #include "api_internal_poly.h"
46 #include "api_internal_int.h"
47 #include "api_internal_sparse.h"
48 #include "api_internal_boolean_sparse.h"
49 #include "api_internal_pointer.h"
50 #include "localization.h"
51 }
52
53 //internal functions
54 static SciErr checkListItemPosition(void* _pvCtx, int* _piParent, int _iItemPos, int _apiError, const char* _functionName);
55 static SciErr createCommonList(void* _pvCtx, int _iVar, int _iListType, int _iNbItem, int** _piAddress);
56 static SciErr createCommonListInList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iListType, int _iNbItem, int** _piAddress);
57 static SciErr createCommonNamedList(void* _pvCtx, const char* _pstName, int _iListType, int _iNbItem, int** _piAddress);
58 static SciErr getCommonListInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iListType, int** _piAddress);
59 static SciErr getCommomListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iListType, int** _piAddress);
60 static SciErr readCommonNamedList(void* _pvCtx, const char* _pstName, int _iListType, int* _piNbItem, int** _piAddress);
61 static SciErr allocCommonMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, double **_pdblReal, double **_pdblImg);
62 static SciErr getCommonMatrixOfDoubleInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg);
63 static SciErr createCommonMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg);
64 static SciErr createCommonMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg);
65 static SciErr readCommonMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, double* _pdblReal, double* _pdblImg);
66 static SciErr getCommonMatrixOfPolyInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg);
67 static SciErr createCommonMatrixOfPolyInList(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);
68 static SciErr readCommonMatrixOfPolyInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg);
69 static SciErr createCommonMatrixOfStringInList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const char* const* _pstStrings);
70 static SciErr createCommonPointerInList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, void* _pvPtr);
71 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);
72 static SciErr createCommonBooleanSparseMatrixInList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos);
73 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);
74
75 const char* getListTypeName(int _iType)
76 {
77     switch (_iType)
78     {
79         case sci_list :
80             return "list";
81             break;
82         case sci_tlist :
83             return "tlist";
84             break;
85         case sci_mlist :
86             return "mlist";
87             break;
88         default:
89             break;
90     }
91     return "";
92 }
93
94 SciErr getListItemNumber(void* _pvCtx, int* _piAddress, int* _piNbItem)
95 {
96     int iType = 0;
97
98     SciErr sciErr = getVarType(_pvCtx, _piAddress, &iType);
99     if (sciErr.iErr)
100     {
101         addErrorMessage(&sciErr, API_ERROR_LIST_ITEM_NUMBER, _("%s: Unable to get item number of list"), "getListItemNumber");
102         return sciErr;
103     }
104
105     types::List* pL = (types::List*)_piAddress;
106     switch (iType)
107     {
108         case sci_list :
109         case sci_mlist :
110         case sci_tlist :
111             *_piNbItem = pL->getSize();
112             break;
113         default :
114             addErrorMessage(&sciErr, API_ERROR_INVALID_LIST_TYPE, _("%s: Invalid argument type, %s expected"), "getListItemNumber", _("list"));
115             return sciErr;
116     }
117     return sciErr;
118 }
119
120 SciErr getListItemAddress(void* _pvCtx, int* _piAddress, int _iItemNum, int** _piItemAddress)
121 {
122     int iItem           = 0;
123     int* piOffset       = NULL;
124     int* piItemAddress  = NULL;
125
126     SciErr sciErr = sciErrInit();
127
128     sciErr = checkListItemPosition(_pvCtx, _piAddress, _iItemNum, API_ERROR_GET_ITEM_ADDRESS, "getListItemAddress");
129     if (sciErr.iErr)
130     {
131         return sciErr;
132     }
133
134     types::List* pL = (types::List*)_piAddress;
135     //get offset of item array
136     types::InternalType* pIT = pL->get(_iItemNum - 1);
137     if (pIT->isListUndefined())
138     {
139         *_piItemAddress = NULL;
140     }
141     else
142     {
143         *_piItemAddress = (int*)pIT;
144     }
145     return sciErr;
146 }
147
148 SciErr checkListItemPosition(void* _pvCtx, int* _piParent, int _iItemPos, int _apiError, const char* _functionName)
149 {
150     SciErr sciErr = sciErrInit();
151     int iItem = 0;
152
153     // get a number of items
154     sciErr = getListItemNumber(_pvCtx, _piParent, &iItem);
155     if (sciErr.iErr)
156     {
157         addErrorMessage(&sciErr, API_ERROR_ITEM_LIST_NUMBER, _("%s: Unable to get address of item #%d in argument #%d"), _functionName, _iItemPos + 1, getRhsFromAddress(_pvCtx, _piParent));
158         return sciErr;
159     }
160     // check a valid item
161     if (_iItemPos > iItem)
162     {
163         addErrorMessage(&sciErr, _apiError, _("%s: Unable to create list item #%d in Scilab memory"), _functionName, _iItemPos + 1);
164         return sciErr;
165     }
166     return sciErr;
167 }
168
169 SciErr createList(void* _pvCtx, int _iVar, int _iNbItem, int** _piAddress)
170 {
171     return createCommonList(_pvCtx, _iVar, sci_list, _iNbItem, _piAddress);
172 }
173
174 SciErr createMList(void* _pvCtx, int _iVar, int _iNbItem, int** _piAddress)
175 {
176     return createCommonList(_pvCtx, _iVar, sci_mlist, _iNbItem, _piAddress);
177 }
178
179 SciErr createTList(void* _pvCtx, int _iVar, int _iNbItem, int** _piAddress)
180 {
181     return createCommonList(_pvCtx, _iVar, sci_tlist, _iNbItem, _piAddress);
182 }
183
184 SciErr createNamedList(void* _pvCtx, const char* _pstName, int _iNbItem, int** _piAddress)
185 {
186     return createCommonNamedList(_pvCtx, _pstName, sci_list, _iNbItem, _piAddress);
187 }
188
189 SciErr createNamedTList(void* _pvCtx, const char* _pstName, int _iNbItem, int** _piAddress)
190 {
191     return createCommonNamedList(_pvCtx, _pstName, sci_tlist, _iNbItem, _piAddress);
192 }
193
194 SciErr createNamedMList(void* _pvCtx, const char* _pstName, int _iNbItem, int** _piAddress)
195 {
196     return createCommonNamedList(_pvCtx, _pstName, sci_mlist, _iNbItem, _piAddress);
197 }
198
199 SciErr createNamedList(void* _pvCtx, const char* _pstName, int _iNbItem, int** _piAddress, bool useStack)
200 {
201
202     return createCommonNamedList(_pvCtx, _pstName, sci_list, _iNbItem, _piAddress);
203 }
204
205 SciErr createNamedTList(void* _pvCtx, const char* _pstName, int _iNbItem, int** _piAddress, bool useStack)
206 {
207     return createCommonNamedList(_pvCtx, _pstName, sci_tlist, _iNbItem, _piAddress);
208 }
209
210 SciErr createNamedMList(void* _pvCtx, const char* _pstName, int _iNbItem, int** _piAddress, bool useStack)
211 {
212     return createCommonNamedList(_pvCtx, _pstName, sci_mlist, _iNbItem, _piAddress);
213 }
214
215 static SciErr createCommonNamedList(void* _pvCtx, const char* _pstName, int _iListType, int _iNbItem, int** _piAddress)
216 {
217     SciErr sciErr = sciErrInit();
218
219     // check variable name
220     if (checkNamedVarFormat(_pvCtx, _pstName) == 0)
221     {
222         addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Invalid variable name: %s."), "createCommonNamedList", _pstName);
223         return sciErr;
224     }
225
226     types::List* pL = NULL;
227     try
228     {
229         if (_iListType == sci_list)
230         {
231             pL = new types::List();
232         }
233         else if (_iListType == sci_mlist)
234         {
235             pL = new types::MList();
236         }
237         else if (_iListType == sci_tlist)
238         {
239             pL = new types::TList();
240         }
241         else
242         {
243             addErrorMessage(&sciErr, API_ERROR_INVALID_LIST_TYPE, _("%s: Invalid argument type, %s expected"), "createNamedList", _("list"));
244             return sciErr;
245         }
246     }
247     catch (const ast::InternalError& ie)
248     {
249         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: %ls"), "createNamedList", ie.GetErrorMessage().c_str());
250         return sciErr;
251     }
252
253     if (pL == NULL)
254     {
255         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), "createNamedList");
256         return sciErr;
257     }
258
259     *_piAddress = (int*)pL;
260     // create a list with the user number of items
261     // it helps to check a wrong item, for example in createCommonListInList
262     pL->set(_iNbItem - 1, new types::ListUndefined());
263
264     wchar_t* pwstName = to_wide_string(_pstName);
265     symbol::Context* ctx = symbol::Context::getInstance();
266     symbol::Symbol sym = symbol::Symbol(pwstName);
267     FREE(pwstName);
268     if (ctx->isprotected(sym) == false)
269     {
270         ctx->put(sym, pL);
271     }
272     else
273     {
274         delete pL;
275         addErrorMessage(&sciErr, API_ERROR_REDEFINE_PERMANENT_VAR, _("Redefining permanent variable.\n"));
276     }
277     return sciErr;
278 }
279
280 static SciErr createCommonList(void* _pvCtx, int _iVar, int _iListType, int _iNbItem, int** _piAddress)
281 {
282     SciErr sciErr = sciErrInit();
283     if (_pvCtx == NULL)
284     {
285         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "createList");
286         return sciErr;
287     }
288
289     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
290     types::InternalType** out = pStr->m_pOut;
291
292     types::List* pL = NULL;
293     try
294     {
295         if (_iListType == sci_list)
296         {
297             pL = new types::List();
298         }
299         else if (_iListType == sci_mlist)
300         {
301             pL = new types::MList();
302         }
303         else if (_iListType == sci_tlist)
304         {
305             pL = new types::TList();
306         }
307         else
308         {
309             addErrorMessage(&sciErr, API_ERROR_INVALID_LIST_TYPE, _("%s: Invalid argument type, %s expected"), "createList", _("list"));
310             return sciErr;
311         }
312     }
313     catch (const ast::InternalError& ie)
314     {
315         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: %ls"), "createList", ie.GetErrorMessage().c_str());
316         return sciErr;
317     }
318
319     if (pL == NULL)
320     {
321         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), "createList");
322         return sciErr;
323     }
324
325     // create a list with the user number of items
326     // it helps to check a wrong item, for example in createCommonListInList
327     pL->set(_iNbItem - 1, new types::ListUndefined());
328
329     int rhs = _iVar - *getNbInputArgument(_pvCtx);
330     out[rhs - 1] = pL;
331     *_piAddress = (int*)pL;
332     return sciErr;
333 }
334
335 SciErr readNamedList(void* _pvCtx, const char* _pstName, int* _piNbItem, int** _piAddress)
336 {
337     return readCommonNamedList(_pvCtx, _pstName, sci_list, _piNbItem, _piAddress);
338 }
339
340 SciErr readNamedTList(void* _pvCtx, const char* _pstName, int* _piNbItem, int** _piAddress)
341 {
342     return readCommonNamedList(_pvCtx, _pstName, sci_tlist, _piNbItem, _piAddress);
343 }
344
345 SciErr readNamedMList(void* _pvCtx, const char* _pstName, int* _piNbItem, int** _piAddress)
346 {
347     return readCommonNamedList(_pvCtx, _pstName, sci_mlist, _piNbItem, _piAddress);
348 }
349
350 static SciErr readCommonNamedList(void* _pvCtx, const char* _pstName, int _iListType, int* _piNbItem, int** _piAddress)
351 {
352     int* piAddr  = NULL;
353     int iNbItem  = 0;
354
355     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
356     if (sciErr.iErr)
357     {
358         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_LIST, _("%s: Unable to get variable \"%s\""), "readNamedList", _pstName);
359         return sciErr;
360     }
361
362     if (piAddr[0] != _iListType)
363     {
364         addErrorMessage(&sciErr, API_ERROR_INVALID_LIST_TYPE, _("%s: Invalid argument type, %s expected"), "readNamedList", getListTypeName(_iListType));
365         return sciErr;
366     }
367
368     sciErr = getListItemNumber(_pvCtx, piAddr, &iNbItem);
369     if (sciErr.iErr)
370     {
371         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_LIST, _("%s: Unable to get variable \"%s\""), "readNamedList", _pstName);
372         return sciErr;
373     }
374
375     *_piNbItem = iNbItem;
376     *_piAddress = piAddr;
377
378     return sciErr;
379 }
380
381 SciErr getListInList(void* _pvCtx, int* _piParent, int _iItemPos, int** _piAddress)
382 {
383     return getCommonListInList(_pvCtx, _piParent, _iItemPos, sci_list, _piAddress);
384 }
385
386 SciErr getTListInList(void* _pvCtx, int* _piParent, int _iItemPos, int** _piAddress)
387 {
388     return getCommonListInList(_pvCtx, _piParent, _iItemPos, sci_tlist, _piAddress);
389 }
390
391 SciErr getMListInList(void* _pvCtx, int* _piParent, int _iItemPos, int** _piAddress)
392 {
393     return getCommonListInList(_pvCtx, _piParent, _iItemPos, sci_mlist, _piAddress);
394 }
395
396 SciErr getCommonListInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iListType, int** _piAddress)
397 {
398     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, _piAddress);
399     if (sciErr.iErr)
400     {
401         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));
402         return sciErr;
403     }
404
405     if ((*_piAddress)[0] != _iListType)
406     {
407         addErrorMessage(&sciErr, API_ERROR_INVALID_LIST_TYPE, _("%s: Invalid argument type, %s expected"), "getListInList", getListTypeName(_iListType));
408         return sciErr;
409     }
410     return sciErr;
411 }
412
413 SciErr getListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int** _piAddress)
414 {
415     return getCommomListInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, sci_list, _piAddress);
416 }
417
418 SciErr getTListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int** _piAddress)
419 {
420     return getCommomListInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, sci_tlist, _piAddress);
421 }
422
423 SciErr getMListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int** _piAddress)
424 {
425     return getCommomListInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, sci_mlist, _piAddress);
426 }
427
428 SciErr getCommomListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iListType, int** _piAddress)
429 {
430     SciErr sciErr = sciErrInit();
431     int* piAddr  = NULL;
432
433     sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
434     if (sciErr.iErr)
435     {
436         addErrorMessage(&sciErr, API_ERROR_GET_LIST_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "getListInNamedList", _iItemPos + 1, _pstName);
437         return sciErr;
438     }
439
440     if (piAddr[0] != _iListType)
441     {
442         addErrorMessage(&sciErr, API_ERROR_INVALID_LIST_TYPE, _("%s: Invalid argument type, %s expected"), "getListInNamedList", getListTypeName(_iListType));
443         return sciErr;
444     }
445
446     *_piAddress = piAddr;
447     return sciErr;
448 }
449
450 SciErr createListInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iNbItem, int** _piAddress)
451 {
452     return createCommonListInList(_pvCtx, NULL, _piParent, _iItemPos, sci_list, _iNbItem, _piAddress);
453 }
454
455 SciErr createTListInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iNbItem, int** _piAddress)
456 {
457     return createCommonListInList(_pvCtx, NULL, _piParent, _iItemPos, sci_tlist, _iNbItem, _piAddress);
458 }
459
460 SciErr createMListInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iNbItem, int** _piAddress)
461 {
462     return createCommonListInList(_pvCtx, NULL, _piParent, _iItemPos, sci_mlist, _iNbItem, _piAddress);
463 }
464
465 SciErr createListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iNbItem, int** _piAddress)
466 {
467     return createCommonListInList(_pvCtx, _pstName, _piParent, _iItemPos, sci_list, _iNbItem, _piAddress);
468 }
469
470 SciErr createTListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iNbItem, int** _piAddress)
471 {
472     return createCommonListInList(_pvCtx, _pstName, _piParent, _iItemPos, sci_tlist, _iNbItem, _piAddress);
473 }
474
475 SciErr createMListInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iNbItem, int** _piAddress)
476 {
477     return createCommonListInList(_pvCtx, _pstName, _piParent, _iItemPos, sci_mlist, _iNbItem, _piAddress);
478 }
479
480 static SciErr createCommonListInList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iListType, int _iNbItem, int** _piAddress)
481 {
482     SciErr sciErr        = sciErrInit();
483     const char* funcName = NULL;
484     int apiError         = API_ERROR_CREATE_LIST_IN_LIST;
485
486     if (_piParent != NULL)
487     {
488         funcName = "createListInList";
489     }
490     else
491     {
492         funcName = "createListInNamedList";
493         apiError = API_ERROR_CREATE_LIST_IN_NAMED_LIST;
494     }
495
496     sciErr = checkListItemPosition(_pvCtx, _piParent, _iItemPos, apiError, funcName);
497     if (sciErr.iErr)
498     {
499         return sciErr;
500     }
501
502     types::List* pChild = NULL;
503     try
504     {
505         if (_iListType == sci_list)
506         {
507             pChild = new types::List();
508         }
509         else if (_iListType == sci_mlist)
510         {
511             pChild = new types::MList();
512         }
513         else if (_iListType == sci_tlist)
514         {
515             pChild = new types::TList();
516         }
517         else
518         {
519             addErrorMessage(&sciErr, API_ERROR_INVALID_LIST_TYPE, _("%s: Invalid argument type, %s expected"), funcName, _("list"));
520             return sciErr;
521         }
522     }
523     catch (const ast::InternalError& ie)
524     {
525         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: %ls"), funcName, ie.GetErrorMessage().c_str());
526         return sciErr;
527     }
528
529     if (pChild == NULL)
530     {
531         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), funcName);
532         return sciErr;
533     }
534     // create a list in the list with a user number of items
535     pChild->set(_iNbItem - 1, new types::ListUndefined());
536
537     types::List* pParent = (types::List*)_piParent;
538     pParent->set(_iItemPos - 1, pChild);
539     *_piAddress = (int*)pChild;
540     return sciErr;
541 }
542
543 /******************************
544 * Void and defined functions *
545 ******************************/
546 SciErr createVoidInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos)
547 {
548     SciErr sciErr   = sciErrInit();
549
550     sciErr = checkListItemPosition(_pvCtx, _piParent, _iItemPos, API_ERROR_CREATE_VOID_IN_LIST, "createVoidInNamedList");
551     if (sciErr.iErr)
552     {
553         return sciErr;
554     }
555
556     types::List* pL = (types::List*)_piParent;
557     if (pL == NULL)
558     {
559         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), "createVoidInNamedList");
560         return sciErr;
561     }
562
563     pL->set(_iItemPos - 1, new types::Void());
564     return sciErr;
565 }
566
567 SciErr createUndefinedInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos)
568 {
569     SciErr sciErr   = sciErrInit();
570
571     sciErr = checkListItemPosition(_pvCtx, _piParent, _iItemPos, API_ERROR_CREATE_VOID_IN_LIST, "createUndefinedInNamedList");
572     if (sciErr.iErr)
573     {
574         return sciErr;
575     }
576
577     types::List* pL = (types::List*)_piParent;
578     if (pL == NULL)
579     {
580         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), "createUndefinedInNamedList");
581         return sciErr;
582     }
583
584     pL->set(_iItemPos - 1, new types::ListUndefined());
585     return sciErr;
586 }
587
588 /*********************
589 * Double functions *
590 *********************/
591
592 SciErr getMatrixOfDoubleInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, double** _pdblReal)
593 {
594     return getCommonMatrixOfDoubleInList(_pvCtx, _piParent, _iItemPos, 0, _piRows, _piCols, _pdblReal, NULL);
595 }
596
597 SciErr getComplexMatrixOfDoubleInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg)
598 {
599     return getCommonMatrixOfDoubleInList(_pvCtx, _piParent, _iItemPos, 1, _piRows, _piCols, _pdblReal, _pdblImg);
600 }
601
602 static SciErr getCommonMatrixOfDoubleInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg)
603 {
604     int* piAddr  = NULL;
605
606     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
607     if (sciErr.iErr)
608     {
609         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));
610         return sciErr;
611     }
612
613     sciErr = getCommonMatrixOfDouble(_pvCtx, piAddr, '$', _iComplex, _piRows, _piCols, _pdblReal, _pdblImg);
614     if (sciErr.iErr)
615     {
616         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));
617         return sciErr;
618     }
619     return sciErr;
620 }
621
622 SciErr allocMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, double** _pdblReal)
623 {
624     return allocCommonMatrixOfDoubleInList(_pvCtx, _iVar, _piParent, _iItemPos, 0, _iRows, _iCols, _pdblReal, NULL);
625 }
626
627 SciErr allocComplexMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg)
628 {
629     return allocCommonMatrixOfDoubleInList(_pvCtx, _iVar, _piParent, _iItemPos, 1, _iRows, _iCols, _pdblReal, _pdblImg);
630 }
631
632 static SciErr allocCommonMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg)
633 {
634     SciErr sciErr   = sciErrInit();
635     int iItem       = 0;
636
637     sciErr = checkListItemPosition(_pvCtx, _piParent, _iItemPos, API_ERROR_ALLOC_DOUBLE_IN_LIST, _iComplex ? "allocComplexMatrixOfDoubleInList" : "allocMatrixOfDoubleInList");
638     if (sciErr.iErr)
639     {
640         return sciErr;
641     }
642
643     types::List* pParent = (types::List*)_piParent;
644     if (_iRows == 0 || _iCols == 0)
645     {
646         types::Double *pDbl = types::Double::Empty();
647         if (pDbl == NULL)
648         {
649             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
650             return sciErr;
651         }
652         pParent->set(_iItemPos - 1, pDbl);
653         return sciErr;
654     }
655
656     types::Double* pDbl = NULL;
657     try
658     {
659         pDbl = new types::Double(_iRows, _iCols, _iComplex == 1);
660     }
661     catch (const ast::InternalError& ie)
662     {
663         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: %ls"), _iComplex ? "allocComplexMatrixOfDoubleInList" : "allocMatrixOfDoubleInList", ie.GetErrorMessage().c_str());
664         return sciErr;
665     }
666
667     if (pDbl == NULL)
668     {
669         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), _iComplex ? "allocComplexMatrixOfDoubleInList" : "allocMatrixOfDoubleInList");
670         return sciErr;
671     }
672
673     *_pdblReal = pDbl->getReal();
674     if (*_pdblReal == NULL)
675     {
676         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), _iComplex ? "allocComplexMatrixOfDoubleInList" : "allocMatrixOfDoubleInList");
677         return sciErr;
678     }
679
680     if (_iComplex && _pdblImg != NULL)
681     {
682         *_pdblImg = pDbl->getImg();
683         if (*_pdblImg == NULL)
684         {
685             addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), _iComplex ? "allocComplexMatrixOfDoubleInList" : "allocMatrixOfDoubleInList");
686             return sciErr;
687         }
688     }
689
690     pParent->set(_iItemPos - 1, pDbl);
691     return sciErr;
692 }
693
694 SciErr createMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const double* _pdblReal)
695 {
696     return createCommonMatrixOfDoubleInList(_pvCtx, _iVar, _piParent, _iItemPos, 0, _iRows, _iCols, _pdblReal, NULL);
697 }
698
699 SciErr createComplexMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg)
700 {
701     return createCommonMatrixOfDoubleInList(_pvCtx, _iVar, _piParent, _iItemPos, 1, _iRows, _iCols, _pdblReal, _pdblImg);
702 }
703
704 SciErr createComplexZMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const doublecomplex* _pdblData)
705 {
706     SciErr sciErr       = sciErrInit();
707     double *pdblReal    = NULL;
708     double *pdblImg     = NULL;
709
710     sciErr = checkListItemPosition(_pvCtx, _piParent, _iItemPos, API_ERROR_CREATE_ZDOUBLE_IN_LIST, "createComplexZMatrixOfDoubleInList");
711     if (sciErr.iErr)
712     {
713         return sciErr;
714     }
715
716     sciErr = allocCommonMatrixOfDoubleInList(_pvCtx, _iVar, _piParent, _iItemPos, 1, _iRows, _iCols, &pdblReal, &pdblImg);
717     if (sciErr.iErr)
718     {
719         addErrorMessage(&sciErr, API_ERROR_CREATE_ZDOUBLE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createComplexZMatrixOfDoubleInList", _iItemPos + 1);
720         return sciErr;
721     }
722
723     vGetPointerFromDoubleComplex(_pdblData, _iRows * _iCols, pdblReal, pdblImg);
724
725     return sciErr;
726 }
727
728 SciErr createCommonMatrixOfDoubleInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg)
729 {
730     double *pdblReal = NULL;
731     double *pdblImg  = NULL;
732
733     SciErr sciErr = allocCommonMatrixOfDoubleInList(_pvCtx, _iVar, _piParent, _iItemPos, _iComplex, _iRows, _iCols, &pdblReal, &pdblImg);
734     if (sciErr.iErr)
735     {
736         addErrorMessage(&sciErr, API_ERROR_CREATE_DOUBLE_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexMatrixOfDoubleInList" : "createMatrixOfDoubleInList", _iItemPos + 1);
737         return sciErr;
738     }
739
740     if (_pdblReal != NULL)
741     {
742         memcpy(pdblReal, _pdblReal, _iRows * _iCols * sizeof(double));
743     }
744
745     if (_iComplex && _pdblImg != NULL)
746     {
747         memcpy(pdblImg, _pdblImg, _iRows * _iCols * sizeof(double));
748     }
749
750     return sciErr;
751 }
752
753 SciErr createMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const double* _pdblReal)
754 {
755     return createCommonMatrixOfDoubleInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 0, _iRows, _iCols, _pdblReal, NULL);
756 }
757
758 SciErr createComplexMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg)
759 {
760     return createCommonMatrixOfDoubleInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 1, _iRows, _iCols, _pdblReal, _pdblImg);
761 }
762
763 SciErr createComplexZMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const doublecomplex* _pdblData)
764 {
765     SciErr sciErr       = sciErrInit();
766     int iVar            = 0;
767     double *pdblReal    = NULL;
768     double *pdblImg     = NULL;
769
770     sciErr = allocCommonMatrixOfDoubleInList(_pvCtx, iVar, _piParent, _iItemPos, 1, _iRows, _iCols, &pdblReal, &pdblImg);
771     if (sciErr.iErr)
772     {
773         addErrorMessage(&sciErr, API_ERROR_CREATE_ZDOUBLE_IN_NAMED_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createComplexZMatrixOfDoubleInNamedList", _iItemPos + 1, _pstName);
774         return sciErr;
775     }
776
777     vGetPointerFromDoubleComplex(_pdblData, _iRows * _iCols, pdblReal, pdblImg);
778
779     return sciErr;
780 }
781
782 SciErr createCommonMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg)
783 {
784     SciErr sciErr    = sciErrInit();
785     double* pdblReal = NULL;
786     double* pdblImg  = NULL;
787     int iVar         = 0;
788
789     sciErr = allocCommonMatrixOfDoubleInList(_pvCtx, iVar, _piParent, _iItemPos, _iComplex, _iRows, _iCols, &pdblReal, &pdblImg);
790     if (sciErr.iErr)
791     {
792         addErrorMessage(&sciErr, API_ERROR_CREATE_DOUBLE_IN_NAMED_LIST, _("%s: Unable to create list item #%d in Scilab memory"), _iComplex ? "createComplexMatrixOfDoubleInNamedList" : "createMatrixOfDoubleInNamedList", _iItemPos + 1, _pstName);
793         return sciErr;
794     }
795
796     if (_pdblReal != NULL)
797     {
798         memcpy(pdblReal, _pdblReal, _iRows * _iCols * sizeof(double));
799     }
800
801     if (_iComplex && _pdblImg != NULL)
802     {
803         memcpy(pdblImg, _pdblImg, _iRows * _iCols * sizeof(double));
804     }
805
806     return sciErr;
807 }
808
809 SciErr readMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, double* _pdblReal)
810 {
811     return readCommonMatrixOfDoubleInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 0, _piRows, _piCols, _pdblReal, NULL);
812 }
813
814 SciErr readComplexMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, double* _pdblReal, double* _pdblImg)
815 {
816     return readCommonMatrixOfDoubleInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 1, _piRows, _piCols, _pdblReal, _pdblImg);
817 }
818
819 static SciErr readCommonMatrixOfDoubleInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, double* _pdblReal, double* _pdblImg)
820 {
821     SciErr sciErr = sciErrInit();
822     int iNbItem    = 0;
823     int* piAddr    = NULL;
824     int* piRoot    = NULL;
825     double* pdblReal = NULL;
826     double* pdblImg  = NULL;
827
828     if (_piParent == NULL)
829     {
830         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
831         if (sciErr.iErr)
832         {
833             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);
834             return sciErr;
835         }
836
837         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
838     }
839     else
840     {
841         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
842     }
843
844     if (sciErr.iErr)
845     {
846         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);
847         return sciErr;
848     }
849
850     sciErr = getCommonMatrixOfDouble(_pvCtx, piAddr, '$', _iComplex, _piRows, _piCols, &pdblReal, &pdblImg);
851     if (sciErr.iErr)
852     {
853         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);
854         return sciErr;
855     }
856
857     if (_pdblReal == NULL || (_iComplex && _pdblImg == NULL))
858     {
859         return sciErr;
860     }
861
862     memcpy(_pdblReal, pdblReal, sizeof(double) **_piRows **_piCols);
863     if (_iComplex)
864     {
865         memcpy(_pdblImg, pdblImg, sizeof(double) **_piRows **_piCols);
866     }
867     return sciErr;
868 }
869
870
871 /*********************
872 * Strings functions *
873 *********************/
874
875 SciErr getMatrixOfStringInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piLength, char** _pstStrings)
876 {
877     int* piAddr  = NULL;
878
879     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
880     if (sciErr.iErr)
881     {
882         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));
883         return sciErr;
884     }
885
886     sciErr = getMatrixOfString(_pvCtx, piAddr, _piRows, _piCols, _piLength, _pstStrings);
887     if (sciErr.iErr)
888     {
889         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));
890         return sciErr;
891     }
892
893     return sciErr;
894 }
895
896 SciErr createMatrixOfStringInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const char* const* _pstStrings)
897 {
898     return createCommonMatrixOfStringInList(_pvCtx, NULL, _piParent, _iItemPos, _iRows, _iCols, _pstStrings);
899 }
900
901 SciErr createMatrixOfStringInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const char* const* _pstStrings)
902 {
903     return createCommonMatrixOfStringInList(_pvCtx, _pstName, _piParent, _iItemPos, _iRows, _iCols, _pstStrings);
904 }
905
906 SciErr createCommonMatrixOfStringInList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const char* const* _pstStrings)
907 {
908     SciErr sciErr = sciErrInit();
909     const char* funcName = NULL;
910     int apiError         = API_ERROR_CREATE_STRING_IN_LIST;
911
912     if (_pstName == NULL)
913     {
914         funcName = "createMatrixOfStringInList";
915     }
916     else
917     {
918         funcName = "createMatrixOfStringInNamedList";
919         apiError = API_ERROR_CREATE_STRING_IN_NAMED_LIST;
920     }
921
922     sciErr = checkListItemPosition(_pvCtx, _piParent, _iItemPos, apiError, funcName);
923     if (sciErr.iErr)
924     {
925         return sciErr;
926     }
927
928     types::List* pParent = (types::List*)_piParent;
929     if (_iRows == 0 || _iCols == 0)
930     {
931         types::Double *pDbl = types::Double::Empty();
932         if (pDbl == NULL)
933         {
934             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
935             return sciErr;
936         }
937         pParent->set(_iItemPos - 1, pDbl);
938         return sciErr;
939     }
940
941     types::String* pS = NULL;
942     try
943     {
944         pS = new types::String(_iRows, _iCols);
945     }
946     catch (const ast::InternalError& ie)
947     {
948         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: %ls"), funcName, ie.GetErrorMessage().c_str());
949         return sciErr;
950     }
951
952     if (pS == NULL)
953     {
954         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), funcName);
955         return sciErr;
956     }
957
958     for (int i = 0 ; i < _iRows * _iCols ; i++)
959     {
960         wchar_t* pwst = to_wide_string(_pstStrings[i]);
961         pS->set(i, pwst);
962         FREE(pwst);
963     }
964
965     pParent->set(_iItemPos - 1, pS);
966     return sciErr;
967 }
968
969 SciErr readMatrixOfStringInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piLength, char** _pstStrings)
970 {
971     SciErr sciErr = sciErrInit();
972     int* piAddr    = NULL;
973     int* piRoot    = NULL;
974     int iNbItem    = 0;
975
976     if (_piParent == NULL)
977     {
978         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
979         if (sciErr.iErr)
980         {
981             addErrorMessage(&sciErr, API_ERROR_READ_STRING_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfStringInNamedList", _iItemPos + 1, _pstName);
982             return sciErr;
983         }
984
985         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
986     }
987     else
988     {
989         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
990     }
991
992     if (sciErr.iErr)
993     {
994         addErrorMessage(&sciErr, API_ERROR_READ_STRING_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfStringInNamedList", _iItemPos + 1, _pstName);
995         return sciErr;
996     }
997
998     sciErr = getMatrixOfString(_pvCtx, piAddr, _piRows, _piCols, _piLength, _pstStrings);
999     if (sciErr.iErr)
1000     {
1001         addErrorMessage(&sciErr, API_ERROR_READ_STRING_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfStringInNamedList", _iItemPos + 1, _pstName);
1002         return sciErr;
1003     }
1004
1005     return sciErr;
1006 }
1007
1008 /*********************
1009 * boolean functions *
1010 *********************/
1011
1012 SciErr getMatrixOfBooleanInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int** _piBool)
1013 {
1014     int* piAddr  = NULL;
1015
1016     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1017     if (sciErr.iErr)
1018     {
1019         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));
1020         return sciErr;
1021     }
1022
1023     sciErr = getMatrixOfBoolean(_pvCtx, piAddr, _piRows, _piCols, _piBool);
1024     if (sciErr.iErr)
1025     {
1026         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));
1027         return sciErr;
1028     }
1029
1030     return sciErr;
1031 }
1032
1033 SciErr createMatrixOfBooleanInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const int* _piBool)
1034 {
1035     SciErr sciErr   = sciErrInit();
1036     int *piBool     = NULL;
1037     int iVar        = 0;
1038
1039     sciErr = allocMatrixOfBooleanInList(_pvCtx, iVar, _piParent, _iItemPos, _iRows, _iCols, &piBool);
1040     if (sciErr.iErr)
1041     {
1042         addErrorMessage(&sciErr, API_ERROR_CREATE_BOOLEAN_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfBooleanInList", _iItemPos + 1);
1043         return sciErr;
1044     }
1045
1046     if (_piBool != NULL)
1047     {
1048         memcpy(piBool, _piBool, _iRows * _iCols * sizeof(int));
1049     }
1050
1051     return sciErr;
1052 }
1053
1054 SciErr allocMatrixOfBooleanInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int** _piBool)
1055 {
1056     SciErr sciErr   = sciErrInit();
1057
1058     sciErr = checkListItemPosition(_pvCtx, _piParent, _iItemPos, API_ERROR_ALLOC_BOOLEAN_IN_LIST, "allocMatrixOfBooleanInList");
1059     if (sciErr.iErr)
1060     {
1061         return sciErr;
1062     }
1063
1064     types::List* pParent = (types::List*)_piParent;
1065     if (_iRows == 0 || _iCols == 0)
1066     {
1067         types::Double *pDbl = types::Double::Empty();
1068         if (pDbl == NULL)
1069         {
1070             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
1071             return sciErr;
1072         }
1073         pParent->set(_iItemPos - 1, pDbl);
1074         return sciErr;
1075     }
1076
1077     types::Bool* pBool = NULL;
1078     try
1079     {
1080         pBool = new types::Bool(_iRows, _iCols);
1081     }
1082     catch (const ast::InternalError& ie)
1083     {
1084         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: %ls"), "allocMatrixOfBooleanInList", ie.GetErrorMessage().c_str());
1085         return sciErr;
1086     }
1087
1088     if (pBool == NULL)
1089     {
1090         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), "allocMatrixOfBooleanInList");
1091         return sciErr;
1092     }
1093
1094     *_piBool = pBool->get();
1095     if (*_piBool == NULL)
1096     {
1097         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), "allocMatrixOfBooleanInList");
1098         return sciErr;
1099     }
1100
1101     pParent->set(_iItemPos - 1, pBool);
1102     return sciErr;
1103 }
1104
1105 SciErr createMatrixOfBooleanInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const int* _piBool)
1106 {
1107     SciErr sciErr   = sciErrInit();
1108     int* piBool     = NULL;
1109     int iVar        = 0;
1110
1111     sciErr = allocMatrixOfBooleanInList(_pvCtx, iVar, _piParent, _iItemPos, _iRows, _iCols, &piBool);
1112     if (sciErr.iErr)
1113     {
1114         addErrorMessage(&sciErr, API_ERROR_CREATE_BOOLEAN_IN_NAMED_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfBooleanInNamedList", _iItemPos + 1, _pstName);
1115         return sciErr;
1116     }
1117
1118     if (_piBool != NULL)
1119     {
1120         memcpy(piBool, _piBool, _iRows * _iCols * sizeof(int));
1121     }
1122
1123     return sciErr;
1124 }
1125
1126 SciErr readMatrixOfBooleanInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piBool)
1127 {
1128     SciErr sciErr = sciErrInit();
1129     int* piAddr    = NULL;
1130     int* piRoot    = NULL;
1131     int iNbItem    = 0;
1132     int* piBool    = NULL;
1133
1134
1135     if (_piParent == NULL)
1136     {
1137         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
1138         if (sciErr.iErr)
1139         {
1140             addErrorMessage(&sciErr, API_ERROR_READ_BOOLEAN_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfBooleanInNamedList", _iItemPos + 1, _pstName);
1141             return sciErr;
1142         }
1143
1144         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
1145     }
1146     else
1147     {
1148         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1149     }
1150
1151     if (sciErr.iErr)
1152     {
1153         addErrorMessage(&sciErr, API_ERROR_READ_BOOLEAN_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfBooleanInNamedList", _iItemPos + 1, _pstName);
1154         return sciErr;
1155     }
1156
1157     sciErr = getMatrixOfBoolean(_pvCtx, piAddr, _piRows, _piCols, &piBool);
1158     if (sciErr.iErr)
1159     {
1160         addErrorMessage(&sciErr, API_ERROR_READ_BOOLEAN_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfBooleanInNamedList", _iItemPos + 1, _pstName);
1161         return sciErr;
1162     }
1163
1164     if (_piBool == NULL)
1165     {
1166         return sciErr;
1167     }
1168
1169     memcpy(_piBool, piBool, *_piRows **_piCols * sizeof(int));
1170     return sciErr;
1171 }
1172
1173
1174 /*************************
1175 * polynomials functions *
1176 *************************/
1177
1178 SciErr getMatrixOfPolyInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal)
1179 {
1180     return getCommonMatrixOfPolyInList(_pvCtx, _piParent, _iItemPos, 0, _piRows, _piCols, _piNbCoef, _pdblReal, NULL);
1181 }
1182
1183 SciErr getComplexMatrixOfPolyInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
1184 {
1185     return getCommonMatrixOfPolyInList(_pvCtx, _piParent, _iItemPos, 1, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
1186 }
1187
1188 SciErr getCommonMatrixOfPolyInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
1189 {
1190     int* piAddr  = NULL;
1191
1192     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1193     if (sciErr.iErr)
1194     {
1195         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));
1196         return sciErr;
1197     }
1198
1199     sciErr = getCommonMatrixOfPoly(_pvCtx, piAddr, _iComplex, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
1200     if (sciErr.iErr)
1201     {
1202         addErrorMessage(&sciErr, API_ERROR_GET_POLY_IN_LIST, _("API_ERROR_GET_POLY_IN_LIST"));
1203         return sciErr;
1204     }
1205
1206     return sciErr;
1207 }
1208
1209 SciErr createMatrixOfPolyInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal)
1210 {
1211     return createCommonMatrixOfPolyInList(_pvCtx, NULL, _piParent, _iItemPos, _pstVarName, 0, _iRows, _iCols, _piNbCoef, _pdblReal, NULL);
1212 }
1213
1214 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)
1215 {
1216     return createCommonMatrixOfPolyInList(_pvCtx, NULL, _piParent, _iItemPos, _pstVarName, 1, _iRows, _iCols, _piNbCoef, _pdblReal, _pdblImg);
1217 }
1218
1219 SciErr createMatrixOfPolyInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal)
1220 {
1221     return createCommonMatrixOfPolyInList(_pvCtx, _pstName, _piParent, _iItemPos, _pstVarName, 0, _iRows, _iCols, _piNbCoef, _pdblReal, NULL);
1222 }
1223
1224 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)
1225 {
1226     return createCommonMatrixOfPolyInList(_pvCtx, _pstName, _piParent, _iItemPos, _pstVarName, 1, _iRows, _iCols, _piNbCoef, _pdblReal, _pdblImg);
1227 }
1228
1229 SciErr createCommonMatrixOfPolyInList(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)
1230 {
1231     SciErr sciErr        = sciErrInit();
1232     const char* funcName = NULL;
1233     int apiError         = API_ERROR_CREATE_POLY_IN_LIST;
1234
1235     if (_pstName == NULL)
1236     {
1237         funcName = _iComplex ? "createComplexMatrixOfPolyInList" : "createMatrixOfPolyInList";
1238     }
1239     else
1240     {
1241         funcName = _iComplex ? "createComplexMatrixOfPolyInNamedList" : "createMatrixOfPolyInNamedList";
1242         apiError = API_ERROR_CREATE_POLY_IN_NAMED_LIST;
1243     }
1244
1245     sciErr = checkListItemPosition(_pvCtx, _piParent, _iItemPos, apiError, funcName);
1246     if (sciErr.iErr)
1247     {
1248         return sciErr;
1249     }
1250
1251     types::List* pParent = (types::List*)_piParent;
1252     //return empty matrix
1253     if (_iRows == 0 || _iCols == 0)
1254     {
1255         types::Double *pDbl = types::Double::Empty();
1256         if (pDbl == NULL)
1257         {
1258             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
1259             return sciErr;
1260         }
1261         pParent->set(_iItemPos - 1, pDbl);
1262         return sciErr;
1263     }
1264
1265     wchar_t* pstTemp = to_wide_string(_pstVarName);
1266     std::wstring wstTemp(pstTemp);
1267     types::Polynom* pP = new types::Polynom(wstTemp, _iRows, _iCols, _piNbCoef);
1268     FREE(pstTemp);
1269     if (pP == NULL)
1270     {
1271         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocated variable"), funcName);
1272         return sciErr;
1273     }
1274
1275     if (_iComplex)
1276     {
1277         pP->setComplex(true);
1278     }
1279
1280     for (int i = 0; i < pP->getSize(); i++)
1281     {
1282         types::Double* pD = new types::Double(_piNbCoef[i], 1, _iComplex == 1);
1283         pD->set(_pdblReal[i]);
1284         if (_iComplex)
1285         {
1286             pD->setImg(_pdblImg[i]);
1287         }
1288         pP->setCoef(i, pD);
1289         delete pD;
1290     }
1291
1292     pParent->set(_iItemPos - 1, pP);
1293     return sciErr;
1294 }
1295
1296 SciErr readMatrixOfPolyInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal)
1297 {
1298     return readCommonMatrixOfPolyInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 0, _piRows, _piCols, _piNbCoef, _pdblReal, NULL);
1299 }
1300
1301 SciErr readComplexMatrixOfPolyInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
1302 {
1303     return readCommonMatrixOfPolyInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 1, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
1304 }
1305
1306 SciErr readCommonMatrixOfPolyInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
1307 {
1308     SciErr sciErr = sciErrInit();
1309     int* piAddr    = NULL;
1310     int* piRoot    = NULL;
1311     int iNbItem    = 0;
1312
1313     if (_piParent == NULL)
1314     {
1315         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
1316         if (sciErr.iErr)
1317         {
1318             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);
1319             return sciErr;
1320         }
1321
1322         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
1323     }
1324     else
1325     {
1326         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1327     }
1328
1329     if (sciErr.iErr)
1330     {
1331         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);
1332         return sciErr;
1333     }
1334
1335     sciErr = getCommonMatrixOfPoly(_pvCtx, piAddr, _iComplex, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
1336     if (sciErr.iErr)
1337     {
1338         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);
1339         return sciErr;
1340     }
1341
1342     return sciErr;
1343 }
1344
1345 /**********************
1346 * integers functions *
1347 **********************/
1348
1349 static SciErr allocCommonMatrixOfIntegerInList(void* _pvCtx, int _iVar, const char* _pstName, int* _piParent, int _iItemPos, int _iPrecision, int _iRows, int _iCols, void** _pvData)
1350 {
1351     SciErr sciErr = sciErrInit();
1352
1353     sciErr = checkListItemPosition(_pvCtx, _piParent, _iItemPos, API_ERROR_ALLOC_INT_IN_LIST, "allocMatrixOfIntegerInList");
1354     if (sciErr.iErr)
1355     {
1356         return sciErr;
1357     }
1358
1359     types::List* pParent = (types::List*)_piParent;
1360     if (_iRows == 0 || _iCols == 0)
1361     {
1362         types::Double *pDbl = types::Double::Empty();
1363         if (pDbl == NULL)
1364         {
1365             addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
1366             return sciErr;
1367         }
1368         pParent->set(_iItemPos - 1, pDbl);
1369         return sciErr;
1370     }
1371
1372     types::InternalType* pIT = NULL;
1373     try
1374     {
1375         switch (_iPrecision)
1376         {
1377             case SCI_INT8 :
1378             {
1379                 types::Int8* pi = new types::Int8(_iRows, _iCols);
1380                 *_pvData = pi->get();
1381                 pIT = pi;
1382             }
1383             break;
1384             case SCI_UINT8 :
1385             {
1386                 types::UInt8* pi = new types::UInt8(_iRows, _iCols);
1387                 *_pvData = pi->get();
1388                 pIT = pi;
1389             }
1390             break;
1391             case SCI_INT16 :
1392             {
1393                 types::Int16* pi = new types::Int16(_iRows, _iCols);
1394                 *_pvData = pi->get();
1395                 pIT = pi;
1396             }
1397             break;
1398             case SCI_UINT16 :
1399             {
1400                 types::UInt16* pi = new types::UInt16(_iRows, _iCols);
1401                 *_pvData = pi->get();
1402                 pIT = pi;
1403             }
1404             break;
1405             case SCI_INT32 :
1406             {
1407                 types::Int32* pi = new types::Int32(_iRows, _iCols);
1408                 *_pvData = pi->get();
1409                 pIT = pi;
1410             }
1411             break;
1412             case SCI_UINT32 :
1413             {
1414                 types::UInt32* pi = new types::UInt32(_iRows, _iCols);
1415                 *_pvData = pi->get();
1416                 pIT = pi;
1417             }
1418             break;
1419             case SCI_INT64 :
1420             {
1421                 types::Int64* pi = new types::Int64(_iRows, _iCols);
1422                 *_pvData = pi->get();
1423                 pIT = pi;
1424             }
1425             break;
1426             case SCI_UINT64 :
1427             {
1428                 types::UInt64* pi = new types::UInt64(_iRows, _iCols);
1429                 *_pvData = pi->get();
1430                 pIT = pi;
1431             }
1432             break;
1433         }
1434     }
1435     catch (const ast::InternalError& ie)
1436     {
1437         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: %ls"), "allocMatrixOfIntegerInList", ie.GetErrorMessage().c_str());
1438         return sciErr;
1439     }
1440
1441     if (pIT == NULL)
1442     {
1443         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), "allocMatrixOfIntegerInList");
1444         return sciErr;
1445     }
1446
1447     pParent->set(_iItemPos - 1, pIT);
1448     return sciErr;
1449 }
1450
1451 SciErr allocMatrixOfUnsignedInteger8InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, unsigned char** _pucData)
1452 {
1453     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT8, _iRows, _iCols, (void **)_pucData);
1454 }
1455
1456 SciErr allocMatrixOfUnsignedInteger16InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, unsigned short** _pusData)
1457 {
1458     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT16, _iRows, _iCols, (void**)_pusData);
1459 }
1460
1461 SciErr allocMatrixOfUnsignedInteger32InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, unsigned int** _puiData)
1462 {
1463     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT32, _iRows, _iCols, (void**)_puiData);
1464 }
1465
1466 #ifdef __SCILAB_INT64__
1467 SciErr allocMatrixOfUnsignedInteger64InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, unsigned long long** _pullData)
1468 {
1469     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT64, _iRows, _iCols, (void**)_pullData);
1470 }
1471 #endif
1472
1473 SciErr allocMatrixOfInteger8InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, char** _pcData)
1474 {
1475     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT8, _iRows, _iCols, (void**)_pcData);
1476 }
1477
1478 SciErr allocMatrixOfInteger16InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, short** _psData)
1479 {
1480     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT16, _iRows, _iCols, (void**)_psData);
1481 }
1482
1483 SciErr allocMatrixOfInteger32InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int** _piData)
1484 {
1485     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT32, _iRows, _iCols, (void**)_piData);
1486 }
1487
1488 #ifdef __SCILAB_INT64__
1489 SciErr allocMatrixOfInteger64InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, long long** _pllData)
1490 {
1491     return allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT64, _iRows, _iCols, (void**)_pllData);
1492 }
1493 #endif
1494
1495 static SciErr createCommonMatrixOfIntegerInList(void* _pvCtx, int _iVar, const char* _pstName, int* _piParent, int _iItemPos, int _iPrecision, int _iRows, int _iCols, const void* _pvData)
1496 {
1497     void *pvData = NULL;
1498
1499     SciErr sciErr = allocCommonMatrixOfIntegerInList(_pvCtx, _iVar, _pstName, _piParent, _iItemPos, _iPrecision, _iRows, _iCols, &pvData);
1500     if (sciErr.iErr)
1501     {
1502         addErrorMessage(&sciErr, API_ERROR_CREATE_INT_IN_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfIntegerInList", _iItemPos + 1);
1503         return sciErr;
1504     }
1505
1506     if (pvData != NULL)
1507     {
1508         memcpy(pvData, _pvData, _iRows * _iCols * (_iPrecision % 10));
1509     }
1510     return sciErr;
1511 }
1512
1513 SciErr createMatrixOfUnsignedInteger8InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned char* _pucData)
1514 {
1515     return createCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT8, _iRows, _iCols, _pucData);
1516 }
1517
1518 SciErr createMatrixOfUnsignedInteger16InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned short* _pusData)
1519 {
1520     return createCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT16, _iRows, _iCols, _pusData);
1521 }
1522
1523 SciErr createMatrixOfUnsignedInteger32InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned int* _puiData)
1524 {
1525     return createCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT32, _iRows, _iCols, _puiData);
1526 }
1527
1528 #ifdef __SCILAB_INT64__
1529 SciErr createMatrixOfUnsignedInteger64InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned long long* _pullData)
1530 {
1531     return createCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_UINT64, _iRows, _iCols, _pullData);
1532 }
1533 #endif
1534
1535 SciErr createMatrixOfInteger8InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const char* _pcData)
1536 {
1537     return createCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT8, _iRows, _iCols, _pcData);
1538 }
1539
1540 SciErr createMatrixOfInteger16InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const short* _psData)
1541 {
1542     return createCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT16, _iRows, _iCols, _psData);
1543 }
1544
1545 SciErr createMatrixOfInteger32InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const int* _piData)
1546 {
1547     return createCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT32, _iRows, _iCols, _piData);
1548 }
1549
1550 #ifdef __SCILAB_INT64__
1551 SciErr createMatrixOfInteger64InList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, const long long* _pllData)
1552 {
1553     return createCommonMatrixOfIntegerInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, SCI_INT64, _iRows, _iCols, _pllData);
1554 }
1555 #endif
1556
1557 static SciErr getCommonMatrixOfIntegerInList(void* _pvCtx, int* _piParent, int _iItemPos, int _iPrecision, int* _piRows, int* _piCols, void** _pvData)
1558 {
1559     int* piAddr  = NULL;
1560
1561     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1562     if (sciErr.iErr)
1563     {
1564         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));
1565         return sciErr;
1566     }
1567
1568     sciErr = getCommonMatrixOfInteger(_pvCtx, piAddr, _iPrecision, _piRows, _piCols, _pvData);
1569     if (sciErr.iErr)
1570     {
1571         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));
1572         return sciErr;
1573     }
1574
1575     return sciErr;
1576 }
1577
1578 SciErr getMatrixOfUnsignedInteger8InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned char** _pucData)
1579 {
1580     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_UINT8, _piRows, _piCols, (void**)_pucData);
1581 }
1582
1583 SciErr getMatrixOfUnsignedInteger16InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned short** _pusData)
1584 {
1585     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_UINT16, _piRows, _piCols, (void**)_pusData);
1586 }
1587
1588 SciErr getMatrixOfUnsignedInteger32InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned int** _puiData)
1589 {
1590     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_UINT32, _piRows, _piCols, (void**)_puiData);
1591 }
1592
1593 #ifdef __SCILAB_INT64__
1594 SciErr getMatrixOfUnsignedInteger64InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned long long** _pullData)
1595 {
1596     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_UINT64, _piRows, _piCols, (void**)_pullData);
1597 }
1598 #endif
1599
1600 SciErr getMatrixOfInteger8InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, char** _pcData)
1601 {
1602     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_INT8, _piRows, _piCols, (void**)_pcData);
1603 }
1604
1605 SciErr getMatrixOfInteger16InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, short** _psData)
1606 {
1607     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_INT16, _piRows, _piCols, (void**)_psData);
1608 }
1609
1610 SciErr getMatrixOfInteger32InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int** _piData)
1611 {
1612     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_INT32, _piRows, _piCols, (void**)_piData);
1613 }
1614
1615 #ifdef __SCILAB_INT64__
1616 SciErr getMatrixOfInteger64InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, long long** _pllData)
1617 {
1618     return getCommonMatrixOfIntegerInList(_pvCtx, _piParent, _iItemPos, SCI_INT64, _piRows, _piCols, (void**)_pllData);
1619 }
1620 #endif
1621
1622 static SciErr createCommonMatrixOfIntegerInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iPrecision, int _iRows, int _iCols, const void* _pvData)
1623 {
1624     SciErr sciErr   = sciErrInit();
1625     void* pvData    = NULL;
1626     int iVar        = 0;
1627
1628     sciErr = allocCommonMatrixOfIntegerInList(_pvCtx, iVar, _pstName, _piParent, _iItemPos, _iPrecision, _iRows, _iCols, &pvData);
1629     if (sciErr.iErr)
1630     {
1631         addErrorMessage(&sciErr, API_ERROR_CREATE_INT_IN_NAMED_LIST, _("%s: Unable to create list item #%d in Scilab memory"), "createMatrixOfIntegerInNamedList", _iItemPos + 1, _pstName);
1632         return sciErr;
1633     }
1634
1635     if (pvData != NULL)
1636     {
1637         memcpy(pvData, _pvData, _iRows * _iCols * (_iPrecision % 10));
1638     }
1639
1640     return sciErr;
1641 }
1642
1643 SciErr createMatrixOfUnsignedInteger8InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned char* _pucData)
1644 {
1645     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT8, _iRows, _iCols, _pucData);
1646 }
1647
1648 SciErr createMatrixOfUnsignedInteger16InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned short* _pusData)
1649 {
1650     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT16, _iRows, _iCols, _pusData);
1651 }
1652
1653 SciErr createMatrixOfUnsignedInteger32InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned int* _puiData)
1654 {
1655     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT32, _iRows, _iCols, _puiData);
1656 }
1657
1658 #ifdef __SCILAB_INT64__
1659 SciErr createMatrixOfUnsignedInteger64InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const unsigned long long* _pullData)
1660 {
1661     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT64, _iRows, _iCols, _pullData);
1662 }
1663 #endif
1664
1665 SciErr createMatrixOfInteger8InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const char* _pcData)
1666 {
1667     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT8, _iRows, _iCols, _pcData);
1668 }
1669
1670 SciErr createMatrixOfInteger16InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const short* _psData)
1671 {
1672     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT16, _iRows, _iCols, _psData);
1673 }
1674
1675 SciErr createMatrixOfInteger32InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const int* _piData)
1676 {
1677     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT32, _iRows, _iCols, _piData);
1678 }
1679
1680 #ifdef __SCILAB_INT64__
1681 SciErr createMatrixOfInteger64InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, const long long* _pllData)
1682 {
1683     return createCommonMatrixOfIntegerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT64, _iRows, _iCols, _pllData);
1684 }
1685 #endif
1686
1687 static SciErr readCommonMatrixOfIntgerInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iPrecision, int* _piRows, int* _piCols, void* _pvData)
1688 {
1689     SciErr sciErr = sciErrInit();
1690     int iNbItem    = 0;
1691     int* piAddr    = NULL;
1692     int* piRoot    = NULL;
1693     void* pvData   = NULL;
1694
1695     if (_piParent == NULL)
1696     {
1697         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
1698         if (sciErr.iErr)
1699         {
1700             addErrorMessage(&sciErr, API_ERROR_READ_INT_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfIntgerInNamedList", _iItemPos + 1, _pstName);
1701             return sciErr;
1702         }
1703
1704         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
1705     }
1706     else
1707     {
1708         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1709     }
1710
1711     if (sciErr.iErr)
1712     {
1713         addErrorMessage(&sciErr, API_ERROR_READ_INT_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfIntgerInNamedList", _iItemPos + 1, _pstName);
1714         return sciErr;
1715     }
1716
1717     sciErr = getCommonMatrixOfInteger(_pvCtx, piAddr, _iPrecision, _piRows, _piCols, &pvData);
1718     if (sciErr.iErr)
1719     {
1720         addErrorMessage(&sciErr, API_ERROR_READ_INT_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readMatrixOfIntgerInNamedList", _iItemPos + 1, _pstName);
1721         return sciErr;
1722     }
1723
1724     if (_pvData == NULL)
1725     {
1726         return sciErr;
1727     }
1728
1729     memcpy(_pvData, pvData, (_iPrecision % 10 ) **_piRows **_piCols);
1730     return sciErr;
1731 }
1732
1733 SciErr readMatrixOfUnsignedInteger8InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned char* _pucData)
1734 {
1735     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT8, _piRows, _piCols, _pucData);
1736 }
1737
1738 SciErr readMatrixOfUnsignedInteger16InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned short* _pusData)
1739 {
1740     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT16, _piRows, _piCols, _pusData);
1741 }
1742
1743 SciErr readMatrixOfUnsignedInteger32InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned int* _puiData)
1744 {
1745     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT32, _piRows, _piCols, _puiData);
1746 }
1747
1748 #ifdef __SCILAB_INT64__
1749 SciErr readMatrixOfUnsignedInteger64InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned long long* _pullData)
1750 {
1751     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_UINT64, _piRows, _piCols, _pullData);
1752 }
1753 #endif
1754
1755 SciErr readMatrixOfIntger8InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, char* _pcData)
1756 {
1757     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT8, _piRows, _piCols, _pcData);
1758 }
1759
1760 SciErr readMatrixOfIntger16InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, short* _psData)
1761 {
1762     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT16, _piRows, _piCols, _psData);
1763 }
1764
1765 SciErr readMatrixOfIntger32InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piData)
1766 {
1767     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT32, _piRows, _piCols, _piData);
1768 }
1769
1770 #ifdef __SCILAB_INT64__
1771 SciErr readMatrixOfIntger64InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, long long* _pllData)
1772 {
1773     return readCommonMatrixOfIntgerInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, SCI_INT64, _piRows, _piCols, _pllData);
1774 }
1775 #endif
1776
1777 /*********************
1778 * sparses functions *
1779 *********************/
1780
1781 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)
1782 {
1783     SciErr sciErr = sciErrInit();
1784
1785     types::Sparse* pSparse = (types::Sparse*)_piParent;
1786
1787     if (_iComplex)
1788     {
1789         for (int i = 0; i < _iRows; i++)
1790         {
1791             for (int j = 0; j < _piNbItemRow[i]; j++)
1792             {
1793                 int iIndex = (*_piColPos++ - 1) * _iRows + i;
1794                 std::complex<double> cplx(*_pdblReal++, *_pdblImg++);
1795                 pSparse->set(iIndex, cplx);
1796             }
1797         }
1798     }
1799     else
1800     {
1801         for (int i = 0; i < _iRows; i++)
1802         {
1803             for (int j = 0; j < _piNbItemRow[i]; j++)
1804             {
1805                 int iIndex = (*_piColPos++ - 1) * _iRows + i;
1806                 pSparse->set(iIndex, *_pdblReal++);
1807             }
1808         }
1809     }
1810
1811     return sciErr;
1812 }
1813
1814 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)
1815 {
1816     SciErr sciErr        = sciErrInit();
1817     const char* funcName = NULL;
1818     int apiError         = API_ERROR_CREATE_SPARSE_IN_LIST;
1819
1820     if (_pstName == NULL)
1821     {
1822         funcName = _iComplex ? "createComplexSparseMatrixInList" : "createSparseMatrixInList";
1823     }
1824     else
1825     {
1826         funcName = _iComplex ? "createComplexSparseMatrixInNamedList" : "createSparseMatrixInNamedList";
1827         apiError = API_ERROR_CREATE_SPARSE_IN_NAMED_LIST;
1828     }
1829
1830     sciErr = checkListItemPosition(_pvCtx, _piParent, _iItemPos, apiError, funcName);
1831     if (sciErr.iErr)
1832     {
1833         return sciErr;
1834     }
1835
1836     types::Sparse* pSparse = NULL;
1837     try
1838     {
1839         pSparse = new types::Sparse(_iRows, _iCols, _iComplex == 1);
1840     }
1841     catch (const ast::InternalError& ie)
1842     {
1843         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: %ls"), funcName, ie.GetErrorMessage().c_str());
1844         return sciErr;
1845     }
1846
1847     if (pSparse == NULL)
1848     {
1849         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), funcName);
1850         return sciErr;
1851     }
1852
1853     sciErr = fillCommonSparseMatrixInList(_pvCtx, _iVar, (int*)pSparse, _iItemPos, _iComplex, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
1854     if (sciErr.iErr)
1855     {
1856         addErrorMessage(&sciErr, apiError, _("%s: Unable to create list item #%d in Scilab memory"), funcName, _iItemPos + 1);
1857         return sciErr;
1858     }
1859
1860     types::List* pParent = (types::List*)_piParent;
1861     pParent->set(_iItemPos - 1, pSparse);
1862
1863     return sciErr;
1864 }
1865
1866 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)
1867 {
1868     return createCommonSparseMatrixInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
1869 }
1870
1871 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)
1872 {
1873     return createCommonSparseMatrixInList(_pvCtx, _iVar, NULL, _piParent, _iItemPos, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
1874 }
1875
1876 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)
1877 {
1878     return createCommonSparseMatrixInList(_pvCtx, 0, _pstName, _piParent, _iItemPos, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
1879 }
1880
1881 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)
1882 {
1883     return createCommonSparseMatrixInList(_pvCtx, 0, _pstName, _piParent, _iItemPos, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
1884 }
1885
1886 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)
1887 {
1888     int* piAddr  = NULL;
1889
1890     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1891     if (sciErr.iErr)
1892     {
1893         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));
1894         return sciErr;
1895     }
1896
1897     sciErr = getCommonSparseMatrix(_pvCtx, piAddr, _iComplex, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
1898     if (sciErr.iErr)
1899     {
1900         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));
1901         return sciErr;
1902     }
1903
1904     return sciErr;
1905 }
1906
1907 SciErr getSparseMatrixInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal)
1908 {
1909     return getCommonSparseMatrixInList(_pvCtx, _piParent, _iItemPos, 0, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
1910 }
1911
1912 SciErr getComplexSparseMatrixInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
1913 {
1914     return getCommonSparseMatrixInList(_pvCtx, _piParent, _iItemPos, 1, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
1915 }
1916
1917 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)
1918 {
1919     SciErr sciErr = sciErrInit();
1920     int iNbItem    = 0;
1921     int* piAddr    = NULL;
1922     int* piRoot    = NULL;
1923     int* piNbItemRow = NULL;
1924     int* piColPos   = NULL;
1925     double* pdblReal = NULL;
1926     double* pdblImg  = NULL;
1927
1928     if (_piParent == NULL)
1929     {
1930         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
1931         if (sciErr.iErr)
1932         {
1933             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);
1934             return sciErr;
1935         }
1936
1937         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
1938     }
1939     else
1940     {
1941         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
1942     }
1943
1944     if (sciErr.iErr)
1945     {
1946         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);
1947         return sciErr;
1948     }
1949
1950     sciErr = getCommonSparseMatrix(_pvCtx, piAddr, _iComplex, _piRows, _piCols, _piNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
1951     if (sciErr.iErr)
1952     {
1953         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);
1954         return sciErr;
1955     }
1956
1957     if (_piNbItemRow == NULL)
1958     {
1959         return sciErr;
1960     }
1961     memcpy(_piNbItemRow, piNbItemRow, *_piRows * sizeof(int));
1962
1963     if (_piColPos == NULL)
1964     {
1965         return sciErr;
1966     }
1967     memcpy(_piColPos, piColPos, *_piNbItem * sizeof(int));
1968
1969     if (_pdblReal == NULL || (_iComplex && _pdblImg == NULL))
1970     {
1971         return sciErr;
1972     }
1973
1974     memcpy(_pdblReal, pdblReal, sizeof(double) **_piNbItem);
1975     if (_iComplex)
1976     {
1977         memcpy(_pdblImg, pdblImg, sizeof(double) **_piNbItem);
1978     }
1979
1980     return sciErr;
1981 }
1982
1983 SciErr readSparseMatrixInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal)
1984 {
1985     return readCommonSparseMatrixInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 0, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
1986 }
1987
1988 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)
1989 {
1990     return readCommonSparseMatrixInNamedList(_pvCtx, _pstName, _piParent, _iItemPos, 1, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
1991 }
1992
1993
1994 /*****************************
1995 * boolean sparses functions *
1996 *****************************/
1997 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)
1998 {
1999     SciErr sciErr = sciErrInit();
2000     types::SparseBool* pSparse = (types::SparseBool*)_piParent;
2001
2002     for (int i = 0; i < _iRows; i++)
2003     {
2004         for (int j = 0; j < _piNbItemRow[i]; j++)
2005         {
2006             int iIndex = (*_piColPos++ - 1) * _iRows + i;
2007             pSparse->set(iIndex, true);
2008         }
2009     }
2010
2011     return sciErr;
2012 }
2013
2014 SciErr createCommonBooleanSparseMatrixInList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos)
2015 {
2016     SciErr sciErr = sciErrInit();
2017     const char* funcName = NULL;
2018     int apiError = API_ERROR_CREATE_BOOLEAN_SPARSE_IN_LIST;
2019
2020     if (_pstName == NULL)
2021     {
2022         funcName = "createBooleanSparseMatrixInList";
2023     }
2024     else
2025     {
2026         funcName = "createBooleanSparseMatrixInNamedList";
2027         apiError = API_ERROR_CREATE_BOOLEAN_SPARSE_IN_NAMED_LIST;
2028     }
2029
2030     sciErr = checkListItemPosition(_pvCtx, _piParent, _iItemPos, apiError, funcName);
2031     if (sciErr.iErr)
2032     {
2033         return sciErr;
2034     }
2035
2036     types::SparseBool* pSparse = NULL;
2037     try
2038     {
2039         pSparse = new types::SparseBool(_iRows, _iCols);
2040     }
2041     catch (const ast::InternalError& ie)
2042     {
2043         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: %ls"), funcName, ie.GetErrorMessage().c_str());
2044         return sciErr;
2045     }
2046
2047     if (pSparse == NULL)
2048     {
2049         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), funcName);
2050         return sciErr;
2051     }
2052
2053     sciErr = fillBooleanSparseMatrixInList(_pvCtx, 0, NULL, (int*)pSparse, _iItemPos, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos);
2054     if (sciErr.iErr)
2055     {
2056         addErrorMessage(&sciErr, API_ERROR_CREATE_BOOLEAN_SPARSE_IN_NAMED_LIST, _("%s: Unable to create list item #%d in Scilab memory"), funcName, _iItemPos + 1);
2057         return sciErr;
2058     }
2059
2060     types::List* piParent = (types::List*)_piParent;
2061     piParent->set(_iItemPos - 1, pSparse);
2062
2063     return sciErr;
2064 }
2065
2066 SciErr createBooleanSparseMatrixInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos)
2067 {
2068     return createCommonBooleanSparseMatrixInList(_pvCtx, NULL, _piParent, _iItemPos, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos);
2069 }
2070
2071 SciErr createBooleanSparseMatrixInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos)
2072 {
2073     return createCommonBooleanSparseMatrixInList(_pvCtx, _pstName, _piParent, _iItemPos, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos);
2074 }
2075
2076 SciErr getBooleanSparseMatrixInList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos)
2077 {
2078     int* piAddr  = NULL;
2079
2080     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
2081     if (sciErr.iErr)
2082     {
2083         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));
2084         return sciErr;
2085     }
2086
2087     sciErr = getBooleanSparseMatrix(_pvCtx, piAddr, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos);
2088     if (sciErr.iErr)
2089     {
2090         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));
2091         return sciErr;
2092     }
2093
2094     return sciErr;
2095 }
2096
2097 SciErr readBooleanSparseMatrixInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos)
2098 {
2099     SciErr sciErr = sciErrInit();
2100     int iNbItem    = 0;
2101     int* piAddr    = NULL;
2102     int* piRoot    = NULL;
2103     int* piNbItemRow = NULL;
2104     int* piColPos   = NULL;
2105
2106     if (_piParent == NULL)
2107     {
2108         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
2109         if (sciErr.iErr)
2110         {
2111             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);
2112             return sciErr;
2113         }
2114
2115         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
2116     }
2117     else
2118     {
2119         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
2120     }
2121
2122     if (sciErr.iErr)
2123     {
2124         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);
2125         return sciErr;
2126     }
2127
2128     sciErr = getBooleanSparseMatrix(_pvCtx, piAddr, _piRows, _piCols, _piNbItem, &piNbItemRow, &piColPos);
2129     if (sciErr.iErr)
2130     {
2131         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);
2132         return sciErr;
2133     }
2134
2135     if (_piNbItemRow == NULL)
2136     {
2137         freeAllocatedBooleanSparse(piNbItemRow, piColPos);
2138         return sciErr;
2139     }
2140     memcpy(_piNbItemRow, piNbItemRow, *_piRows * sizeof(int));
2141
2142     if (_piColPos == NULL)
2143     {
2144         freeAllocatedBooleanSparse(piNbItemRow, piColPos);
2145         return sciErr;
2146     }
2147     memcpy(_piColPos, piColPos, *_piNbItem * sizeof(int));
2148
2149     freeAllocatedBooleanSparse(piNbItemRow, piColPos);
2150     return sciErr;
2151 }
2152
2153 /*********************
2154 * Pointer functions *
2155 *********************/
2156 SciErr getPointerInList(void* _pvCtx, int* _piParent, int _iItemPos, void** _pvPtr)
2157 {
2158     int* piAddr  = NULL;
2159
2160     SciErr sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
2161     if (sciErr.iErr)
2162     {
2163         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));
2164         return sciErr;
2165     }
2166
2167     sciErr = getPointer(_pvCtx, piAddr, _pvPtr);
2168     if (sciErr.iErr)
2169     {
2170         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));
2171         return sciErr;
2172     }
2173
2174     return sciErr;
2175 }
2176
2177 SciErr createPointerInList(void* _pvCtx, int _iVar, int* _piParent, int _iItemPos, void* _pvPtr)
2178 {
2179     return createCommonPointerInList(_pvCtx, NULL, _piParent, _iItemPos, _pvPtr);
2180 }
2181
2182 SciErr createPointerInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, void* _pvPtr)
2183 {
2184     return createCommonPointerInList(_pvCtx, _pstName, _piParent, _iItemPos, _pvPtr);
2185 }
2186
2187 SciErr createCommonPointerInList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, void* _pvPtr)
2188 {
2189     SciErr sciErr        = sciErrInit();
2190     const char* funcName = NULL;
2191     int apiError         = API_ERROR_CREATE_POINTER_IN_LIST;
2192
2193     if (_pstName == NULL)
2194     {
2195         funcName = "createPointerInList";
2196     }
2197     else
2198     {
2199         funcName = "createPointerInNamedList";
2200         apiError = API_ERROR_CREATE_POINTER_IN_NAMED_LIST;
2201     }
2202
2203     sciErr = checkListItemPosition(_pvCtx, _piParent, _iItemPos, apiError, funcName);
2204     if (sciErr.iErr)
2205     {
2206         return sciErr;
2207     }
2208
2209     types::Pointer* pP = NULL;
2210     try
2211     {
2212         pP = new types::Pointer(_pvPtr);
2213         if (pP == NULL)
2214         {
2215             addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), "createPointerInList");
2216             return sciErr;
2217         }
2218     }
2219     catch (const ast::InternalError& ie)
2220     {
2221         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: %ls"), "createPointerInList", ie.GetErrorMessage().c_str());
2222         return sciErr;
2223     }
2224
2225     types::List* pParent   = (types::List*)_piParent;
2226     pParent->set(_iItemPos - 1, pP);
2227
2228     return sciErr;
2229 }
2230
2231 SciErr readPointerInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, void** _pvPtr)
2232 {
2233     SciErr sciErr = sciErrInit();
2234     int iNbItem    = 0;
2235     int* piAddr    = NULL;
2236     int* piRoot    = NULL;
2237
2238     if (_piParent == NULL)
2239     {
2240         sciErr = readNamedList(_pvCtx, _pstName, &iNbItem, &piRoot);
2241         if (sciErr.iErr)
2242         {
2243             addErrorMessage(&sciErr, API_ERROR_READ_POINTER_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readPointerInNamedList", _iItemPos + 1, _pstName);
2244             return sciErr;
2245         }
2246
2247         sciErr = getListItemAddress(_pvCtx, piRoot, _iItemPos, &piAddr);
2248     }
2249     else
2250     {
2251         sciErr = getListItemAddress(_pvCtx, _piParent, _iItemPos, &piAddr);
2252     }
2253
2254     if (sciErr.iErr)
2255     {
2256         addErrorMessage(&sciErr, API_ERROR_READ_POINTER_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readPointerInNamedList", _iItemPos + 1, _pstName);
2257         return sciErr;
2258     }
2259
2260     sciErr = getPointer(_pvCtx, piAddr, _pvPtr);
2261     if (sciErr.iErr)
2262     {
2263         addErrorMessage(&sciErr, API_ERROR_READ_POINTER_IN_NAMED_LIST, _("%s: Unable to get address of item #%d in variable \"%s\""), "readPointerInNamedList", _iItemPos + 1, _pstName);
2264         return sciErr;
2265     }
2266
2267     return sciErr;
2268 }
2269
2270 /********************
2271 * tools  functions *
2272 ********************/
2273
2274 //internal tool functions
2275 /*--------------------------------------------------------------------------*/
2276
2277 int isListType(void* _pvCtx, int* _piAddress)
2278 {
2279     return checkVarType(_pvCtx, _piAddress, sci_list);
2280 }
2281
2282 /*--------------------------------------------------------------------------*/
2283 int isNamedListType(void* _pvCtx, const char* _pstName)
2284 {
2285     return checkNamedVarType(_pvCtx, _pstName, sci_list);
2286 }
2287
2288 /*--------------------------------------------------------------------------*/
2289 int isTListType(void* _pvCtx, int* _piAddress)
2290 {
2291     return checkVarType(_pvCtx, _piAddress, sci_tlist);
2292 }
2293
2294 /*--------------------------------------------------------------------------*/
2295 int isNamedTListType(void* _pvCtx, const char* _pstName)
2296 {
2297     return checkNamedVarType(_pvCtx, _pstName, sci_tlist);
2298 }
2299
2300 /*--------------------------------------------------------------------------*/
2301 int isMListType(void* _pvCtx, int* _piAddress)
2302 {
2303     return checkVarType(_pvCtx, _piAddress, sci_mlist);
2304 }
2305
2306 /*--------------------------------------------------------------------------*/
2307 int isNamedMListType(void* _pvCtx, const char* _pstName)
2308 {
2309     return checkNamedVarType(_pvCtx, _pstName, sci_mlist);
2310 }
2311 /*--------------------------------------------------------------------------*/