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