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