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             FREE(piDims);
 753             return false;
 754     }
 755
 756     FREE(piDims);
 757
 758     if (sciErr.iErr)
 759     {
 760         printError(&sciErr, 0);
 761         return false;
 762     }
 763
 764     return true;
 765 }
 766
 767 static bool import_boolean(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 768 {
 769     int iRet = 0;
 770     int *piData = NULL;
 771     int iDims = 0;
 772     int* piDims = NULL;
 773     int iComplex = 0;
 774     int iSize = 0;
 775     SciErr sciErr;
 776
 777     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
 778     if (iRet < 0)
 779     {
 780         return false;
 781     }
 782
 783     piDims = (int*)MALLOC(sizeof(int) * iDims);
 784     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
 785
 786     if (iSize == 0)
 787     {
 788         FREE(piDims);
 789         return false;
 790     }
 791
 792     piData = (int *)MALLOC(iSize * sizeof(int));
 793     iRet = readBooleanMatrix(_iDatasetId, piData);
 794     if (iRet)
 795     {
 796         FREE(piData);
 797         FREE(piDims);
 798         return false;
 799     }
 800
 801     if (_piAddress == NULL)
 802     {
 803         sciErr = createNamedMatrixOfBoolean(pvCtx, _pstVarname, piDims[0], piDims[1], piData);
 804     }
 805     else                        //if not null this variable is in a list
 806     {
 807         sciErr = createMatrixOfBooleanInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData);
 808     }
 809
 810     FREE(piDims);
 811     if (piData)
 812     {
 813         FREE(piData);
 814     }
 815
 816     if (sciErr.iErr)
 817     {
 818         printError(&sciErr, 0);
 819         return false;
 820     }
 821
 822     return true;
 823 }
 824
 825 static bool import_poly(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 826 {
 827     int iRet = 0;
 828     int iComplex = 0;
 829     char pstVarName[64] = { 0 };
 830     double **pdblReal = NULL;
 831     double **pdblImg = NULL;
 832     int *piNbCoef = NULL;
 833     int iDims = 0;
 834     int* piDims = NULL;
 835     int iSize = 0;
 836     SciErr sciErr;
 837
 838     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
 839     if (iRet < 0)
 840     {
 841         return false;
 842     }
 843
 844     piDims = (int*)MALLOC(sizeof(int) * iDims);
 845     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
 846
 847     if (iComplex)
 848     {
 849         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
 850         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
 851         pdblImg = (double **)MALLOC(iSize * sizeof(double *));
 852         iRet = readPolyComplexMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal, pdblImg);
 853     }
 854     else
 855     {
 856         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
 857         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
 858         iRet = readPolyMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal);
 859     }
 860
 861     if (iRet)
 862     {
 863         FREE(piDims);
 864         FREE(piNbCoef);
 865         for (int i = 0; i < iSize; i++)
 866         {
 867             FREE(pdblReal[i]);
 868         }
 869         FREE(pdblReal);
 870
 871         if (iComplex)
 872         {
 873             for (int i = 0; i < iSize; i++)
 874             {
 875                 FREE(pdblImg[i]);
 876             }
 877             FREE(pdblImg);
 878         }
 879
 880         return false;
 881     }
 882
 883     if (_piAddress == NULL)
 884     {
 885         if (iComplex)
 886         {
 887             sciErr = createNamedComplexMatrixOfPoly(pvCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal, pdblImg);
 888         }
 889         else
 890         {
 891             sciErr = createNamedMatrixOfPoly(pvCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
 892         }
 893     }
 894     else                        //if not null this variable is in a list
 895     {
 896         if (iComplex)
 897         {
 898             sciErr =
 899                 createComplexMatrixOfPolyInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal,
 900                         pdblImg);
 901         }
 902         else
 903         {
 904             sciErr = createMatrixOfPolyInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
 905         }
 906     }
 907
 908     FREE(piDims);
 909     FREE(piNbCoef);
 910     for (int i = 0; i < iSize; i++)
 911     {
 912         FREE(pdblReal[i]);
 913     }
 914
 915     FREE(pdblReal);
 916
 917     if (iComplex)
 918     {
 919         for (int i = 0; i < iSize; i++)
 920         {
 921             FREE(pdblImg[i]);
 922         }
 923
 924         FREE(pdblImg);
 925     }
 926
 927     if (sciErr.iErr)
 928     {
 929         printError(&sciErr, 0);
 930         return false;
 931     }
 932
 933     return true;
 934 }
 935
 936 static bool import_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 937 {
 938     int iRet = 0;
 939     int iRows = 0;
 940     int iCols = 0;
 941     int iComplex = 0;
 942     double *pdblReal = NULL;
 943     double *pdblImg = NULL;
 944     int iNbItem = 0;
 945     int *piNbItemRow = NULL;
 946     int *piColPos = NULL;
 947     SciErr sciErr;
 948
 949     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
 950     if (iRet)
 951     {
 952         return false;
 953     }
 954
 955     iComplex = isComplexData(_iDatasetId);
 956
 957     if (iComplex)
 958     {
 959         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
 960         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
 961         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
 962         pdblImg = (double *)MALLOC(iNbItem * sizeof(double));
 963         iRet = readSparseComplexMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
 964     }
 965     else
 966     {
 967         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
 968         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
 969         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
 970         iRet = readSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
 971     }
 972
 973     if (iRet)
 974     {
 975         FREE(piNbItemRow);
 976         FREE(piColPos);
 977         FREE(pdblReal);
 978         if (iComplex)
 979         {
 980             FREE(pdblImg);
 981         }
 982
 983         return false;
 984     }
 985
 986     if (_piAddress == NULL)
 987     {
 988         if (iComplex)
 989         {
 990             sciErr = createNamedComplexSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
 991         }
 992         else
 993         {
 994             sciErr = createNamedSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
 995         }
 996     }
 997     else //if not null this variable is in a list
 998     {
 999         if (iComplex)
1000         {
1001             sciErr = createComplexSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
1002         }
1003         else
1004         {
1005             sciErr = createSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
1006         }
1007     }
1008
1009     FREE(piNbItemRow);
1010     FREE(piColPos);
1011     FREE(pdblReal);
1012     if (iComplex)
1013     {
1014         FREE(pdblImg);
1015     }
1016
1017     if (sciErr.iErr)
1018     {
1019         printError(&sciErr, 0);
1020         return false;
1021     }
1022
1023     return true;
1024 }
1025
1026 static bool import_boolean_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
1027 {
1028     int iRet = 0;
1029     int iRows = 0;
1030     int iCols = 0;
1031     int iNbItem = 0;
1032     int *piNbItemRow = NULL;
1033     int *piColPos = NULL;
1034     SciErr sciErr;
1035
1036     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
1037     if (iRet)
1038     {
1039         return false;
1040     }
1041
1042     piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
1043     piColPos = (int *)MALLOC(iNbItem * sizeof(int));
1044
1045     iRet = readBooleanSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1046     if (iRet)
1047     {
1048         FREE(piNbItemRow);
1049         return false;
1050     }
1051
1052     if (_piAddress == NULL)
1053     {
1054         sciErr = createNamedBooleanSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1055     }
1056     else                        //if not null this variable is in a list
1057     {
1058         sciErr = createBooleanSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1059     }
1060
1061     FREE(piNbItemRow);
1062     FREE(piColPos);
1063
1064     if (sciErr.iErr)
1065     {
1066         printError(&sciErr, 0);
1067         return false;
1068     }
1069
1070     return true;
1071 }
1072
1073 static bool import_list(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1074 {
1075     int iRet = 0;
1076     int i = 0;
1077     int iItems = 0;
1078     int *piListAddr = NULL;
1079     hobj_ref_t *piItemRef = NULL;
1080     SciErr sciErr;
1081
1082     iRet = getListDims(_iDatasetId, &iItems);
1083     if (iRet)
1084     {
1085         return false;
1086     }
1087
1088     if (iItems == 0)
1089     {
1090         //special case for empty list
1091     }
1092     else
1093     {
1094         iRet = getListItemReferences(_iDatasetId, &piItemRef);
1095         if (iRet)
1096         {
1097             return false;
1098         }
1099     }
1100
1101     if (_piAddress == 0)
1102     {
1103         switch (_iVarType)
1104         {
1105             case sci_list:
1106                 sciErr = createNamedList(pvCtx, _pstVarname, iItems, &piListAddr);
1107                 break;
1108             case sci_tlist:
1109                 sciErr = createNamedTList(pvCtx, _pstVarname, iItems, &piListAddr);
1110                 break;
1111             case sci_mlist:
1112                 sciErr = createNamedMList(pvCtx, _pstVarname, iItems, &piListAddr);
1113                 break;
1114             default:
1115                 return false;
1116         }
1117     }
1118     else                        //if not null this variable is in a list
1119     {
1120         switch (_iVarType)
1121         {
1122             case sci_list:
1123                 sciErr = createListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1124                 break;
1125             case sci_tlist:
1126                 sciErr = createTListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1127                 break;
1128             case sci_mlist:
1129                 sciErr = createMListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1130                 break;
1131             default:
1132                 return false;
1133         }
1134     }
1135
1136     if (sciErr.iErr)
1137     {
1138         printError(&sciErr, 0);
1139         return false;
1140     }
1141
1142     for (i = 0; i < iItems; i++)
1143     {
1144         int iItemDataset = 0;
1145
1146         iRet = getListItemDataset(_iDatasetId, piItemRef, i, &iItemDataset);
1147         if (iRet || iItemDataset == 0)
1148         {
1149             return false;
1150         }
1151
1152         bool bRet = import_data(pvCtx, iItemDataset, i + 1, piListAddr, _pstVarname);
1153
1154         if (bRet == false)
1155         {
1156             return false;
1157         }
1158     }
1159
1160     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1161     if (iRet)
1162     {
1163         return false;
1164     }
1165
1166     return true;
1167 }
1168
1169 static bool import_hypermat(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1170 {
1171     int iRet = 0;
1172     int iComplex = 0;
1173     int iDims = 0;
1174     int iItems = 0;
1175     hobj_ref_t *piItemRef = NULL;
1176
1177     // an hypermatrix is stored in an mlist
1178     if (_iVarType != sci_mlist)
1179     {
1180         return false;
1181     }
1182
1183     iRet = getListDims(_iDatasetId, &iItems);
1184     if (iRet)
1185     {
1186         return false;
1187     }
1188
1189     if (iItems != 3)
1190     {
1191         // hypermatrix have 3 elements
1192         return false;
1193     }
1194
1195     iRet = getListItemReferences(_iDatasetId, &piItemRef);
1196     if (iRet)
1197     {
1198         deleteListItemReferences(_iDatasetId, piItemRef);
1199         return false;
1200     }
1201
1202     // get first item
1203     int iItemDataset = 0;
1204     iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
1205     if (iRet || iItemDataset == 0)
1206     {
1207         deleteListItemReferences(_iDatasetId, piItemRef);
1208         return false;
1209     }
1210
1211     // get first item type
1212     int iItemType = getScilabTypeFromDataSet(iItemDataset);
1213     if (iItemType != sci_strings)
1214     {
1215         deleteListItemReferences(_iDatasetId, piItemRef);
1216         return false;
1217     }
1218
1219     // get size of first item
1220     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1221     if (iRet < 0 || iDims != 2)
1222     {
1223         deleteListItemReferences(_iDatasetId, piItemRef);
1224         return false;
1225     }
1226
1227     int* piDims = new int[2];
1228     int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1229     if (iSize != 3)
1230     {
1231         deleteListItemReferences(_iDatasetId, piItemRef);
1232         delete[] piDims;
1233         return false;
1234     }
1235
1236     delete[] piDims;
1237     piDims = NULL;
1238
1239     // get data of first item for check the type of mlist
1240     char** pstData = new char*[iSize];
1241     iRet = readStringMatrix(iItemDataset, pstData);
1242     if (iRet || strcmp(pstData[0], "hm") != 0)
1243     {
1244         // if not the good type, do not h5close (deleteListItemReferences)
1245         FREE(piItemRef);
1246         freeStringMatrix(iItemDataset, pstData);
1247         delete[] pstData;
1248         return false;
1249     }
1250
1251     freeStringMatrix(iItemDataset, pstData);
1252     delete[] pstData;
1253     pstData = NULL;
1254
1255     // get second item, the Size of hypermatrix
1256     iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
1257     if (iRet)
1258     {
1259         deleteListItemReferences(_iDatasetId, piItemRef);
1260         return false;
1261     }
1262
1263     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1264     if (iRet < 0 || iDims != 2)
1265     {
1266         deleteListItemReferences(_iDatasetId, piItemRef);
1267         return false;
1268     }
1269
1270     piDims = new int[2];
1271     iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1272     if (piDims[0] != 1)
1273     {
1274         deleteListItemReferences(_iDatasetId, piItemRef);
1275         delete[] piDims;
1276         return false;
1277     }
1278
1279     int* piDimsArray = new int[piDims[1]];
1280     iRet = readInteger32Matrix(iItemDataset, piDimsArray);
1281     if (iRet)
1282     {
1283         deleteListItemReferences(_iDatasetId, piItemRef);
1284         delete[] piDims;
1285         delete[] piDimsArray;
1286         return false;
1287     }
1288
1289     // get third item, the Data of hypermatrix
1290     // import data like a "type" (Double, Int, ...) instead of mlist
1291     iRet = getListItemDataset(_iDatasetId, piItemRef, 2, &iItemDataset);
1292     bool bRet = import_data(pvCtx, iItemDataset, _iItemPos, _piAddress, _pstVarname);
1293     if (bRet == false)
1294     {
1295         deleteListItemReferences(_iDatasetId, piItemRef);
1296         delete[] piDims;
1297         delete[] piDimsArray;
1298         return false;
1299     }
1300
1301     // get imported hypermatrix from List or Context
1302     types::GenericType* pGT = NULL;
1303     types::InternalType* pIT = NULL;
1304     if (_piAddress)
1305     {
1306         types::List* pL = (types::List*)_piAddress;
1307         pIT = pL->get(_iItemPos - 1);
1308     }
1309     else
1310     {
1311         wchar_t* pwcsName = to_wide_string(_pstVarname);
1312         pIT = symbol::Context::getInstance()->getCurrentLevel(symbol::Symbol(pwcsName));
1313         FREE(pwcsName);
1314     }
1315
1316     // reshape data with size of hypermatrix
1317     pGT = pIT->getAs<types::GenericType>();
1318     pGT->reshape(piDimsArray, piDims[1]);
1319
1320     delete[] piDims;
1321     delete[] piDimsArray;
1322
1323
1324     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1325     if (iRet)
1326     {
1327         return false;
1328     }
1329
1330     return true;
1331 }
1332 /*--------------------------------------------------------------------------*/
1333
1334 static bool import_struct(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1335 {
1336     int iRet = 0;
1337     int iComplex = 0;
1338     int iDims = 0;
1339     int iItems = 0;
1340     hobj_ref_t *piItemRef = NULL;
1341
1342     // an struct is stored in an mlist
1343     if (_iVarType != sci_mlist)
1344     {
1345         return false;
1346     }
1347
1348     iRet = getListDims(_iDatasetId, &iItems);
1349     if (iRet)
1350     {
1351         return false;
1352     }
1353
1354     if (iItems < 2)
1355     {
1356         // struct have 2 elements minimal
1357         return false;
1358     }
1359
1360     iRet = getListItemReferences(_iDatasetId, &piItemRef);
1361     if (iRet)
1362     {
1363         deleteListItemReferences(_iDatasetId, piItemRef);
1364         return false;
1365     }
1366
1367     // get first item
1368     int iItemDataset = 0;
1369     iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
1370     if (iRet || iItemDataset == 0)
1371     {
1372         deleteListItemReferences(_iDatasetId, piItemRef);
1373         return false;
1374     }
1375
1376     // get first item type
1377     int iItemType = getScilabTypeFromDataSet(iItemDataset);
1378     if (iItemType != sci_strings)
1379     {
1380         deleteListItemReferences(_iDatasetId, piItemRef);
1381         return false;
1382     }
1383
1384     // get size of first item
1385     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1386     if (iRet < 0 || iDims != 2)
1387     {
1388         deleteListItemReferences(_iDatasetId, piItemRef);
1389         return false;
1390     }
1391
1392     int* piDims = new int[2];
1393     int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1394     if (iSize != iItems)
1395     {
1396         deleteListItemReferences(_iDatasetId, piItemRef);
1397         delete[] piDims;
1398         return false;
1399     }
1400
1401     delete[] piDims;
1402     piDims = NULL;
1403
1404     // get data of first item for check the type of mlist
1405     char** pstData = new char*[iSize];
1406     char** pstDataSave = new char*[iSize - 2];
1407     iRet = readStringMatrix(iItemDataset, pstData);
1408     if (iRet || strcmp(pstData[0], "st") != 0)
1409     {
1410         // if not the good type, do not h5close (deleteListItemReferences)
1411         FREE(piItemRef);
1412         freeStringMatrix(iItemDataset, pstData);
1413         delete[] pstData;
1414         delete[] pstDataSave;
1415         return false;
1416     }
1417
1418     for (int i = 2; i < iSize; ++i)
1419     {
1420         pstDataSave[-2 + i] = new char[strlen(pstData[i]) + 1];
1421         strcpy(pstDataSave[-2 + i], pstData[i]);
1422     }
1423
1424     freeStringMatrix(iItemDataset, pstData);
1425     delete[] pstData;
1426     pstData = NULL;
1427
1428     // get second item, the Size of struct
1429     iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
1430     if (iRet)
1431     {
1432         deleteListItemReferences(_iDatasetId, piItemRef);
1433         for (int i = 0; i < (-2 + iItems); ++i)
1434         {
1435             delete pstDataSave[i];
1436         }
1437         delete[] pstDataSave;
1438         pstDataSave = NULL;
1439         return false;
1440     }
1441
1442     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1443     if (iRet < 0 || iDims != 2)
1444     {
1445         deleteListItemReferences(_iDatasetId, piItemRef);
1446         for (int i = 0; i < (-2 + iItems); ++i)
1447         {
1448             delete pstDataSave[i];
1449         }
1450         delete[] pstDataSave;
1451         pstDataSave = NULL;
1452         return false;
1453     }
1454
1455     piDims = new int[2];
1456     iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1457     if (piDims[0] != 1)
1458     {
1459         deleteListItemReferences(_iDatasetId, piItemRef);
1460         for (int i = 0; i < (-2 + iItems); ++i)
1461         {
1462             delete pstDataSave[i];
1463         }
1464         delete[] pstDataSave;
1465         pstDataSave = NULL;
1466         delete[] piDims;
1467         return false;
1468     }
1469
1470     int* piDimsArray = new int[piDims[1]];
1471     iRet = readInteger32Matrix(iItemDataset, piDimsArray);
1472     if (iRet)
1473     {
1474         deleteListItemReferences(_iDatasetId, piItemRef);
1475         for (int i = 0; i < (-2 + iItems); ++i)
1476         {
1477             delete pstDataSave[i];
1478         }
1479         delete[] pstDataSave;
1480         pstDataSave = NULL;
1481         delete[] piDims;
1482         delete[] piDimsArray;
1483         return false;
1484     }
1485
1486     types::Struct* pStruct = new types::Struct(piDims[1], piDimsArray);
1487     delete[] piDims;
1488     delete[] piDimsArray;
1489
1490     wchar_t* pwstName = NULL;
1491     for (int i = 0; i < (-2 + iItems); ++i)
1492     {
1493         pwstName = to_wide_string(pstDataSave[i]);
1494         pStruct->addField(pwstName);
1495         delete pstDataSave[i];
1496         FREE(pwstName);
1497     }
1498
1499     delete[] pstDataSave;
1500     pstDataSave = NULL;
1501
1502     types::SingleStruct** ppSStruct =  pStruct->get();
1503     types::String* pStr = pStruct->getFieldNames();
1504
1505     types::List* pList = new types::List();
1506     // fill the list to avoid api_scilab error about the list size.
1507     pList->set(0, types::Double::Empty());
1508
1509     if (pStruct->getSize() == 1)
1510     {
1511         types::InternalType* pIT = NULL;
1512         for (int i = 0; i < pStr->getSize(); ++i)
1513         {
1514             int iItemDataset = 0;
1515             iRet = getListItemDataset(_iDatasetId, piItemRef, i + 2, &iItemDataset);
1516             if (iRet || iItemDataset == 0)
1517             {
1518                 deleteListItemReferences(_iDatasetId, piItemRef);
1519                 delete pList;
1520                 delete pStruct;
1521                 return false;
1522             }
1523
1524             wchar_t* pwcsName = pStr->get(i);
1525             char* pcName = wide_string_to_UTF8(pwcsName);
1526
1527             bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, pcName);
1528             if (bRet == false)
1529             {
1530                 deleteListItemReferences(_iDatasetId, piItemRef);
1531                 delete pList;
1532                 delete pStruct;
1533                 return false;
1534             }
1535
1536             pIT = pList->get(0);
1537             ppSStruct[0]->set(pwcsName, pIT);
1538             FREE(pcName);
1539         }
1540     }
1541     else if (pStruct->getSize() > 1)
1542     {
1543         for (int i = 0; i < pStr->getSize(); ++i)
1544         {
1545             int iItemDataset = 0;
1546             iRet = getListItemDataset(_iDatasetId, piItemRef, i + 2, &iItemDataset);
1547             if (iRet || iItemDataset == 0)
1548             {
1549                 deleteListItemReferences(_iDatasetId, piItemRef);
1550                 delete pList;
1551                 delete pStruct;
1552                 return false;
1553             }
1554
1555             wchar_t* pwcsName = pStr->get(i);
1556             char* pcName = wide_string_to_UTF8(pwcsName);
1557
1558             bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, pcName);
1559             if (bRet == false)
1560             {
1561                 deleteListItemReferences(_iDatasetId, piItemRef);
1562                 delete pList;
1563                 delete pStruct;
1564                 return false;
1565             }
1566
1567             types::List* pListData = pList->get(0)->getAs<types::List>();
1568             for (int iWriteData = 0; iWriteData < pStruct->getSize(); ++iWriteData)
1569             {
1570                 ppSStruct[iWriteData]->set(pwcsName, pListData->get(iWriteData));
1571             }
1572
1573             FREE(pcName);
1574         }
1575
1576     }
1577
1578     delete pList;
1579     if (_piAddress == NULL)
1580     {
1581         pwstName = to_wide_string(_pstVarname);
1582         symbol::Context::getInstance()->put(symbol::Symbol(pwstName), pStruct);
1583         FREE(pwstName);
1584     }
1585     else
1586     {
1587         types::List* pParentList = (types::List*)_piAddress;
1588         pParentList->set(_iItemPos - 1, pStruct);
1589     }
1590
1591     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1592     if (iRet)
1593     {
1594         return false;
1595     }
1596
1597     return true;
1598 }
1599 /*--------------------------------------------------------------------------*/
1600
1601
1602 static bool import_cell(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1603 {
1604     int iRet = 0;
1605     int iComplex = 0;
1606     int iDims = 0;
1607     int iItems = 0;
1608     hobj_ref_t *piItemRef = NULL;
1609
1610     // an hypermatrix is stored in an mlist
1611     if (_iVarType != sci_mlist)
1612     {
1613         return false;
1614     }
1615
1616     iRet = getListDims(_iDatasetId, &iItems);
1617     if (iRet)
1618     {
1619         return false;
1620     }
1621
1622     if (iItems != 3)
1623     {
1624         // cell have 3 elements
1625         return false;
1626     }
1627
1628     iRet = getListItemReferences(_iDatasetId, &piItemRef);
1629     if (iRet)
1630     {
1631         deleteListItemReferences(_iDatasetId, piItemRef);
1632         return false;
1633     }
1634
1635     // get first item
1636     int iItemDataset = 0;
1637     iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
1638     if (iRet || iItemDataset == 0)
1639     {
1640         deleteListItemReferences(_iDatasetId, piItemRef);
1641         return false;
1642     }
1643
1644     // get first item type
1645     int iItemType = getScilabTypeFromDataSet(iItemDataset);
1646     if (iItemType != sci_strings)
1647     {
1648         deleteListItemReferences(_iDatasetId, piItemRef);
1649         return false;
1650     }
1651
1652     // get size of first item
1653     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1654     if (iRet < 0 || iDims != 2)
1655     {
1656         deleteListItemReferences(_iDatasetId, piItemRef);
1657         return false;
1658     }
1659
1660     int* piDims = new int[2];
1661     int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1662     if (iSize != 3)
1663     {
1664         deleteListItemReferences(_iDatasetId, piItemRef);
1665         delete[] piDims;
1666         return false;
1667     }
1668
1669     delete[] piDims;
1670     piDims = NULL;
1671
1672     // get data of first item for check the type of mlist
1673     char** pstData = new char*[iSize];
1674     iRet = readStringMatrix(iItemDataset, pstData);
1675     if (iRet || strcmp(pstData[0], "ce") != 0)
1676     {
1677         // if not the good type, do not h5close (deleteListItemReferences)
1678         FREE(piItemRef);
1679         freeStringMatrix(iItemDataset, pstData);
1680         delete[] pstData;
1681         return false;
1682     }
1683
1684     freeStringMatrix(iItemDataset, pstData);
1685     delete[] pstData;
1686     pstData = NULL;
1687
1688     // get second item, the Size of cell
1689     iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
1690     if (iRet)
1691     {
1692         deleteListItemReferences(_iDatasetId, piItemRef);
1693         return false;
1694     }
1695
1696     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1697     if (iRet < 0 || iDims != 2)
1698     {
1699         deleteListItemReferences(_iDatasetId, piItemRef);
1700         return false;
1701     }
1702
1703     piDims = new int[2];
1704     iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1705     if (piDims[0] != 1)
1706     {
1707         deleteListItemReferences(_iDatasetId, piItemRef);
1708         delete[] piDims;
1709         return false;
1710     }
1711
1712     int* piDimsArray = new int[piDims[1]];
1713     iRet = readInteger32Matrix(iItemDataset, piDimsArray);
1714     if (iRet)
1715     {
1716         deleteListItemReferences(_iDatasetId, piItemRef);
1717         delete[] piDims;
1718         delete[] piDimsArray;
1719         return false;
1720     }
1721
1722     types::Cell* pCell = new types::Cell(piDims[1], piDimsArray);
1723     delete[] piDims;
1724     delete[] piDimsArray;
1725     types::List* pList = new types::List();
1726     pList->set(0, types::Double::Empty());
1727
1728     iRet = getListItemDataset(_iDatasetId, piItemRef, 2, &iItemDataset);
1729     if (iRet || iItemDataset == 0)
1730     {
1731         deleteListItemReferences(_iDatasetId, piItemRef);
1732         delete pList;
1733         delete pCell;
1734         return false;
1735     }
1736
1737     bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, NULL);
1738     if (bRet == false)
1739     {
1740         deleteListItemReferences(_iDatasetId, piItemRef);
1741         delete pList;
1742         delete pCell;
1743         return false;
1744     }
1745
1746     types::List* pListData = pList->get(0)->getAs<types::List>();
1747     for (int iWriteData = 0; iWriteData < pCell->getSize(); ++iWriteData)
1748     {
1749         pCell->set(iWriteData, pListData->get(iWriteData));
1750     }
1751
1752     delete pList;
1753
1754     if (_piAddress == NULL)
1755     {
1756         wchar_t* pwstName = to_wide_string(_pstVarname);
1757         symbol::Context::getInstance()->put(symbol::Symbol(pwstName), pCell);
1758         FREE(pwstName);
1759     }
1760     else
1761     {
1762         types::List* pParentList = (types::List*)_piAddress;
1763         pParentList->set(_iItemPos - 1, pCell);
1764     }
1765
1766     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1767
1768     if (iRet)
1769     {
1770         return false;
1771     }
1772
1773     return true;
1774 }
1775 /*--------------------------------------------------------------------------*/
1776