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