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