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