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 /*--------------------------------------------------------------------------*/