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