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