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