scilab/modules/hdf5/sci_gateway/cpp/sci_hdf5_load_v2.cpp

   1 /*
   2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3 * Copyright (C) 2009 - DIGITEO - Antoine ELIAS
   4 *
   5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
   6  *
   7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
   8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
   9  * This file was originally licensed under the terms of the CeCILL v2.1,
  10  * and continues to be available under such terms.
  11  * For more information, see the COPYING file which you should have received
  12  * along with this program.
  13 *
  14 */
  15
  16 #include <hdf5.h>
  17 #include "context.hxx"
  18 #include "list.hxx"
  19 #include "struct.hxx"
  20 #include "cell.hxx"
  21
  22 extern "C"
  23 {
  24 #include <string.h>
  25 #include "gw_hdf5.h"
  26 #include "sci_malloc.h"
  27 #include "Scierror.h"
  28 #include "localization.h"
  29 #include "sciprint.h"
  30 #include "api_scilab.h"
  31 #include "../../../call_scilab/includes/call_scilab.h"
  32 #include "h5_fileManagement.h"
  33 #include "h5_readDataFromFile.h"
  34 #include "h5_attributeConstants.h"
  35 #include "expandPathVariable.h"
  36 #include "stdlib.h"
  37 #include "freeArrayOfString.h"
  38 }
  39
  40 #include "hdf5_load_v1.hxx"
  41
  42 static bool import_variable(int* pvCtx, int _iFile, char* _pstVarName);
  43 static bool import_data(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  44 static bool import_double(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  45 static bool import_string(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  46 static bool import_boolean(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  47 static bool import_integer(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  48 static bool import_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  49 static bool import_boolean_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  50 static bool import_poly(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  51 static bool import_list(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname);
  52 static bool import_hypermat(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname);
  53 static bool import_struct(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname);
  54 static bool import_cell(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname);
  55 static bool import_void(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  56 static bool import_undefined(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  57
  58 static const std::string fname("load");
  59
  60 int sci_hdf5_load_v2(char *fn, int* pvApiCtx)
  61 {
  62     SciErr sciErr;
  63
  64     int* piAddr = NULL;
  65     char* pstFilename = NULL;
  66     char* pstExpandedFilename = NULL;
  67     bool bImport = true;
  68     const int nbIn = nbInputArgument(pvApiCtx);
  69     int iSelectedVar = nbIn - 1;
  70
  71     CheckInputArgumentAtLeast(pvApiCtx , 1);
  72     CheckOutputArgument(pvApiCtx, 1, 1);
  73
  74     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
  75     if (sciErr.iErr)
  76     {
  77         printError(&sciErr, 0);
  78         return 1;
  79     }
  80
  81     if (getAllocatedSingleString(pvApiCtx, piAddr, &pstFilename))
  82     {
  83         if (pstFilename)
  84         {
  85             freeAllocatedSingleString(pstFilename);
  86         }
  87
  88         Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), 2);
  89         return 1;
  90     }
  91
  92     //open hdf5 file
  93     pstExpandedFilename = expandPathVariable(pstFilename);
  94     int iFile = openHDF5File(pstExpandedFilename, 0);
  95     if (iFile < 0)
  96     {
  97         Scierror(999, _("%s: Unable to open file: %s\n"), fname.data(), pstFilename);
  98         FREE(pstExpandedFilename);
  99         FREE(pstFilename);
 100         return 1;
 101     }
 102
 103     FREE(pstExpandedFilename);
 104     FREE(pstFilename);
 105
 106     //manage version information
 107     int iVersion = getSODFormatAttribute(iFile);
 108     if (iVersion != SOD_FILE_VERSION)
 109     {
 110         if (iVersion > SOD_FILE_VERSION)
 111         {
 112             //can't read file with version newer that me !
 113             Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname.data(), SOD_FILE_VERSION, iVersion);
 114             return 1;
 115         }
 116         else
 117         {
 118             //call older import functions and exit or ... EXIT !
 119             if (iVersion == 1 || iVersion == -1)
 120             {
 121                 return sci_hdf5_load_v1(fn, pvApiCtx);
 122             }
 123         }
 124     }
 125
 126     std::vector<wchar_t*> varList;
 127     if (iSelectedVar)
 128     {
 129         //selected variable
 130         char* pstVarName = NULL;
 131         for (int i = 0 ; i < iSelectedVar ; i++)
 132         {
 133             sciErr = getVarAddressFromPosition(pvApiCtx, i + 2, &piAddr);
 134             if (sciErr.iErr)
 135             {
 136                 printError(&sciErr, 0);
 137                 return 1;
 138             }
 139
 140             if (getAllocatedSingleString(pvApiCtx, piAddr, &pstVarName))
 141             {
 142                 if (pstVarName)
 143                 {
 144                     freeAllocatedSingleString(pstVarName);
 145                 }
 146
 147                 Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), i + 1);
 148                 return 1;
 149             }
 150
 151             if (import_variable(pvApiCtx, iFile, pstVarName) == false)
 152             {
 153                 FREE(pstVarName);
 154                 bImport = false;
 155                 break;
 156             }
 157
 158             varList.push_back(to_wide_string(pstVarName));
 159             FREE(pstVarName);
 160             pstVarName = NULL;
 161         }
 162     }
 163     else
 164     {
 165         //all variables
 166         int iNbItem = 0;
 167         iNbItem = getVariableNames(iFile, NULL);
 168         if (iNbItem != 0)
 169         {
 170             char **pstVarNameList = (char **)MALLOC(sizeof(char *) * iNbItem);
 171
 172             iNbItem = getVariableNames(iFile, pstVarNameList);
 173
 174             //import all data
 175             for (int i = 0; i < iNbItem; i++)
 176             {
 177                 if (import_variable(pvApiCtx, iFile, pstVarNameList[i]) == false)
 178                 {
 179                     bImport = false;
 180                     break;
 181                 }
 182
 183                 varList.push_back(to_wide_string(pstVarNameList[i]));
 184             }
 185
 186             freeArrayOfString(pstVarNameList, iNbItem);
 187         }
 188     }
 189     //close the file
 190     closeHDF5File(iFile);
 191
 192     if (bImport == true && varList.size() != 0)
 193     {
 194         createMatrixOfWideString(pvApiCtx, nbIn + 1, 1, static_cast<int>(varList.size()), varList.data());
 195     }
 196     else
 197     {
 198         createEmptyMatrix(pvApiCtx, nbIn + 1);
 199     }
 200
 201     for (auto & i : varList)
 202     {
 203         FREE(i);
 204     }
 205
 206     AssignOutputVariable(pvApiCtx, 1) = nbIn + 1;
 207     ReturnArguments(pvApiCtx);
 208
 209     //  printf("End gateway !!!\n");
 210     return 0;
 211 }
 212
 213 static bool import_variable(int* pvCtx, int _iFile, char* _pstVarName)
 214 {
 215     int iDataSetId = getDataSetIdFromName(_iFile, _pstVarName);
 216     if (iDataSetId <= 0)
 217     {
 218         return false;
 219     }
 220
 221     return import_data(pvCtx, iDataSetId, 0, NULL, _pstVarName);
 222 }
 223
 224 static bool import_data(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 225 {
 226     bool bRet = false;
 227
 228     //get var type
 229     int iVarType = getScilabTypeFromDataSet(_iDatasetId);
 230
 231     switch (iVarType)
 232     {
 233         case sci_matrix:
 234         {
 235             bRet = import_double(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
 236             break;
 237         }
 238         case sci_strings:
 239         {
 240             bRet = import_string(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
 241             break;
 242         }
 243         case sci_list:
 244         case sci_tlist:
 245         case sci_mlist:
 246         {
 247             bRet = import_hypermat(pvCtx, _iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
 248             if (bRet == false)
 249             {
 250                 bRet = import_struct(pvCtx, _iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
 251             }
 252             if (bRet == false)
 253             {
 254                 bRet = import_cell(pvCtx, _iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
 255             }
 256             if (bRet == false)
 257             {
 258                 bRet = import_list(pvCtx, _iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
 259             }
 260             break;
 261         }
 262         case sci_boolean:
 263         {
 264             bRet = import_boolean(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
 265             break;
 266         }
 267         case sci_poly:
 268         {
 269             bRet = import_poly(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
 270             break;
 271         }
 272         case sci_ints:
 273         {
 274             bRet = import_integer(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
 275             break;
 276         }
 277         case sci_sparse:
 278         {
 279             bRet = import_sparse(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
 280             break;
 281         }
 282         case sci_boolean_sparse:
 283         {
 284             bRet = import_boolean_sparse(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
 285             break;
 286         }
 287         case sci_void:             //void item only on list variable
 288         {
 289             bRet = import_void(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
 290             break;
 291         }
 292         case sci_undefined:        //undefined item only on list variable
 293         {
 294             bRet = import_undefined(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
 295             break;
 296         }
 297         default:
 298         {
 299             Scierror(999, _("%s: Invalid HDF5 Scilab format.\n"), fname.data());
 300         }
 301     }
 302     return bRet;
 303 }
 304
 305 static bool import_void(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 306 {
 307     SciErr sciErr;
 308
 309     if (_piAddress)
 310     {
 311         sciErr = createVoidInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos);
 312     }
 313     else
 314     {
 315         return false;
 316     }
 317
 318     if (sciErr.iErr)
 319     {
 320         printError(&sciErr, 0);
 321         return false;
 322     }
 323
 324     //close void dataset
 325     closeDataSet(_iDatasetId);
 326     return true;
 327 }
 328
 329 static bool import_undefined(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 330 {
 331     SciErr sciErr;
 332
 333     if (_piAddress)
 334     {
 335         sciErr = createUndefinedInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos);
 336     }
 337     else
 338     {
 339         return false;
 340     }
 341
 342     if (sciErr.iErr)
 343     {
 344         printError(&sciErr, 0);
 345         return false;
 346     }
 347
 348     //close undefined dataset
 349     closeDataSet(_iDatasetId);
 350     return true;
 351 }
 352
 353 static bool import_double(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 354 {
 355     SciErr sciErr;
 356     int iRet = 0;
 357     double *pdblReal = NULL;
 358     double *pdblImg = NULL;
 359     int iDims = 0;
 360     int* piDims = NULL;
 361     int iComplex = 0;
 362     int iSize = 0;
 363
 364     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
 365     if (iRet < 0)
 366     {
 367         return false;
 368     }
 369
 370     if (iDims)
 371     {
 372         if (iDims > 2)
 373         {
 374             //hypermatrix
 375             return false;
 376         }
 377
 378         piDims = (int*)MALLOC(sizeof(int) * iDims);
 379         iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
 380
 381         if (iSize > 0)
 382         {
 383             pdblReal = (double *)MALLOC(iSize * sizeof(double));
 384
 385             if (iComplex)
 386             {
 387                 pdblImg = (double *)MALLOC(iSize * sizeof(double));
 388                 iRet = readDoubleComplexMatrix(_iDatasetId, pdblReal, pdblImg);
 389             }
 390             else
 391             {
 392                 iRet = readDoubleMatrix(_iDatasetId, pdblReal);
 393             }
 394
 395             //to be sure ti have 2 dims
 396             if (iDims == 1)
 397             {
 398                 FREE(piDims);
 399                 piDims = (int*)MALLOC(sizeof(int) * 2);
 400                 piDims[0] = 1;
 401                 piDims[1] = iSize;
 402             }
 403         }
 404     }
 405
 406     if (iDims == 0 || iSize == 0) //empty matrix
 407     {
 408         if (piDims)
 409         {
 410             FREE(piDims);
 411         }
 412
 413         /*bug 7224 : to close dataset */
 414         iRet = readEmptyMatrix(_iDatasetId);
 415         if (iRet)
 416         {
 417             return false;
 418         }
 419
 420         // Hack to sure that piDims will not be null at line 372.
 421         iDims = 2;
 422         piDims = (int*)MALLOC(sizeof(int) * iDims);
 423         memset(piDims, 0, sizeof(int) * iDims);
 424         pdblReal = (double*)MALLOC(sizeof(double) * 1);
 425         pdblReal[0] = 0;
 426         iComplex = 0;
 427     }
 428
 429     if (_piAddress == NULL)
 430     {
 431         if (iComplex)
 432         {
 433             sciErr = createNamedComplexMatrixOfDouble(pvCtx, _pstVarname, piDims[0], piDims[1], pdblReal, pdblImg);
 434         }
 435         else
 436         {
 437             sciErr = createNamedMatrixOfDouble(pvCtx, _pstVarname, piDims[0], piDims[1], pdblReal);
 438         }
 439     }
 440     else //if not null this variable is in a list
 441     {
 442         if (iComplex)
 443         {
 444             sciErr = createComplexMatrixOfDoubleInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal, pdblImg);
 445         }
 446         else
 447         {
 448             sciErr = createMatrixOfDoubleInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal);
 449         }
 450     }
 451
 452     FREE(piDims);
 453     FREE(pdblReal);
 454     if (iComplex)
 455     {
 456         FREE(pdblImg);
 457     }
 458
 459     if (sciErr.iErr)
 460     {
 461         printError(&sciErr, 0);
 462         return false;
 463     }
 464
 465     return true;
 466 }
 467
 468 static bool import_string(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 469 {
 470     SciErr sciErr;
 471     int iRet = 0;
 472     char **pstData = NULL;
 473     int iDims = 0;
 474     int* piDims = NULL;
 475     int iComplex = 0;
 476     int iSize = 0;
 477
 478     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
 479     if (iRet < 0)
 480     {
 481         return false;
 482     }
 483
 484     piDims = (int*)MALLOC(sizeof(int) * iDims);
 485     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
 486
 487     pstData = (char **)MALLOC(iSize * sizeof(char *));
 488
 489     iRet = readStringMatrix(_iDatasetId, pstData);
 490     if (iRet)
 491     {
 492         FREE(piDims);
 493         return false;
 494     }
 495
 496     if (_piAddress == NULL)
 497     {
 498         sciErr = createNamedMatrixOfString(pvCtx, _pstVarname, piDims[0], piDims[1], pstData);
 499     }
 500     else                        //if not null this variable is in a list
 501     {
 502         sciErr = createMatrixOfStringInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pstData);
 503     }
 504
 505     if (sciErr.iErr)
 506     {
 507         printError(&sciErr, 0);
 508         FREE(piDims);
 509         freeStringMatrix(_iDatasetId, pstData);
 510         FREE(pstData);
 511         return false;
 512     }
 513
 514     FREE(piDims);
 515     freeStringMatrix(_iDatasetId, pstData);
 516     FREE(pstData);
 517
 518     return true;
 519 }
 520
 521 static bool import_integer(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 522 {
 523     int iRet = 0;
 524     int iDims = 0;
 525     int* piDims = NULL;
 526     int iComplex = 0;
 527     int iSize = 0;
 528     int iPrec = 0;
 529     SciErr sciErr;
 530
 531     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
 532     if (iRet < 0)
 533     {
 534         return false;
 535     }
 536
 537     piDims = (int*)MALLOC(sizeof(int) * iDims);
 538     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
 539
 540     iRet = getDatasetPrecision(_iDatasetId, &iPrec);
 541     if (iRet)
 542     {
 543         FREE(piDims);
 544         return false;
 545     }
 546
 547     switch (iPrec)
 548     {
 549         case SCI_INT8:
 550         {
 551             char *pcData = NULL;
 552
 553             pcData = (char *)MALLOC(sizeof(char) * iSize);
 554             iRet = readInteger8Matrix(_iDatasetId, pcData);
 555             if (iRet)
 556             {
 557                 FREE(piDims);
 558                 return false;
 559             }
 560
 561             if (_piAddress == NULL)
 562             {
 563                 sciErr = createNamedMatrixOfInteger8(pvCtx, _pstVarname, piDims[0], piDims[1], pcData);
 564             }
 565             else
 566             {
 567                 sciErr = createMatrixOfInteger8InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pcData);
 568             }
 569
 570             FREE(pcData);
 571         }
 572         break;
 573         case SCI_UINT8:
 574         {
 575             unsigned char *pucData = NULL;
 576
 577             pucData = (unsigned char *)MALLOC(sizeof(unsigned char) * iSize);
 578             iRet = readUnsignedInteger8Matrix(_iDatasetId, pucData);
 579             if (iRet)
 580             {
 581                 FREE(piDims);
 582                 return false;
 583             }
 584
 585             if (_piAddress == NULL)
 586             {
 587                 sciErr = createNamedMatrixOfUnsignedInteger8(pvCtx, _pstVarname, piDims[0], piDims[1], pucData);
 588             }
 589             else
 590             {
 591                 sciErr = createMatrixOfUnsignedInteger8InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pucData);
 592             }
 593
 594             FREE(pucData);
 595         }
 596         break;
 597         case SCI_INT16:
 598         {
 599             short *psData = NULL;
 600
 601             psData = (short *)MALLOC(sizeof(short) * iSize);
 602             iRet = readInteger16Matrix(_iDatasetId, psData);
 603             if (iRet)
 604             {
 605                 FREE(piDims);
 606                 return false;
 607             }
 608
 609             if (_piAddress == NULL)
 610             {
 611                 sciErr = createNamedMatrixOfInteger16(pvCtx, _pstVarname, piDims[0], piDims[1], psData);
 612             }
 613             else
 614             {
 615                 sciErr = createMatrixOfInteger16InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], psData);
 616             }
 617
 618             FREE(psData);
 619         }
 620         break;
 621         case SCI_UINT16:
 622         {
 623             unsigned short *pusData = NULL;
 624
 625             pusData = (unsigned short *)MALLOC(sizeof(unsigned short) * iSize);
 626             iRet = readUnsignedInteger16Matrix(_iDatasetId, pusData);
 627             if (iRet)
 628             {
 629                 FREE(piDims);
 630                 return false;
 631             }
 632
 633             if (_piAddress == NULL)
 634             {
 635                 sciErr = createNamedMatrixOfUnsignedInteger16(pvCtx, _pstVarname, piDims[0], piDims[1], pusData);
 636             }
 637             else
 638             {
 639                 sciErr = createMatrixOfUnsignedInteger16InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pusData);
 640             }
 641
 642             FREE(pusData);
 643         }
 644         break;
 645         case SCI_INT32:
 646         {
 647             int *piData = NULL;
 648
 649             piData = (int *)MALLOC(sizeof(int) * iSize);
 650             iRet = readInteger32Matrix(_iDatasetId, piData);
 651             if (iRet)
 652             {
 653                 FREE(piDims);
 654                 return false;
 655             }
 656
 657             if (_piAddress == NULL)
 658             {
 659                 sciErr = createNamedMatrixOfInteger32(pvCtx, _pstVarname, piDims[0], piDims[1], piData);
 660             }
 661             else
 662             {
 663                 sciErr = createMatrixOfInteger32InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData);
 664             }
 665
 666             FREE(piData);
 667         }
 668         break;
 669         case SCI_UINT32:
 670         {
 671             unsigned int *puiData = NULL;
 672
 673             puiData = (unsigned int *)MALLOC(sizeof(unsigned int) * iSize);
 674             iRet = readUnsignedInteger32Matrix(_iDatasetId, puiData);
 675             if (iRet)
 676             {
 677                 FREE(piDims);
 678                 return false;
 679             }
 680
 681             if (_piAddress == NULL)
 682             {
 683                 sciErr = createNamedMatrixOfUnsignedInteger32(pvCtx, _pstVarname, piDims[0], piDims[1], puiData);
 684             }
 685             else
 686             {
 687                 sciErr = createMatrixOfUnsignedInteger32InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], puiData);
 688             }
 689
 690             FREE(puiData);
 691         }
 692         break;
 693         case SCI_INT64:
 694         {
 695 #ifdef __SCILAB_INT64__
 696             long long *pllData = NULL;
 697
 698             pllData = (long long *)MALLOC(sizeof(long long) * iSize);
 699             iRet = readInteger64Matrix(_iDatasetId, pllData);
 700             if (iRet)
 701             {
 702                 FREE(piDims);
 703                 return false;
 704             }
 705
 706             if (_piAddress == NULL)
 707             {
 708                 sciErr = createNamedMatrixOfInteger64(pvCtx, _pstVarname, piDims[0], piDims[1], pllData);
 709             }
 710             else
 711             {
 712                 sciErr = createMatrixOfInteger64InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pllData);
 713             }
 714
 715             FREE(pllData);
 716 #else
 717             FREE(piDims);
 718             return false;
 719 #endif
 720         }
 721         break;
 722         case SCI_UINT64:
 723         {
 724 #ifdef __SCILAB_INT64__
 725             unsigned long long *pullData = NULL;
 726
 727             pullData = (unsigned long long *)MALLOC(sizeof(unsigned long long) * iSize);
 728             iRet = readUnsignedInteger64Matrix(_iDatasetId, pullData);
 729             if (iRet)
 730             {
 731                 FREE(piDims);
 732                 return false;
 733             }
 734
 735             if (_piAddress == NULL)
 736             {
 737                 sciErr = createNamedMatrixOfUnsignedInteger64(pvCtx, _pstVarname, piDims[0], piDims[1], pullData);
 738             }
 739             else
 740             {
 741                 sciErr = createMatrixOfUnsignedInteger64InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pullData);
 742             }
 743
 744             FREE(pullData);
 745 #else
 746             FREE(piDims);
 747             return false;
 748 #endif
 749         }
 750         break;
 751         default:
 752             return false;
 753     }
 754
 755     FREE(piDims);
 756
 757     if (sciErr.iErr)
 758     {
 759         printError(&sciErr, 0);
 760         return false;
 761     }
 762
 763     return true;
 764 }
 765
 766 static bool import_boolean(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 767 {
 768     int iRet = 0;
 769     int *piData = NULL;
 770     int iDims = 0;
 771     int* piDims = NULL;
 772     int iComplex = 0;
 773     int iSize = 0;
 774     SciErr sciErr;
 775
 776     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
 777     if (iRet < 0)
 778     {
 779         return false;
 780     }
 781
 782     piDims = (int*)MALLOC(sizeof(int) * iDims);
 783     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
 784
 785     if (iSize == 0)
 786     {
 787         FREE(piDims);
 788         return false;
 789     }
 790
 791     piData = (int *)MALLOC(iSize * sizeof(int));
 792     iRet = readBooleanMatrix(_iDatasetId, piData);
 793     if (iRet)
 794     {
 795         FREE(piData);
 796         FREE(piDims);
 797         return false;
 798     }
 799
 800     if (_piAddress == NULL)
 801     {
 802         sciErr = createNamedMatrixOfBoolean(pvCtx, _pstVarname, piDims[0], piDims[1], piData);
 803     }
 804     else                        //if not null this variable is in a list
 805     {
 806         sciErr = createMatrixOfBooleanInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData);
 807     }
 808
 809     FREE(piDims);
 810     if (piData)
 811     {
 812         FREE(piData);
 813     }
 814
 815     if (sciErr.iErr)
 816     {
 817         printError(&sciErr, 0);
 818         return false;
 819     }
 820
 821     return true;
 822 }
 823
 824 static bool import_poly(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 825 {
 826     int iRet = 0;
 827     int iComplex = 0;
 828     char pstVarName[64] = { 0 };
 829     double **pdblReal = NULL;
 830     double **pdblImg = NULL;
 831     int *piNbCoef = NULL;
 832     int iDims = 0;
 833     int* piDims = NULL;
 834     int iSize = 0;
 835     SciErr sciErr;
 836
 837     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
 838     if (iRet < 0)
 839     {
 840         return false;
 841     }
 842
 843     piDims = (int*)MALLOC(sizeof(int) * iDims);
 844     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
 845
 846     if (iComplex)
 847     {
 848         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
 849         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
 850         pdblImg = (double **)MALLOC(iSize * sizeof(double *));
 851         iRet = readPolyComplexMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal, pdblImg);
 852     }
 853     else
 854     {
 855         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
 856         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
 857         iRet = readPolyMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal);
 858     }
 859
 860     if (iRet)
 861     {
 862         FREE(piDims);
 863         FREE(piNbCoef);
 864         for (int i = 0; i < iSize; i++)
 865         {
 866             FREE(pdblReal[i]);
 867         }
 868         FREE(pdblReal);
 869
 870         if (iComplex)
 871         {
 872             for (int i = 0; i < iSize; i++)
 873             {
 874                 FREE(pdblImg[i]);
 875             }
 876             FREE(pdblImg);
 877         }
 878
 879         return false;
 880     }
 881
 882     if (_piAddress == NULL)
 883     {
 884         if (iComplex)
 885         {
 886             sciErr = createNamedComplexMatrixOfPoly(pvCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal, pdblImg);
 887         }
 888         else
 889         {
 890             sciErr = createNamedMatrixOfPoly(pvCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
 891         }
 892     }
 893     else                        //if not null this variable is in a list
 894     {
 895         if (iComplex)
 896         {
 897             sciErr =
 898                 createComplexMatrixOfPolyInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal,
 899                         pdblImg);
 900         }
 901         else
 902         {
 903             sciErr = createMatrixOfPolyInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
 904         }
 905     }
 906
 907     FREE(piDims);
 908     FREE(piNbCoef);
 909     for (int i = 0; i < iSize; i++)
 910     {
 911         FREE(pdblReal[i]);
 912     }
 913
 914     FREE(pdblReal);
 915
 916     if (iComplex)
 917     {
 918         for (int i = 0; i < iSize; i++)
 919         {
 920             FREE(pdblImg[i]);
 921         }
 922
 923         FREE(pdblImg);
 924     }
 925
 926     if (sciErr.iErr)
 927     {
 928         printError(&sciErr, 0);
 929         return false;
 930     }
 931
 932     return true;
 933 }
 934
 935 static bool import_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 936 {
 937     int iRet = 0;
 938     int iRows = 0;
 939     int iCols = 0;
 940     int iComplex = 0;
 941     double *pdblReal = NULL;
 942     double *pdblImg = NULL;
 943     int iNbItem = 0;
 944     int *piNbItemRow = NULL;
 945     int *piColPos = NULL;
 946     SciErr sciErr;
 947
 948     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
 949     if (iRet)
 950     {
 951         return false;
 952     }
 953
 954     iComplex = isComplexData(_iDatasetId);
 955
 956     if (iComplex)
 957     {
 958         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
 959         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
 960         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
 961         pdblImg = (double *)MALLOC(iNbItem * sizeof(double));
 962         iRet = readSparseComplexMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
 963     }
 964     else
 965     {
 966         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
 967         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
 968         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
 969         iRet = readSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
 970     }
 971
 972     if (iRet)
 973     {
 974         FREE(piNbItemRow);
 975         FREE(piColPos);
 976         FREE(pdblReal);
 977         if (iComplex)
 978         {
 979             FREE(pdblImg);
 980         }
 981
 982         return false;
 983     }
 984
 985     if (_piAddress == NULL)
 986     {
 987         if (iComplex)
 988         {
 989             sciErr = createNamedComplexSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
 990         }
 991         else
 992         {
 993             sciErr = createNamedSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
 994         }
 995     }
 996     else //if not null this variable is in a list
 997     {
 998         if (iComplex)
 999         {
1000             sciErr = createComplexSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
1001         }
1002         else
1003         {
1004             sciErr = createSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
1005         }
1006     }
1007
1008     FREE(piNbItemRow);
1009     FREE(piColPos);
1010     FREE(pdblReal);
1011     if (iComplex)
1012     {
1013         FREE(pdblImg);
1014     }
1015
1016     if (sciErr.iErr)
1017     {
1018         printError(&sciErr, 0);
1019         return false;
1020     }
1021
1022     return true;
1023 }
1024
1025 static bool import_boolean_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
1026 {
1027     int iRet = 0;
1028     int iRows = 0;
1029     int iCols = 0;
1030     int iNbItem = 0;
1031     int *piNbItemRow = NULL;
1032     int *piColPos = NULL;
1033     SciErr sciErr;
1034
1035     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
1036     if (iRet)
1037     {
1038         return false;
1039     }
1040
1041     piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
1042     piColPos = (int *)MALLOC(iNbItem * sizeof(int));
1043
1044     iRet = readBooleanSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1045     if (iRet)
1046     {
1047         FREE(piNbItemRow);
1048         return false;
1049     }
1050
1051     if (_piAddress == NULL)
1052     {
1053         sciErr = createNamedBooleanSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1054     }
1055     else                        //if not null this variable is in a list
1056     {
1057         sciErr = createBooleanSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1058     }
1059
1060     FREE(piNbItemRow);
1061     FREE(piColPos);
1062
1063     if (sciErr.iErr)
1064     {
1065         printError(&sciErr, 0);
1066         return false;
1067     }
1068
1069     return true;
1070 }
1071
1072 static bool import_list(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1073 {
1074     int iRet = 0;
1075     int i = 0;
1076     int iItems = 0;
1077     int *piListAddr = NULL;
1078     hobj_ref_t *piItemRef = NULL;
1079     SciErr sciErr;
1080
1081     iRet = getListDims(_iDatasetId, &iItems);
1082     if (iRet)
1083     {
1084         return false;
1085     }
1086
1087     if (iItems == 0)
1088     {
1089         //special case for empty list
1090     }
1091     else
1092     {
1093         iRet = getListItemReferences(_iDatasetId, &piItemRef);
1094         if (iRet)
1095         {
1096             return false;
1097         }
1098     }
1099
1100     if (_piAddress == 0)
1101     {
1102         switch (_iVarType)
1103         {
1104             case sci_list:
1105                 sciErr = createNamedList(pvCtx, _pstVarname, iItems, &piListAddr);
1106                 break;
1107             case sci_tlist:
1108                 sciErr = createNamedTList(pvCtx, _pstVarname, iItems, &piListAddr);
1109                 break;
1110             case sci_mlist:
1111                 sciErr = createNamedMList(pvCtx, _pstVarname, iItems, &piListAddr);
1112                 break;
1113             default:
1114                 return false;
1115         }
1116     }
1117     else                        //if not null this variable is in a list
1118     {
1119         switch (_iVarType)
1120         {
1121             case sci_list:
1122                 sciErr = createListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1123                 break;
1124             case sci_tlist:
1125                 sciErr = createTListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1126                 break;
1127             case sci_mlist:
1128                 sciErr = createMListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1129                 break;
1130             default:
1131                 return false;
1132         }
1133     }
1134
1135     if (sciErr.iErr)
1136     {
1137         printError(&sciErr, 0);
1138         return false;
1139     }
1140
1141     for (i = 0; i < iItems; i++)
1142     {
1143         int iItemDataset = 0;
1144
1145         iRet = getListItemDataset(_iDatasetId, piItemRef, i, &iItemDataset);
1146         if (iRet || iItemDataset == 0)
1147         {
1148             return false;
1149         }
1150
1151         bool bRet = import_data(pvCtx, iItemDataset, i + 1, piListAddr, _pstVarname);
1152
1153         if (bRet == false)
1154         {
1155             return false;
1156         }
1157     }
1158
1159     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1160     if (iRet)
1161     {
1162         return false;
1163     }
1164
1165     return true;
1166 }
1167
1168 static bool import_hypermat(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1169 {
1170     int iRet = 0;
1171     int iComplex = 0;
1172     int iDims = 0;
1173     int iItems = 0;
1174     hobj_ref_t *piItemRef = NULL;
1175
1176     // an hypermatrix is stored in an mlist
1177     if (_iVarType != sci_mlist)
1178     {
1179         return false;
1180     }
1181
1182     iRet = getListDims(_iDatasetId, &iItems);
1183     if (iRet)
1184     {
1185         return false;
1186     }
1187
1188     if (iItems != 3)
1189     {
1190         // hypermatrix have 3 elements
1191         return false;
1192     }
1193
1194     iRet = getListItemReferences(_iDatasetId, &piItemRef);
1195     if (iRet)
1196     {
1197         deleteListItemReferences(_iDatasetId, piItemRef);
1198         return false;
1199     }
1200
1201     // get first item
1202     int iItemDataset = 0;
1203     iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
1204     if (iRet || iItemDataset == 0)
1205     {
1206         deleteListItemReferences(_iDatasetId, piItemRef);
1207         return false;
1208     }
1209
1210     // get first item type
1211     int iItemType = getScilabTypeFromDataSet(iItemDataset);
1212     if (iItemType != sci_strings)
1213     {
1214         deleteListItemReferences(_iDatasetId, piItemRef);
1215         return false;
1216     }
1217
1218     // get size of first item
1219     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1220     if (iRet < 0 || iDims != 2)
1221     {
1222         deleteListItemReferences(_iDatasetId, piItemRef);
1223         return false;
1224     }
1225
1226     int* piDims = new int[2];
1227     int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1228     if (iSize != 3)
1229     {
1230         deleteListItemReferences(_iDatasetId, piItemRef);
1231         delete[] piDims;
1232         return false;
1233     }
1234
1235     delete[] piDims;
1236     piDims = NULL;
1237
1238     // get data of first item for check the type of mlist
1239     char** pstData = new char*[iSize];
1240     iRet = readStringMatrix(iItemDataset, pstData);
1241     if (iRet || strcmp(pstData[0], "hm") != 0)
1242     {
1243         // if not the good type, do not h5close (deleteListItemReferences)
1244         FREE(piItemRef);
1245         freeStringMatrix(iItemDataset, pstData);
1246         delete[] pstData;
1247         return false;
1248     }
1249
1250     freeStringMatrix(iItemDataset, pstData);
1251     delete[] pstData;
1252     pstData = NULL;
1253
1254     // get second item, the Size of hypermatrix
1255     iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
1256     if (iRet)
1257     {
1258         deleteListItemReferences(_iDatasetId, piItemRef);
1259         return false;
1260     }
1261
1262     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1263     if (iRet < 0 || iDims != 2)
1264     {
1265         deleteListItemReferences(_iDatasetId, piItemRef);
1266         return false;
1267     }
1268
1269     piDims = new int[2];
1270     iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1271     if (piDims[0] != 1)
1272     {
1273         deleteListItemReferences(_iDatasetId, piItemRef);
1274         delete[] piDims;
1275         return false;
1276     }
1277
1278     int* piDimsArray = new int[piDims[1]];
1279     iRet = readInteger32Matrix(iItemDataset, piDimsArray);
1280     if (iRet)
1281     {
1282         deleteListItemReferences(_iDatasetId, piItemRef);
1283         delete[] piDims;
1284         delete[] piDimsArray;
1285         return false;
1286     }
1287
1288     // get third item, the Data of hypermatrix
1289     // import data like a "type" (Double, Int, ...) instead of mlist
1290     iRet = getListItemDataset(_iDatasetId, piItemRef, 2, &iItemDataset);
1291     bool bRet = import_data(pvCtx, iItemDataset, _iItemPos, _piAddress, _pstVarname);
1292     if (bRet == false)
1293     {
1294         deleteListItemReferences(_iDatasetId, piItemRef);
1295         delete[] piDims;
1296         delete[] piDimsArray;
1297         return false;
1298     }
1299
1300     // get imported hypermatrix from List or Context
1301     types::GenericType* pGT = NULL;
1302     types::InternalType* pIT = NULL;
1303     if (_piAddress)
1304     {
1305         types::List* pL = (types::List*)_piAddress;
1306         pIT = pL->get(_iItemPos - 1);
1307     }
1308     else
1309     {
1310         wchar_t* pwcsName = to_wide_string(_pstVarname);
1311         pIT = symbol::Context::getInstance()->getCurrentLevel(symbol::Symbol(pwcsName));
1312         FREE(pwcsName);
1313     }
1314
1315     // reshape data with size of hypermatrix
1316     pGT = pIT->getAs<types::GenericType>();
1317     pGT->reshape(piDimsArray, piDims[1]);
1318
1319     delete[] piDims;
1320     delete[] piDimsArray;
1321
1322
1323     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1324     if (iRet)
1325     {
1326         return false;
1327     }
1328
1329     return true;
1330 }
1331 /*--------------------------------------------------------------------------*/
1332
1333 static bool import_struct(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1334 {
1335     int iRet = 0;
1336     int iComplex = 0;
1337     int iDims = 0;
1338     int iItems = 0;
1339     hobj_ref_t *piItemRef = NULL;
1340
1341     // an struct is stored in an mlist
1342     if (_iVarType != sci_mlist)
1343     {
1344         return false;
1345     }
1346
1347     iRet = getListDims(_iDatasetId, &iItems);
1348     if (iRet)
1349     {
1350         return false;
1351     }
1352
1353     if (iItems < 2)
1354     {
1355         // struct have 2 elements minimal
1356         return false;
1357     }
1358
1359     iRet = getListItemReferences(_iDatasetId, &piItemRef);
1360     if (iRet)
1361     {
1362         deleteListItemReferences(_iDatasetId, piItemRef);
1363         return false;
1364     }
1365
1366     // get first item
1367     int iItemDataset = 0;
1368     iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
1369     if (iRet || iItemDataset == 0)
1370     {
1371         deleteListItemReferences(_iDatasetId, piItemRef);
1372         return false;
1373     }
1374
1375     // get first item type
1376     int iItemType = getScilabTypeFromDataSet(iItemDataset);
1377     if (iItemType != sci_strings)
1378     {
1379         deleteListItemReferences(_iDatasetId, piItemRef);
1380         return false;
1381     }
1382
1383     // get size of first item
1384     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1385     if (iRet < 0 || iDims != 2)
1386     {
1387         deleteListItemReferences(_iDatasetId, piItemRef);
1388         return false;
1389     }
1390
1391     int* piDims = new int[2];
1392     int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1393     if (iSize != iItems)
1394     {
1395         deleteListItemReferences(_iDatasetId, piItemRef);
1396         delete[] piDims;
1397         return false;
1398     }
1399
1400     delete[] piDims;
1401     piDims = NULL;
1402
1403     // get data of first item for check the type of mlist
1404     char** pstData = new char*[iSize];
1405     char** pstDataSave = new char*[iSize - 2];
1406     iRet = readStringMatrix(iItemDataset, pstData);
1407     if (iRet || strcmp(pstData[0], "st") != 0)
1408     {
1409         // if not the good type, do not h5close (deleteListItemReferences)
1410         FREE(piItemRef);
1411         freeStringMatrix(iItemDataset, pstData);
1412         delete[] pstData;
1413         delete[] pstDataSave;
1414         return false;
1415     }
1416
1417     for (int i = 2; i < iSize; ++i)
1418     {
1419         pstDataSave[-2 + i] = new char[strlen(pstData[i]) + 1];
1420         strcpy(pstDataSave[-2 + i], pstData[i]);
1421     }
1422
1423     freeStringMatrix(iItemDataset, pstData);
1424     delete[] pstData;
1425     pstData = NULL;
1426
1427     // get second item, the Size of struct
1428     iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
1429     if (iRet)
1430     {
1431         deleteListItemReferences(_iDatasetId, piItemRef);
1432         for (int i = 0; i < (-2 + iItems); ++i)
1433         {
1434             delete pstDataSave[i];
1435         }
1436         delete[] pstDataSave;
1437         pstDataSave = NULL;
1438         return false;
1439     }
1440
1441     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1442     if (iRet < 0 || iDims != 2)
1443     {
1444         deleteListItemReferences(_iDatasetId, piItemRef);
1445         for (int i = 0; i < (-2 + iItems); ++i)
1446         {
1447             delete pstDataSave[i];
1448         }
1449         delete[] pstDataSave;
1450         pstDataSave = NULL;
1451         return false;
1452     }
1453
1454     piDims = new int[2];
1455     iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1456     if (piDims[0] != 1)
1457     {
1458         deleteListItemReferences(_iDatasetId, piItemRef);
1459         for (int i = 0; i < (-2 + iItems); ++i)
1460         {
1461             delete pstDataSave[i];
1462         }
1463         delete[] pstDataSave;
1464         pstDataSave = NULL;
1465         delete[] piDims;
1466         return false;
1467     }
1468
1469     int* piDimsArray = new int[piDims[1]];
1470     iRet = readInteger32Matrix(iItemDataset, piDimsArray);
1471     if (iRet)
1472     {
1473         deleteListItemReferences(_iDatasetId, piItemRef);
1474         for (int i = 0; i < (-2 + iItems); ++i)
1475         {
1476             delete pstDataSave[i];
1477         }
1478         delete[] pstDataSave;
1479         pstDataSave = NULL;
1480         delete[] piDims;
1481         delete[] piDimsArray;
1482         return false;
1483     }
1484
1485     types::Struct* pStruct = new types::Struct(piDims[1], piDimsArray);
1486
1487     wchar_t* pwstName = NULL;
1488     for (int i = 0; i < (-2 + iItems); ++i)
1489     {
1490         pwstName = to_wide_string(pstDataSave[i]);
1491         pStruct->addField(pwstName);
1492         delete pstDataSave[i];
1493         FREE(pwstName);
1494     }
1495
1496     delete[] pstDataSave;
1497     pstDataSave = NULL;
1498
1499     types::SingleStruct** ppSStruct =  pStruct->get();
1500     types::String* pStr = pStruct->getFieldNames();
1501
1502     types::List* pList = new types::List();
1503     // fill the list to avoid api_scilab error about the list size.
1504     pList->set(0, types::Double::Empty());
1505
1506     if (pStruct->getSize() == 1)
1507     {
1508         types::InternalType* pIT = NULL;
1509         for (int i = 0; i < pStr->getSize(); ++i)
1510         {
1511             int iItemDataset = 0;
1512             iRet = getListItemDataset(_iDatasetId, piItemRef, i + 2, &iItemDataset);
1513             if (iRet || iItemDataset == 0)
1514             {
1515                 deleteListItemReferences(_iDatasetId, piItemRef);
1516                 delete pList;
1517                 delete pStruct;
1518                 return false;
1519             }
1520
1521             wchar_t* pwcsName = pStr->get(i);
1522             char* pcName = wide_string_to_UTF8(pwcsName);
1523
1524             bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, pcName);
1525             if (bRet == false)
1526             {
1527                 deleteListItemReferences(_iDatasetId, piItemRef);
1528                 delete pList;
1529                 delete pStruct;
1530                 return false;
1531             }
1532
1533             pIT = pList->get(0);
1534             ppSStruct[0]->set(pwcsName, pIT);
1535             FREE(pcName);
1536         }
1537     }
1538     else if (pStruct->getSize() > 1)
1539     {
1540         for (int i = 0; i < pStr->getSize(); ++i)
1541         {
1542             int iItemDataset = 0;
1543             iRet = getListItemDataset(_iDatasetId, piItemRef, i + 2, &iItemDataset);
1544             if (iRet || iItemDataset == 0)
1545             {
1546                 deleteListItemReferences(_iDatasetId, piItemRef);
1547                 delete pList;
1548                 delete pStruct;
1549                 return false;
1550             }
1551
1552             wchar_t* pwcsName = pStr->get(i);
1553             char* pcName = wide_string_to_UTF8(pwcsName);
1554
1555             bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, pcName);
1556             if (bRet == false)
1557             {
1558                 deleteListItemReferences(_iDatasetId, piItemRef);
1559                 delete pList;
1560                 delete pStruct;
1561                 return false;
1562             }
1563
1564             types::List* pListData = pList->get(0)->getAs<types::List>();
1565             for (int iWriteData = 0; iWriteData < pStruct->getSize(); ++iWriteData)
1566             {
1567                 ppSStruct[iWriteData]->set(pwcsName, pListData->get(iWriteData));
1568             }
1569
1570             FREE(pcName);
1571         }
1572
1573     }
1574
1575     delete pList;
1576     if (_piAddress == NULL)
1577     {
1578         pwstName = to_wide_string(_pstVarname);
1579         symbol::Context::getInstance()->put(symbol::Symbol(pwstName), pStruct);
1580         FREE(pwstName);
1581     }
1582     else
1583     {
1584         types::List* pParentList = (types::List*)_piAddress;
1585         pParentList->set(_iItemPos - 1, pStruct);
1586     }
1587
1588     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1589     if (iRet)
1590     {
1591         return false;
1592     }
1593
1594     return true;
1595 }
1596 /*--------------------------------------------------------------------------*/
1597
1598
1599 static bool import_cell(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1600 {
1601     int iRet = 0;
1602     int iComplex = 0;
1603     int iDims = 0;
1604     int iItems = 0;
1605     hobj_ref_t *piItemRef = NULL;
1606
1607     // an hypermatrix is stored in an mlist
1608     if (_iVarType != sci_mlist)
1609     {
1610         return false;
1611     }
1612
1613     iRet = getListDims(_iDatasetId, &iItems);
1614     if (iRet)
1615     {
1616         return false;
1617     }
1618
1619     if (iItems != 3)
1620     {
1621         // cell have 3 elements
1622         return false;
1623     }
1624
1625     iRet = getListItemReferences(_iDatasetId, &piItemRef);
1626     if (iRet)
1627     {
1628         deleteListItemReferences(_iDatasetId, piItemRef);
1629         return false;
1630     }
1631
1632     // get first item
1633     int iItemDataset = 0;
1634     iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
1635     if (iRet || iItemDataset == 0)
1636     {
1637         deleteListItemReferences(_iDatasetId, piItemRef);
1638         return false;
1639     }
1640
1641     // get first item type
1642     int iItemType = getScilabTypeFromDataSet(iItemDataset);
1643     if (iItemType != sci_strings)
1644     {
1645         deleteListItemReferences(_iDatasetId, piItemRef);
1646         return false;
1647     }
1648
1649     // get size of first item
1650     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1651     if (iRet < 0 || iDims != 2)
1652     {
1653         deleteListItemReferences(_iDatasetId, piItemRef);
1654         return false;
1655     }
1656
1657     int* piDims = new int[2];
1658     int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1659     if (iSize != 3)
1660     {
1661         deleteListItemReferences(_iDatasetId, piItemRef);
1662         delete[] piDims;
1663         return false;
1664     }
1665
1666     delete[] piDims;
1667     piDims = NULL;
1668
1669     // get data of first item for check the type of mlist
1670     char** pstData = new char*[iSize];
1671     iRet = readStringMatrix(iItemDataset, pstData);
1672     if (iRet || strcmp(pstData[0], "ce") != 0)
1673     {
1674         // if not the good type, do not h5close (deleteListItemReferences)
1675         FREE(piItemRef);
1676         freeStringMatrix(iItemDataset, pstData);
1677         delete[] pstData;
1678         return false;
1679     }
1680
1681     freeStringMatrix(iItemDataset, pstData);
1682     delete[] pstData;
1683     pstData = NULL;
1684
1685     // get second item, the Size of cell
1686     iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
1687     if (iRet)
1688     {
1689         deleteListItemReferences(_iDatasetId, piItemRef);
1690         return false;
1691     }
1692
1693     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1694     if (iRet < 0 || iDims != 2)
1695     {
1696         deleteListItemReferences(_iDatasetId, piItemRef);
1697         return false;
1698     }
1699
1700     piDims = new int[2];
1701     iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1702     if (piDims[0] != 1)
1703     {
1704         deleteListItemReferences(_iDatasetId, piItemRef);
1705         delete[] piDims;
1706         return false;
1707     }
1708
1709     int* piDimsArray = new int[piDims[1]];
1710     iRet = readInteger32Matrix(iItemDataset, piDimsArray);
1711     if (iRet)
1712     {
1713         deleteListItemReferences(_iDatasetId, piItemRef);
1714         delete[] piDims;
1715         delete[] piDimsArray;
1716         return false;
1717     }
1718
1719     types::Cell* pCell = new types::Cell(piDims[1], piDimsArray);
1720     types::List* pList = new types::List();
1721     pList->set(0, types::Double::Empty());
1722
1723     iRet = getListItemDataset(_iDatasetId, piItemRef, 2, &iItemDataset);
1724     if (iRet || iItemDataset == 0)
1725     {
1726         deleteListItemReferences(_iDatasetId, piItemRef);
1727         delete pList;
1728         delete pCell;
1729         return false;
1730     }
1731
1732     bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, NULL);
1733     if (bRet == false)
1734     {
1735         deleteListItemReferences(_iDatasetId, piItemRef);
1736         delete pList;
1737         delete pCell;
1738         return false;
1739     }
1740
1741     types::List* pListData = pList->get(0)->getAs<types::List>();
1742     for (int iWriteData = 0; iWriteData < pCell->getSize(); ++iWriteData)
1743     {
1744         pCell->set(iWriteData, pListData->get(iWriteData));
1745     }
1746
1747     delete pList;
1748
1749     if (_piAddress == NULL)
1750     {
1751         wchar_t* pwstName = to_wide_string(_pstVarname);
1752         symbol::Context::getInstance()->put(symbol::Symbol(pwstName), pCell);
1753         FREE(pwstName);
1754     }
1755     else
1756     {
1757         types::List* pParentList = (types::List*)_piAddress;
1758         pParentList->set(_iItemPos - 1, pCell);
1759     }
1760
1761     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1762
1763     if (iRet)
1764     {
1765         return false;
1766     }
1767
1768     return true;
1769 }
1770 /*--------------------------------------------------------------------------*/
1771