scilab/modules/hdf5/sci_gateway/cpp/sci_import_from_hdf5.cpp

   1 /*
   2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3 * Copyright (C) 2009 - DIGITEO - Antoine ELIAS
   4 *
   5 * This file must be used under the terms of the CeCILL.
   6 * This source file is licensed as described in the file COPYING, which
   7 * you should have received as part of this distribution.  The terms
   8 * are also available at
   9 * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  10 *
  11 */
  12
  13 extern "C"
  14 {
  15 #include <hdf5.h>
  16 #include <string.h>
  17 #include "gw_hdf5.h"
  18 #include "MALLOC.h"
  19 #include "Scierror.h"
  20 #include "localization.h"
  21 #include "sciprint.h"
  22 #include "api_scilab.h"
  23 #include "../../../call_scilab/includes/call_scilab.h"
  24 #include "h5_fileManagement.h"
  25 #include "h5_readDataFromFile.h"
  26 #include "h5_attributeConstants.h"
  27 #include "intmacr2tree.h"
  28 #include "expandPathVariable.h"
  29 }
  30 #include "forceJHDF5load.hxx"
  31
  32 //#define PRINT_DEBUG
  33 //#define TIME_DEBUG
  34
  35 static int iTab = 0;
  36 static int iCloseList = 0;
  37
  38 void print_tree(char *_pstMsg);
  39
  40 static bool import_variable(int _iFile, char* _pstVarName);
  41 static bool import_data(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  42 static bool import_double(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  43 static bool import_string(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  44 static bool import_boolean(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  45 static bool import_integer(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  46 static bool import_sparse(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  47 static bool import_boolean_sparse(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  48 static bool import_poly(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  49 static bool import_list(int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname);
  50 static bool import_void(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  51 static bool import_undefined(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
  52
  53 int sci_import_from_hdf5(char *fname, unsigned long fname_len)
  54 {
  55     SciErr sciErr;
  56
  57     int* piAddr = NULL;
  58     char* pstFilename = NULL;
  59     char* pstExpandedFilename = NULL;
  60     bool bImport = true;
  61
  62     int iSelectedVar = Rhs - 1;
  63
  64     checkInputArgumentAtLeast(pvApiCtx, 1);
  65     CheckLhs(1, 1);
  66
  67 #ifndef _MSC_VER
  68     forceJHDF5load();
  69 #endif
  70
  71     iCloseList = 0;
  72
  73     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
  74     if (sciErr.iErr)
  75     {
  76         printError(&sciErr, 0);
  77         return 1;
  78     }
  79
  80     if (getAllocatedSingleString(pvApiCtx, piAddr, &pstFilename))
  81     {
  82         Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
  83         return 1;
  84     }
  85
  86     //open hdf5 file
  87     pstExpandedFilename = expandPathVariable(pstFilename);
  88     int iFile = openHDF5File(pstExpandedFilename);
  89     if (iFile < 0)
  90     {
  91         FREE(pstExpandedFilename);
  92         FREE(pstFilename);
  93         Scierror(999, _("%s: Unable to open file: %s\n"), fname, pstFilename);
  94         return 1;
  95     }
  96
  97     FREE(pstExpandedFilename);
  98     FREE(pstFilename);
  99
 100     //manage version information
 101     int iVersion = getSODFormatAttribute(iFile);
 102     if (iVersion > SOD_FILE_VERSION)
 103     {//can't read file with version newer that me !
 104         Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname, SOD_FILE_VERSION, iVersion);
 105         return 1;
 106     }
 107
 108     if (iSelectedVar)
 109     {
 110         //selected variable
 111         char* pstVarName = NULL;
 112         for (int i = 0 ; i < iSelectedVar ; i++)
 113         {
 114             sciErr = getVarAddressFromPosition(pvApiCtx, i + 2, &piAddr);
 115             if (sciErr.iErr)
 116             {
 117                 printError(&sciErr, 0);
 118                 return 1;
 119             }
 120
 121             if (getAllocatedSingleString(pvApiCtx, piAddr, &pstVarName))
 122             {
 123                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, i + 1);
 124                 return 1;
 125             }
 126
 127             if (import_variable(iFile, pstVarName) == false)
 128             {
 129                 bImport = false;
 130                 break;
 131             }
 132
 133             FREE(pstVarName);
 134         }
 135     }
 136     else
 137     {
 138         //all variables
 139         int iNbItem = 0;
 140         iNbItem = getVariableNames(iFile, NULL);
 141         if (iNbItem != 0)
 142         {
 143             char **pstVarNameList = (char **)MALLOC(sizeof(char *) * iNbItem);
 144
 145             iNbItem = getVariableNames(iFile, pstVarNameList);
 146
 147             //import all data
 148             for (int i = 0; i < iNbItem; i++)
 149             {
 150                 if (import_variable(iFile, pstVarNameList[i]) == false)
 151                 {
 152                     bImport = false;
 153                     break;
 154                 }
 155             }
 156         }
 157     }
 158     //close the file
 159     closeHDF5File(iFile);
 160
 161     int *piReturn = NULL;
 162
 163     sciErr = allocMatrixOfBoolean(pvApiCtx, Rhs + 1, 1, 1, &piReturn);
 164     if (sciErr.iErr)
 165     {
 166         printError(&sciErr, 0);
 167         return 1;
 168     }
 169
 170     if (bImport == true)
 171     {
 172         piReturn[0] = 1;
 173     }
 174     else
 175     {
 176         piReturn[0] = 0;
 177     }
 178
 179     LhsVar(1) = Rhs + 1;
 180     PutLhsVar();
 181
 182     //  printf("End gateway !!!\n");
 183     return 0;
 184 }
 185
 186 static bool import_variable(int _iFile, char* _pstVarName)
 187 {
 188     int iDataSetId = getDataSetIdFromName(_iFile, _pstVarName);
 189     if (iDataSetId == 0)
 190     {
 191         return false;
 192     }
 193
 194     return import_data(iDataSetId, 0, NULL, _pstVarName);
 195 }
 196
 197 static bool import_data(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 198 {
 199     bool bRet = false;
 200
 201     //get var type
 202     int iVarType = getScilabTypeFromDataSet(_iDatasetId);
 203
 204     switch (iVarType)
 205     {
 206         case sci_matrix:
 207         {
 208             bRet = import_double(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
 209             break;
 210         }
 211         case sci_strings:
 212         {
 213             bRet = import_string(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
 214             break;
 215         }
 216         case sci_list:
 217         case sci_tlist:
 218         case sci_mlist:
 219         {
 220             bRet = import_list(_iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
 221             break;
 222         }
 223         case sci_boolean:
 224         {
 225             bRet = import_boolean(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
 226             break;
 227         }
 228         case sci_poly:
 229         {
 230             bRet = import_poly(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
 231             break;
 232         }
 233         case sci_ints:
 234         {
 235             bRet = import_integer(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
 236             break;
 237         }
 238         case sci_sparse:
 239         {
 240             bRet = import_sparse(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
 241             break;
 242         }
 243         case sci_boolean_sparse:
 244         {
 245             bRet = import_boolean_sparse(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
 246             break;
 247         }
 248         case sci_void:             //void item only on list variable
 249         {
 250             bRet = import_void(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
 251             break;
 252         }
 253         case sci_undefined:        //undefined item only on list variable
 254         {
 255             bRet = import_undefined(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
 256             break;
 257         }
 258         default:
 259         {
 260             Scierror(999, _("%s: Invalid HDF5 Scilab format.\n"), "import_from_hdf5");
 261 #ifdef PRINT_DEBUG
 262             {
 263                 char pstMsg[512];
 264
 265                 sprintf(pstMsg, "Unknown type : %d", iVarType);
 266                 print_tree(pstMsg);
 267             }
 268 #endif
 269         }
 270     }
 271
 272     return bRet;
 273 }
 274
 275 static bool import_void(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 276 {
 277     SciErr sciErr;
 278
 279     if (_piAddress)
 280     {
 281         sciErr = createVoidInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos);
 282     }
 283     else
 284     {
 285         return false;
 286     }
 287
 288     if (sciErr.iErr)
 289     {
 290         printError(&sciErr, 0);
 291         return false;
 292     }
 293     return true;
 294 }
 295
 296 static bool import_undefined(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 297 {
 298     SciErr sciErr;
 299
 300     if (_piAddress)
 301     {
 302         sciErr = createUndefinedInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos);
 303     }
 304     else
 305     {
 306         return false;
 307     }
 308
 309     if (sciErr.iErr)
 310     {
 311         printError(&sciErr, 0);
 312         return false;
 313     }
 314     return true;
 315 }
 316
 317 static bool import_double(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 318 {
 319     int iRet = 0;
 320     double *pdblReal = NULL;
 321     double *pdblImg = NULL;
 322     int iRows = 0;
 323     int iCols = 0;
 324     int iComplex = 0;
 325     SciErr sciErr;
 326
 327 #ifdef TIME_DEBUG
 328     LARGE_INTEGER iStart, iEnd, iFreq;
 329
 330     QueryPerformanceFrequency(&iFreq);
 331     QueryPerformanceCounter(&iStart);
 332 #endif
 333
 334     iRet = getDatasetDims(_iDatasetId, &iRows, &iCols);
 335     iComplex = isComplexData(_iDatasetId);
 336     if (iRet)
 337     {
 338         return false;
 339     }
 340
 341     if (iRows * iCols != 0)
 342     {
 343         if (iComplex)
 344         {
 345             pdblReal = (double *)MALLOC(iRows * iCols * sizeof(double));
 346             pdblImg = (double *)MALLOC(iRows * iCols * sizeof(double));
 347             iRet = readDoubleComplexMatrix(_iDatasetId, iRows, iCols, pdblReal, pdblImg);
 348         }
 349         else
 350         {
 351             pdblReal = (double *)MALLOC(iRows * iCols * sizeof(double));
 352             iRet = readDoubleMatrix(_iDatasetId, iRows, iCols, pdblReal);
 353         }
 354
 355         if (iRet)
 356         {
 357             return false;
 358         }
 359     }
 360     else
 361     {
 362         /*bug 7224 : to close dataset */
 363         iRet = readEmptyMatrix(_iDatasetId);
 364         if (iRet)
 365         {
 366             return false;
 367         }
 368     }
 369
 370     if (_piAddress == NULL)
 371     {
 372         if (iComplex)
 373         {
 374             sciErr = createNamedComplexMatrixOfDouble(pvApiCtx, _pstVarname, iRows, iCols, pdblReal, pdblImg);
 375         }
 376         else
 377         {
 378             sciErr = createNamedMatrixOfDouble(pvApiCtx, _pstVarname, iRows, iCols, pdblReal);
 379         }
 380     }
 381     else                        //if not null this variable is in a list
 382     {
 383         if (iComplex)
 384         {
 385             sciErr = createComplexMatrixOfDoubleInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, pdblReal, pdblImg);
 386         }
 387         else
 388         {
 389             sciErr = createMatrixOfDoubleInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, pdblReal);
 390         }
 391     }
 392
 393     if (sciErr.iErr)
 394     {
 395         printError(&sciErr, 0);
 396         return false;
 397     }
 398
 399 #ifdef PRINT_DEBUG
 400     char pstMsg[512];
 401
 402     sprintf(pstMsg, "double_%d (%d x %d)", _iItemPos, iRows, iCols);
 403     print_tree(pstMsg);
 404 #endif
 405
 406     if (pdblReal)
 407     {
 408         FREE(pdblReal);
 409     }
 410
 411     if (pdblImg)
 412     {
 413         FREE(pdblImg);
 414     }
 415
 416     if (iRet)
 417     {
 418         return false;
 419     }
 420
 421 #ifdef TIME_DEBUG
 422     QueryPerformanceCounter(&iEnd);
 423     double dblTime = ((iEnd.QuadPart - iStart.QuadPart) * 1000.0) / iFreq.QuadPart;
 424
 425     printf("Total Double : %0.3f ms\n\n", dblTime);
 426 #endif
 427
 428     return true;
 429 }
 430
 431 static bool import_string(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 432 {
 433     int iRet = 0;
 434     int i = 0;
 435     int iRows = 0;
 436     int iCols = 0;
 437     char **pstData = NULL;
 438     SciErr sciErr;
 439
 440 #ifdef TIME_DEBUG
 441     LARGE_INTEGER iStart1, iEnd1, iStart2, iEnd2, iStart3, iEnd3, iFreq;
 442
 443     QueryPerformanceFrequency(&iFreq);
 444     QueryPerformanceCounter(&iStart1);
 445 #endif
 446     iRet = getDatasetDims(_iDatasetId, &iRows, &iCols);
 447     if (iRet)
 448     {
 449         return false;
 450     }
 451
 452     pstData = (char **)MALLOC(iRows * iCols * sizeof(char *));
 453
 454 #ifdef TIME_DEBUG
 455     QueryPerformanceCounter(&iStart1);
 456 #endif
 457
 458     iRet = readStringMatrix(_iDatasetId, iRows, iCols, pstData);
 459     if (iRet)
 460     {
 461         return false;
 462     }
 463
 464 #ifdef TIME_DEBUG
 465     QueryPerformanceCounter(&iEnd1);
 466 #endif
 467 #ifdef TIME_DEBUG
 468     QueryPerformanceCounter(&iStart2);
 469 #endif
 470
 471     if (_piAddress == NULL)
 472     {
 473         sciErr = createNamedMatrixOfString(pvApiCtx, _pstVarname, iRows, iCols, pstData);
 474     }
 475     else                        //if not null this variable is in a list
 476     {
 477         sciErr = createMatrixOfStringInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, pstData);
 478     }
 479
 480     if (sciErr.iErr)
 481     {
 482         printError(&sciErr, 0);
 483         return false;
 484     }
 485
 486 #ifdef TIME_DEBUG
 487     QueryPerformanceCounter(&iEnd2);
 488     QueryPerformanceCounter(&iStart3);
 489 #endif
 490 #ifdef PRINT_DEBUG
 491     char pstMsg[512];
 492
 493     sprintf(pstMsg, "string_%d (%d x %d)", _iItemPos, iRows, iCols);
 494     print_tree(pstMsg);
 495 #endif
 496     for (i = 0; i < iRows * iCols; i++)
 497     {
 498         FREE(pstData[i]);
 499     }
 500     FREE(pstData);
 501
 502     if (iRet)
 503     {
 504         return false;
 505     }
 506
 507 #ifdef TIME_DEBUG
 508     QueryPerformanceCounter(&iEnd3);
 509
 510     //double dblTime    =((iEnd1.QuadPart - iStart1.QuadPart) * 1000.0) / iFreq.QuadPart;
 511     //printf("HDF5 : %0.3f ms\n", dblTime);
 512     //dblTime   =((iEnd2.QuadPart - iStart2.QuadPart) * 1000.0) / iFreq.QuadPart;
 513     //printf("Stack : %0.3f ms\n", dblTime);
 514     //dblTime   =((iEnd3.QuadPart - iStart3.QuadPart) * 1000.0) / iFreq.QuadPart;
 515     //printf("Clear : %0.3f ms\n", dblTime);
 516     double dblTime = ((iEnd3.QuadPart - iStart1.QuadPart) * 1000.0) / iFreq.QuadPart;
 517
 518     printf("Total String: %0.3f ms\n\n", dblTime);
 519 #endif
 520     return true;
 521 }
 522
 523 static bool import_integer(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 524 {
 525     int iRet = 0;
 526     int iRows = 0;
 527     int iCols = 0;
 528     int iPrec = 0;
 529     SciErr sciErr;
 530
 531     iRet = getDatasetDims(_iDatasetId, &iRows, &iCols);
 532     if (iRet)
 533     {
 534         return false;
 535     }
 536
 537     iRet = getDatasetPrecision(_iDatasetId, &iPrec);
 538     if (iRet)
 539     {
 540         return false;
 541     }
 542
 543     switch (iPrec)
 544     {
 545         case SCI_INT8:
 546         {
 547             char *pcData = NULL;
 548
 549             pcData = (char *)MALLOC(sizeof(char) * iRows * iCols);
 550             iRet = readInteger8Matrix(_iDatasetId, iRows, iCols, pcData);
 551             if (iRet)
 552             {
 553                 return false;
 554             }
 555
 556             if (_piAddress == NULL)
 557             {
 558                 sciErr = createNamedMatrixOfInteger8(pvApiCtx, _pstVarname, iRows, iCols, pcData);
 559             }
 560             else
 561             {
 562                 sciErr = createMatrixOfInteger8InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, pcData);
 563             }
 564         }
 565         break;
 566         case SCI_UINT8:
 567         {
 568             unsigned char *pucData = NULL;
 569
 570             pucData = (unsigned char *)MALLOC(sizeof(unsigned char) * iRows * iCols);
 571             iRet = readUnsignedInteger8Matrix(_iDatasetId, iRows, iCols, pucData);
 572             if (iRet)
 573             {
 574                 return false;
 575             }
 576
 577             if (_piAddress == NULL)
 578             {
 579                 sciErr = createNamedMatrixOfUnsignedInteger8(pvApiCtx, _pstVarname, iRows, iCols, pucData);
 580             }
 581             else
 582             {
 583                 sciErr = createMatrixOfUnsignedInteger8InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, pucData);
 584             }
 585         }
 586         break;
 587         case SCI_INT16:
 588         {
 589             short *psData = NULL;
 590
 591             psData = (short *)MALLOC(sizeof(short) * iRows * iCols);
 592             iRet = readInteger16Matrix(_iDatasetId, iRows, iCols, psData);
 593             if (iRet)
 594             {
 595                 return false;
 596             }
 597
 598             if (_piAddress == NULL)
 599             {
 600                 sciErr = createNamedMatrixOfInteger16(pvApiCtx, _pstVarname, iRows, iCols, psData);
 601             }
 602             else
 603             {
 604                 sciErr = createMatrixOfInteger16InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, psData);
 605             }
 606         }
 607         break;
 608         case SCI_UINT16:
 609         {
 610             unsigned short *pusData = NULL;
 611
 612             pusData = (unsigned short *)MALLOC(sizeof(unsigned short) * iRows * iCols);
 613             iRet = readUnsignedInteger16Matrix(_iDatasetId, iRows, iCols, pusData);
 614             if (iRet)
 615             {
 616                 return false;
 617             }
 618
 619             if (_piAddress == NULL)
 620             {
 621                 sciErr = createNamedMatrixOfUnsignedInteger16(pvApiCtx, _pstVarname, iRows, iCols, pusData);
 622             }
 623             else
 624             {
 625                 sciErr = createMatrixOfUnsignedInteger16InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, pusData);
 626             }
 627         }
 628         break;
 629         case SCI_INT32:
 630         {
 631             int *piData = NULL;
 632
 633             piData = (int *)MALLOC(sizeof(int) * iRows * iCols);
 634             iRet = readInteger32Matrix(_iDatasetId, iRows, iCols, piData);
 635             if (iRet)
 636             {
 637                 return false;
 638             }
 639
 640             if (_piAddress == NULL)
 641             {
 642                 sciErr = createNamedMatrixOfInteger32(pvApiCtx, _pstVarname, iRows, iCols, piData);
 643             }
 644             else
 645             {
 646                 sciErr = createMatrixOfInteger32InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, piData);
 647             }
 648         }
 649         break;
 650         case SCI_UINT32:
 651         {
 652             unsigned int *puiData = NULL;
 653
 654             puiData = (unsigned int *)MALLOC(sizeof(unsigned int) * iRows * iCols);
 655             iRet = readUnsignedInteger32Matrix(_iDatasetId, iRows, iCols, puiData);
 656             if (iRet)
 657             {
 658                 return false;
 659             }
 660
 661             if (_piAddress == NULL)
 662             {
 663                 sciErr = createNamedMatrixOfUnsignedInteger32(pvApiCtx, _pstVarname, iRows, iCols, puiData);
 664             }
 665             else
 666             {
 667                 sciErr = createMatrixOfUnsignedInteger32InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, puiData);
 668             }
 669         }
 670         break;
 671         case SCI_INT64:
 672         {
 673 #ifdef __SCILAB_INT64__
 674             long long *pllData = NULL;
 675
 676             pllData = (long long *)MALLOC(sizeof(long long) * iRows * iCols);
 677             iRet = readInteger64Matrix(_iDatasetId, iRows, iCols, pllData);
 678             if (iRet)
 679             {
 680                 return false;
 681             }
 682
 683             if (_piAddress == NULL)
 684             {
 685                 sciErr = createNamedMatrixOfInteger64(_pstVarname, iRows, iCols, pllData);
 686             }
 687             else
 688             {
 689                 sciErr = createMatrixOfInteger64InNamedList(_pstVarname, _piAddress, _iItemPos, iRows, iCols, pllData);
 690             }
 691 #else
 692             return false;
 693 #endif
 694         }
 695         break;
 696         case SCI_UINT64:
 697         {
 698 #ifdef __SCILAB_INT64__
 699             unsigned long long *pullData = NULL;
 700
 701             pullData = (unsigned long long *)MALLOC(sizeof(unsigned long long) * iRows * iCols);
 702             iRet = readUnsignedInteger64Matrix(_iDatasetId, iRows, iCols, pullData);
 703             if (iRet)
 704             {
 705                 return false;
 706             }
 707
 708             if (_piAddress == NULL)
 709             {
 710                 sciErr = createNamedMatrixOfUnsignedInteger64(_pstVarname, iRows, iCols, pullData);
 711             }
 712             else
 713             {
 714                 sciErr = createMatrixOfUnsignedInteger64InNamedList(_pstVarname, _piAddress, _iItemPos, iRows, iCols, pullData);
 715             }
 716 #else
 717             return false;
 718 #endif
 719         }
 720         break;
 721         default:
 722             return false;
 723     }
 724
 725 #ifdef PRINT_DEBUG
 726     char pstMsg[512];
 727
 728     sprintf(pstMsg, "integer_%d (%d x %d)", _iItemPos, iRows, iCols);
 729     print_tree(pstMsg);
 730 #endif
 731
 732     if (sciErr.iErr)
 733     {
 734         printError(&sciErr, 0);
 735         return false;
 736     }
 737
 738     return true;
 739 }
 740
 741 static bool import_boolean(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 742 {
 743     int iRet = 0;
 744     int *piData = NULL;
 745     int iRows = 0;
 746     int iCols = 0;
 747     SciErr sciErr;
 748
 749     iRet = getDatasetDims(_iDatasetId, &iRows, &iCols);
 750     if (iRet)
 751     {
 752         return false;
 753     }
 754
 755     if (iRows * iCols != 0)
 756     {
 757         piData = (int *)MALLOC(iRows * iCols * sizeof(int));
 758         iRet = readBooleanMatrix(_iDatasetId, iRows, iCols, piData);
 759         if (iRet)
 760         {
 761             return false;
 762         }
 763     }
 764
 765     if (_piAddress == NULL)
 766     {
 767         sciErr = createNamedMatrixOfBoolean(pvApiCtx, _pstVarname, iRows, iCols, piData);
 768     }
 769     else                        //if not null this variable is in a list
 770     {
 771         sciErr = createMatrixOfBooleanInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, piData);
 772     }
 773
 774     if (sciErr.iErr)
 775     {
 776         printError(&sciErr, 0);
 777         return false;
 778     }
 779
 780 #ifdef PRINT_DEBUG
 781     char pstMsg[512];
 782
 783     sprintf(pstMsg, "boolean_%d (%d x %d)", _iItemPos, iRows, iCols);
 784     print_tree(pstMsg);
 785 #endif
 786
 787     if (piData)
 788     {
 789         FREE(piData);
 790     }
 791
 792     if (iRet)
 793     {
 794         return false;
 795     }
 796
 797     return true;
 798 }
 799
 800 static bool import_poly(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 801 {
 802     int iRet = 0;
 803     int i = 0;
 804     int iRows = 0;
 805     int iCols = 0;
 806     int iComplex = 0;
 807     char pstVarName[64] = { 0 };
 808     double **pdblReal = NULL;
 809     double **pdblImg = NULL;
 810     int *piNbCoef = NULL;
 811     SciErr sciErr;
 812
 813     iRet = getDatasetDims(_iDatasetId, &iRows, &iCols);
 814     if (iRet)
 815     {
 816         return false;
 817     }
 818
 819     iComplex = isComplexData(_iDatasetId);
 820
 821     if (iComplex)
 822     {
 823         piNbCoef = (int *)MALLOC(iRows * iCols * sizeof(int));
 824         pdblReal = (double **)MALLOC(iRows * iCols * sizeof(double *));
 825         pdblImg = (double **)MALLOC(iRows * iCols * sizeof(double *));
 826         iRet = readPolyComplexMatrix(_iDatasetId, pstVarName, iRows, iCols, piNbCoef, pdblReal, pdblImg);
 827     }
 828     else
 829     {
 830         piNbCoef = (int *)MALLOC(iRows * iCols * sizeof(int));
 831         pdblReal = (double **)MALLOC(iRows * iCols * sizeof(double *));
 832         iRet = readPolyMatrix(_iDatasetId, pstVarName, iRows, iCols, piNbCoef, pdblReal);
 833     }
 834
 835     if (iRet)
 836     {
 837         return false;
 838     }
 839
 840     if (_piAddress == NULL)
 841     {
 842         if (iComplex)
 843         {
 844             sciErr = createNamedComplexMatrixOfPoly(pvApiCtx, _pstVarname, pstVarName, iRows, iCols, piNbCoef, pdblReal, pdblImg);
 845         }
 846         else
 847         {
 848             sciErr = createNamedMatrixOfPoly(pvApiCtx, _pstVarname, pstVarName, iRows, iCols, piNbCoef, pdblReal);
 849         }
 850     }
 851     else                        //if not null this variable is in a list
 852     {
 853         if (iComplex)
 854         {
 855             sciErr =
 856                 createComplexMatrixOfPolyInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, iRows, iCols, piNbCoef, pdblReal,
 857                         pdblImg);
 858         }
 859         else
 860         {
 861             sciErr = createMatrixOfPolyInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, iRows, iCols, piNbCoef, pdblReal);
 862         }
 863     }
 864
 865     if (sciErr.iErr)
 866     {
 867         printError(&sciErr, 0);
 868         return false;
 869     }
 870
 871 #ifdef PRINT_DEBUG
 872     char pstMsg[512];
 873
 874     sprintf(pstMsg, "poly_%d (%d x %d)", _iItemPos, iRows, iCols);
 875     print_tree(pstMsg);
 876 #endif
 877
 878     for (i = 0; i < iRows * iCols; i++)
 879     {
 880         FREE(pdblReal[i]);
 881     }
 882     FREE(pdblReal);
 883     FREE(piNbCoef);
 884
 885     if (iRet)
 886     {
 887         return false;
 888     }
 889
 890     return true;
 891 }
 892
 893 static bool import_sparse(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 894 {
 895     int iRet = 0;
 896     int iRows = 0;
 897     int iCols = 0;
 898     int iComplex = 0;
 899     double *pdblReal = NULL;
 900     double *pdblImg = NULL;
 901     int iNbItem = 0;
 902     int *piNbItemRow = NULL;
 903     int *piColPos = NULL;
 904     SciErr sciErr;
 905
 906     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
 907     if (iRet)
 908     {
 909         return false;
 910     }
 911
 912     iComplex = isComplexData(_iDatasetId);
 913
 914     if (iComplex)
 915     {
 916         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
 917         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
 918         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
 919         pdblImg = (double *)MALLOC(iNbItem * sizeof(double));
 920         iRet = readSparseComplexMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
 921     }
 922     else
 923     {
 924         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
 925         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
 926         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
 927         iRet = readSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
 928     }
 929
 930     if (iRet)
 931     {
 932         return false;
 933     }
 934
 935     if (_piAddress == NULL)
 936     {
 937         if (iComplex)
 938         {
 939             sciErr = createNamedComplexSparseMatrix(pvApiCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
 940         }
 941         else
 942         {
 943             sciErr = createNamedSparseMatrix(pvApiCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
 944         }
 945     }
 946     else                        //if not null this variable is in a list
 947     {
 948         if (iComplex)
 949         {
 950             sciErr =
 951                 createComplexSparseMatrixInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos,
 952                         pdblReal, pdblImg);
 953         }
 954         else
 955         {
 956             sciErr =
 957                 createSparseMatrixInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
 958         }
 959     }
 960
 961     if (sciErr.iErr)
 962     {
 963         printError(&sciErr, 0);
 964         return false;
 965     }
 966
 967 #ifdef PRINT_DEBUG
 968     char pstMsg[512];
 969
 970     sprintf(pstMsg, "sparse_%d (%d x %d)", _iItemPos, iRows, iCols);
 971     print_tree(pstMsg);
 972 #endif
 973
 974     FREE(piNbItemRow);
 975     FREE(piColPos);
 976     FREE(pdblReal);
 977     if (iComplex)
 978     {
 979         FREE(pdblImg);
 980     }
 981
 982     if (iRet)
 983     {
 984         return false;
 985     }
 986
 987     return true;
 988 }
 989
 990 static bool import_boolean_sparse(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
 991 {
 992     int iRet = 0;
 993     int iRows = 0;
 994     int iCols = 0;
 995     int iNbItem = 0;
 996     int *piNbItemRow = NULL;
 997     int *piColPos = NULL;
 998     SciErr sciErr;
 999
1000     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
1001     if (iRet)
1002     {
1003         return false;
1004     }
1005
1006     piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
1007     piColPos = (int *)MALLOC(iNbItem * sizeof(int));
1008     iRet = readBooleanSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1009     if (iRet)
1010     {
1011         return false;
1012     }
1013
1014     if (_piAddress == NULL)
1015     {
1016         sciErr = createNamedBooleanSparseMatrix(pvApiCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1017     }
1018     else                        //if not null this variable is in a list
1019     {
1020         sciErr = createBooleanSparseMatrixInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1021     }
1022
1023     if (sciErr.iErr)
1024     {
1025         printError(&sciErr, 0);
1026         return false;
1027     }
1028
1029 #ifdef PRINT_DEBUG
1030     char pstMsg[512];
1031
1032     sprintf(pstMsg, "boolean sparse_%d (%d x %d)", _iItemPos, iRows, iCols);
1033     print_tree(pstMsg);
1034 #endif
1035
1036     FREE(piNbItemRow);
1037     FREE(piColPos);
1038
1039     if (iRet)
1040     {
1041         return false;
1042     }
1043
1044     return true;
1045 }
1046
1047 static bool import_list(int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1048 {
1049     int iRet = 0;
1050     int i = 0;
1051     int iItems = 0;
1052     int *piListAddr = NULL;
1053     hobj_ref_t *piItemRef = NULL;
1054     SciErr sciErr;
1055
1056     iRet = getListDims(_iDatasetId, &iItems);
1057     if (iRet)
1058     {
1059         return false;
1060     }
1061
1062     if (iItems == 0)
1063     {
1064         //special case for empty list
1065     }
1066     else
1067     {
1068         iRet = getListItemReferences(_iDatasetId, &piItemRef);
1069         if (iRet)
1070         {
1071             return false;
1072         }
1073     }
1074
1075 #ifdef PRINT_DEBUG
1076     char pstMsg[512];
1077
1078     sprintf(pstMsg, "list_%d (%d)", _iItemPos, iItems);
1079     print_tree(pstMsg);
1080 #endif
1081
1082     if (_piAddress == 0)
1083     {
1084         switch (_iVarType)
1085         {
1086             case sci_list:
1087                 sciErr = createNamedList(pvApiCtx, _pstVarname, iItems, &piListAddr);
1088                 break;
1089             case sci_tlist:
1090                 sciErr = createNamedTList(pvApiCtx, _pstVarname, iItems, &piListAddr);
1091                 break;
1092             case sci_mlist:
1093                 sciErr = createNamedMList(pvApiCtx, _pstVarname, iItems, &piListAddr);
1094                 break;
1095             default:
1096                 return false;
1097         }
1098     }
1099     else                        //if not null this variable is in a list
1100     {
1101         switch (_iVarType)
1102         {
1103             case sci_list:
1104                 sciErr = createListInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1105                 break;
1106             case sci_tlist:
1107                 sciErr = createTListInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1108                 break;
1109             case sci_mlist:
1110                 sciErr = createMListInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1111                 break;
1112             default:
1113                 return false;
1114         }
1115     }
1116
1117     if (sciErr.iErr)
1118     {
1119         printError(&sciErr, 0);
1120         return false;
1121     }
1122
1123     iTab++;
1124     for (i = 0; i < iItems; i++)
1125     {
1126         int iItemDataset = 0;
1127
1128         iRet = getListItemDataset(_iDatasetId, piItemRef, i, &iItemDataset);
1129         if (iRet || iItemDataset == 0)
1130         {
1131             return false;
1132         }
1133
1134         bool bRet = import_data(iItemDataset, i + 1, piListAddr, _pstVarname);
1135
1136         if (bRet == false)
1137         {
1138             return false;
1139         }
1140     }
1141     iTab--;
1142
1143     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1144     if (iRet)
1145     {
1146         return false;
1147     }
1148
1149 #ifdef TIME_DEBUG
1150     printf("Close List %d\n\n", iCloseList++);
1151 #endif
1152
1153 #ifdef PRINT_DEBUG
1154     char pstMsg1[512];
1155
1156     sprintf(pstMsg1, "ListEnd_%d", _iItemPos);
1157     print_tree(pstMsg1);
1158 #endif
1159     return true;
1160 }
1161
1162 void print_tree(char *_pstMsg)
1163 {
1164 #ifdef PRINT_DEBUG
1165     for (int i = 0; i < iTab; i++)
1166     {
1167         printf("\t");
1168     }
1169     printf("%s\n", _pstMsg);
1170 #endif
1171 }
1172
1173 /*--------------------------------------------------------------------------*/