scilab/modules/hdf5/sci_gateway/cpp/sci_export_to_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.1-en.txt
  10 *
  11 */
  12
  13 #include <hdf5.h>
  14 extern "C"
  15 {
  16 #include <string.h>
  17 #include <stdio.h>
  18 #include "gw_hdf5.h"
  19 #include "MALLOC.h"
  20 #include "Scierror.h"
  21 #include "localization.h"
  22 #include "sciprint.h"
  23 #include "api_scilab.h"
  24 #include "deleteafile.h"
  25 #include "expandPathVariable.h"
  26 #include "h5_fileManagement.h"
  27 #include "h5_writeDataToFile.h"
  28 #include "h5_readDataFromFile.h"
  29 #include "h5_attributeConstants.h"
  30 #include "freeArrayOfString.h"
  31 #ifdef _MSC_VER
  32 #include "strdup_windows.h"
  33 #endif
  34 #include "scilabmode.h"
  35 #include "splitpath.h"
  36 #include "scicurdir.h"
  37 }
  38
  39 //#define PRINT_DEBUG
  40 int iLevel = 0;
  41
  42 static bool isVarExist(int _iFile, char* _pstVarName);
  43
  44 static bool export_data(int _iH5File, int *_piVar, char* _pstName);
  45 static bool export_list(int _iH5File, int *_piVar, char* _pstName, int _iVarType);
  46 static bool export_double(int _iH5File, int *_piVar, char* _pstName);
  47 static bool export_poly(int _iH5File, int *_piVar, char* _pstName);
  48 static bool export_boolean(int _iH5File, int *_piVar, char* _pstName);
  49 static bool export_sparse(int _iH5File, int *_piVar, char* _pstName);
  50 static bool export_boolean_sparse(int _iH5File, int *_piVar, char* _pstName);
  51 static bool export_matlab_sparse(int *_piVar, char* _pstName);
  52 static bool export_ints(int _iH5File, int *_piVar, char* _pstName);
  53 static bool export_handles(int *_piVar, char* _pstName);
  54 static bool export_strings(int _iH5File, int *_piVar, char* _pstName);
  55 static bool export_u_function(int *_piVar, char* _pstName);
  56 static bool export_c_function(int *_piVar, char* _pstName);
  57 static bool export_lib(int *_piVar, char* _pstName);
  58 static bool export_lufact_pointer(int *_piVar, char* _pstName);
  59 static bool export_void(int _iH5File, int *_piVar, char* _pstName);
  60
  61 void print_type(char* _pstType);
  62 int extractVarNameList(int _iStart, int _iEnd, char** _pstNameList);
  63
  64
  65 /*--------------------------------------------------------------------------*/
  66 int sci_export_to_hdf5(char *fname, unsigned long fname_len)
  67 {
  68     int iNbVar          = 0;
  69     int** piAddrList    = NULL;
  70     char** pstNameList  = NULL;
  71     char *pstFileName   = NULL;
  72     bool bExport        = true;
  73     bool bAppendMode    = false;
  74
  75     SciErr sciErr;
  76
  77     int iRhs = nbInputArgument(pvApiCtx);
  78     CheckInputArgumentAtLeast(pvApiCtx, 1);
  79     CheckOutputArgument(pvApiCtx, 0, 1);
  80
  81     pstNameList = (char**)MALLOC(sizeof(char*) * iRhs);
  82     iNbVar = extractVarNameList(1, iRhs, pstNameList);
  83     if (iNbVar == 0)
  84     {
  85         FREE(pstNameList);
  86         return 1;
  87     }
  88
  89     piAddrList = (int**)MALLOC(sizeof(int*) * (iNbVar));
  90     for (int i = 1 ; i < iRhs ; i++)
  91     {
  92         if (strcmp(pstNameList[i], "-append") == 0)
  93         {
  94             bAppendMode = true;
  95         }
  96         else
  97         {
  98             sciErr = getVarAddressFromName(pvApiCtx, pstNameList[i], &piAddrList[i]);
  99             if (sciErr.iErr)
 100             {
 101                 freeArrayOfString(pstNameList, iRhs);
 102                 FREE(piAddrList);
 103                 Scierror(999, _("%s: Wrong value for input argument #%d: Defined variable expected.\n"), fname, i + 1);
 104                 printError(&sciErr, 0);
 105                 return 1;
 106             }
 107         }
 108     }
 109
 110     iLevel = 0;
 111     // open hdf5 file
 112     pstFileName = expandPathVariable(pstNameList[0]);
 113     int iH5File = 0;
 114     if (bAppendMode)
 115     {
 116         iH5File = openHDF5File(pstFileName, bAppendMode);
 117         if (iH5File < 0)
 118         {
 119             iH5File = createHDF5File(pstFileName);
 120         }
 121     }
 122     else
 123     {
 124         iH5File = createHDF5File(pstFileName);
 125     }
 126
 127
 128     if (iH5File < 0)
 129     {
 130         if (iH5File == -2)
 131         {
 132             Scierror(999, _("%s: Wrong value for input argument #%d: \"%s\" is a directory"), fname, 1, pstNameList[0]);
 133         }
 134         else
 135         {
 136             Scierror(999, _("%s: Cannot open file %s.\n"), fname, pstNameList[0]);
 137         }
 138
 139         FREE(piAddrList);
 140         freeArrayOfString(pstNameList, iRhs);
 141         FREE(pstFileName);
 142         return 1;
 143     }
 144
 145     if (bAppendMode)
 146     {
 147         int iVersion = getSODFormatAttribute(iH5File);
 148         if (iVersion != -1 && iVersion != SOD_FILE_VERSION)
 149         {
 150             //to update version must be the same
 151             closeHDF5File(iH5File);
 152             Scierror(999, _("%s: Wrong SOD file format version. Expected: %d Found: %d\n"), fname, SOD_FILE_VERSION, iVersion);
 153             FREE(piAddrList);
 154             freeArrayOfString(pstNameList, iRhs);
 155             FREE(pstFileName);
 156             return 1;
 157         }
 158     }
 159
 160     // export data
 161     for (int i = 1 ; i < iRhs ; i++)
 162     {
 163         if (strcmp(pstNameList[i], "-append") == 0)
 164         {
 165             continue;
 166         }
 167
 168         if (isVarExist(iH5File, pstNameList[i]))
 169         {
 170             if (bAppendMode)
 171             {
 172                 if (deleteHDF5Var(iH5File, pstNameList[i]))
 173                 {
 174                     closeHDF5File(iH5File);
 175                     Scierror(999, _("%s: Unable to delete existing variable \"%s\"."), fname, pstNameList[i]);
 176                     FREE(piAddrList);
 177                     freeArrayOfString(pstNameList, iRhs);
 178                     FREE(pstFileName);
 179                     return 1;
 180                 }
 181             }
 182             else
 183             {
 184                 closeHDF5File(iH5File);
 185                 Scierror(999, _("%s: Variable \'%s\' already exists in file \'%s\'\nUse -append option to replace existing variable\n."), fname, pstNameList[i], pstNameList[0]);
 186                 FREE(piAddrList);
 187                 freeArrayOfString(pstNameList, iRhs);
 188                 FREE(pstFileName);
 189                 return 1;
 190             }
 191         }
 192
 193         bExport = export_data(iH5File, piAddrList[i], pstNameList[i]);
 194         if (bExport == false)
 195         {
 196             break;
 197         }
 198     }
 199
 200     if (bExport && iRhs != 1)
 201     {
 202         //add or update scilab version and file version in hdf5 file
 203         if (updateScilabVersion(iH5File) < 0)
 204         {
 205             closeHDF5File(iH5File);
 206             Scierror(999, _("%s: Unable to update Scilab version in \"%s\"."), fname, pstNameList[0]);
 207             FREE(piAddrList);
 208             freeArrayOfString(pstNameList, iRhs);
 209             FREE(pstFileName);
 210             return 1;
 211         }
 212
 213         if (updateFileVersion(iH5File) < 0)
 214         {
 215             closeHDF5File(iH5File);
 216             Scierror(999, _("%s: Unable to update HDF5 format version in \"%s\"."), fname, pstNameList[0]);
 217             FREE(piAddrList);
 218             freeArrayOfString(pstNameList, iRhs);
 219             FREE(pstFileName);
 220             return 1;
 221         }
 222     }
 223
 224     //close hdf5 file
 225     closeHDF5File(iH5File);
 226
 227     //delete file in case of error but nor in append mode
 228     if (bExport == false && bAppendMode == false && iRhs != 1)
 229     {
 230         //remove file
 231         deleteafile(pstFileName);
 232     }
 233
 234     FREE(pstFileName);
 235     freeArrayOfString(pstNameList, iRhs);
 236     FREE(piAddrList);
 237
 238     //create boolean return value
 239     int *piReturn = NULL;
 240     sciErr = allocMatrixOfBoolean(pvApiCtx, iRhs + 1, 1, 1, &piReturn);
 241     if (sciErr.iErr)
 242     {
 243         printError(&sciErr, 0);
 244         return 1;
 245     }
 246
 247     if (bExport == true || iRhs == 1)
 248     {
 249         piReturn[0] = 1;
 250     }
 251     else
 252     {
 253         piReturn[0] = 0;
 254     }
 255
 256     LhsVar(1) = iRhs + 1;
 257     PutLhsVar();
 258     return 0;
 259 }
 260
 261 static bool export_data(int _iH5File, int* _piVar, char* _pstName)
 262 {
 263     bool bReturn = false;
 264     int iType = 0;
 265
 266     SciErr sciErr = getVarType(pvApiCtx, _piVar, &iType);
 267     if (sciErr.iErr)
 268     {
 269         printError(&sciErr, 0);
 270         return false;
 271     }
 272
 273     switch (iType)
 274     {
 275         case sci_matrix :
 276         {
 277             bReturn = export_double(_iH5File, _piVar, _pstName);
 278             break;
 279         }
 280         case sci_poly :
 281         {
 282             bReturn = export_poly(_iH5File, _piVar, _pstName);
 283             break;
 284         }
 285         case sci_boolean :
 286         {
 287             bReturn = export_boolean(_iH5File, _piVar, _pstName);
 288             break;
 289         }
 290         case sci_sparse :
 291         {
 292             bReturn = export_sparse(_iH5File, _piVar, _pstName);
 293             break;
 294         }
 295         case sci_boolean_sparse :
 296         {
 297             bReturn = export_boolean_sparse(_iH5File, _piVar, _pstName);
 298             break;
 299         }
 300         case sci_matlab_sparse :
 301         {
 302             bReturn = export_matlab_sparse(_piVar, _pstName);
 303             break;
 304         }
 305         case sci_ints :
 306         {
 307             bReturn = export_ints(_iH5File, _piVar, _pstName);
 308             break;
 309         }
 310         case sci_handles :
 311         {
 312             bReturn = export_handles(_piVar, _pstName);
 313             break;
 314         }
 315         case sci_strings :
 316         {
 317             bReturn = export_strings(_iH5File, _piVar, _pstName);
 318             break;
 319         }
 320         case sci_u_function :
 321         {
 322             bReturn = export_u_function(_piVar, _pstName);
 323             break;
 324         }
 325         case sci_c_function :
 326         {
 327             bReturn = export_c_function(_piVar, _pstName);
 328             break;
 329         }
 330         case sci_lib :
 331         {
 332             bReturn = export_lib(_piVar, _pstName);
 333             break;
 334         }
 335         case sci_list :
 336         case sci_tlist :
 337         case sci_mlist :
 338         {
 339             bReturn = export_list(_iH5File, _piVar, _pstName, iType);
 340             break;
 341         }
 342         case sci_lufact_pointer :
 343         {
 344             bReturn = export_lufact_pointer(_piVar, _pstName);
 345             break;
 346         }
 347         case 0 : //void case to "null" items in list
 348         {
 349             bReturn = export_void(_iH5File, _piVar, _pstName);
 350             break;
 351         }
 352
 353         default :
 354         {
 355             bReturn = false;
 356             break;
 357         }
 358     }
 359     return bReturn;
 360 }
 361
 362 static bool export_void(int _iH5File, int *_piVar, char* _pstName)
 363 {
 364     int iRet = writeVoid(_iH5File, _pstName);
 365     if (iRet)
 366     {
 367         return false;
 368     }
 369
 370     //char pstMsg[] = "void";
 371     //print_type(pstMsg);
 372     return true;
 373 }
 374
 375 static bool export_undefined(int _iH5File, int *_piVar, char* _pstName)
 376 {
 377     int iRet = writeUndefined(_iH5File, _pstName);
 378     if (iRet)
 379     {
 380         return false;
 381     }
 382
 383     //char pstMsg[] = "void";
 384     //print_type(pstMsg);
 385     return true;
 386 }
 387
 388 static bool export_list(int _iH5File, int *_piVar, char* _pstName, int _iVarType)
 389 {
 390     int iRet        = 0;
 391     bool bReturn    = false;
 392     int iItemNumber = 0;
 393     SciErr sciErr   = getListItemNumber(pvApiCtx, _piVar, &iItemNumber);
 394     if (sciErr.iErr)
 395     {
 396         printError(&sciErr, 0);
 397         return false;
 398     }
 399
 400
 401     //create groupe name
 402     char* pstGroupName  = createGroupName(_pstName);
 403
 404     //char pstMsg[256];
 405     //sprintf(pstMsg, "list (%d)", iItemNumber);
 406     //print_type(pstMsg);
 407
 408     iLevel++;
 409     //open list
 410     void *pvList = openList(_iH5File, pstGroupName, iItemNumber);
 411     for (int i = 0 ; i < iItemNumber ; i++)
 412     {
 413         int *piNewVar = NULL;
 414         getListItemAddress(pvApiCtx, _piVar, i + 1, &piNewVar);//1 indexed
 415         char* pstPathName   = createPathName(pstGroupName, i);
 416
 417         if (piNewVar == NULL)
 418         {
 419             //undefined item
 420             bReturn = export_undefined(_iH5File, piNewVar, pstPathName);
 421         }
 422         else
 423         {
 424             bReturn = export_data(_iH5File, piNewVar, pstPathName);
 425         }
 426
 427         iRet = addItemInList(_iH5File, pvList, i, pstPathName);
 428         FREE(pstPathName);
 429         if (bReturn == false || iRet)
 430         {
 431             return false;
 432         }
 433     }
 434     iLevel--;
 435     closeList(_iH5File, pvList, _pstName, iItemNumber, _iVarType);
 436     FREE(pstGroupName);
 437     //close list
 438     return true;
 439 }
 440
 441 static bool export_double(int _iH5File, int *_piVar, char* _pstName)
 442 {
 443     int iRet            = 0;
 444     int iComplex        = isVarComplex(pvApiCtx, _piVar);
 445     int piDims[2];
 446     int iType = 0;
 447     double *pdblReal    = NULL;
 448     double *pdblImg             = NULL;
 449
 450     SciErr sciErr = getVarType(pvApiCtx, _piVar, &iType);
 451     if (sciErr.iErr)
 452     {
 453         printError(&sciErr, 0);
 454         return false;
 455     }
 456
 457     if (iType != sci_matrix)
 458     {
 459         return false;
 460     }
 461
 462     if (iComplex)
 463     {
 464         sciErr = getComplexMatrixOfDouble(pvApiCtx, _piVar, &piDims[0], &piDims[1], &pdblReal, &pdblImg);
 465         if (sciErr.iErr)
 466         {
 467             printError(&sciErr, 0);
 468             return false;
 469         }
 470
 471         iRet = writeDoubleComplexMatrix(_iH5File, _pstName, 2, piDims, pdblReal, pdblImg);
 472     }
 473     else
 474     {
 475         sciErr = getMatrixOfDouble(pvApiCtx, _piVar, &piDims[0], &piDims[1], &pdblReal);
 476         if (sciErr.iErr)
 477         {
 478             printError(&sciErr, 0);
 479             return false;
 480         }
 481
 482         iRet = writeDoubleMatrix(_iH5File, _pstName, 2, piDims, pdblReal);
 483     }
 484
 485     if (iRet)
 486     {
 487         return false;
 488     }
 489
 490     //char pstMsg[512];
 491     //sprintf(pstMsg, "double (%d x %d)", piDims[0], piDims[1]);
 492     //print_type(pstMsg);
 493     return true;
 494 }
 495
 496 static bool export_poly(int _iH5File, int *_piVar, char* _pstName)
 497 {
 498     int iRet = 0;
 499     int* piNbCoef = NULL;
 500     double** pdblReal = NULL;
 501     double** pdblImg = NULL;
 502     char pstVarName[64] = {0};
 503     int iVarNameLen = 0;
 504     int piDims[2];
 505
 506     SciErr sciErr = getPolyVariableName(pvApiCtx, _piVar, pstVarName, &iVarNameLen);
 507     if (sciErr.iErr)
 508     {
 509         printError(&sciErr, 0);
 510         return false;
 511     }
 512
 513     if (isVarComplex(pvApiCtx, _piVar))
 514     {
 515         if (getAllocatedMatrixOfComplexPoly(pvApiCtx, _piVar, &piDims[0], &piDims[1], &piNbCoef, &pdblReal, &pdblImg))
 516         {
 517             freeAllocatedMatrixOfComplexPoly(piDims[0], piDims[1], piNbCoef, pdblReal, pdblImg);
 518             return false;
 519         }
 520
 521         iRet = writePolyComplexMatrix(_iH5File, _pstName, pstVarName, 2, piDims, piNbCoef, pdblReal, pdblImg);
 522         freeAllocatedMatrixOfComplexPoly(piDims[0], piDims[1], piNbCoef, pdblReal, pdblImg);
 523     }
 524     else
 525     {
 526         if (getAllocatedMatrixOfPoly(pvApiCtx, _piVar, &piDims[0], &piDims[1], &piNbCoef, &pdblReal))
 527         {
 528             freeAllocatedMatrixOfPoly(piDims[0], piDims[1], piNbCoef, pdblReal);
 529             return false;
 530         }
 531
 532         iRet = writePolyMatrix(_iH5File, _pstName, pstVarName, 2, piDims, piNbCoef, pdblReal);
 533         freeAllocatedMatrixOfPoly(piDims[0], piDims[1], piNbCoef, pdblReal);
 534     }
 535
 536     if (iRet)
 537     {
 538         return false;
 539     }
 540
 541     //char pstMsg[512];
 542     //sprintf(pstMsg, "poly (%d x %d)", piDims[0], piDims[1]);
 543     //print_type(pstMsg);
 544     return true;
 545 }
 546
 547 static bool export_boolean(int _iH5File, int *_piVar, char* _pstName)
 548 {
 549     int *piData = NULL;
 550     int piDims[2];
 551
 552     //for error management
 553     SciErr sciErr = getMatrixOfBoolean(pvApiCtx, _piVar, &piDims[0], &piDims[1], &piData);
 554     if (sciErr.iErr)
 555     {
 556         printError(&sciErr, 0);
 557         return 0;
 558     }
 559
 560     int iRet = writeBooleanMatrix(_iH5File, _pstName, 2, piDims, piData);
 561     if (iRet)
 562     {
 563         //Msg ??
 564         return false;
 565     }
 566
 567     //char pstMsg[512];
 568     //sprintf(pstMsg, "bool (%d x %d)", piDims[0], piDims[1]);
 569     //print_type(pstMsg);
 570     return true;
 571 }
 572
 573 static bool export_boolean_sparse(int _iH5File, int *_piVar, char* _pstName)
 574 {
 575     int iRet = 0;
 576     int iNbItem = 0;
 577     int* piNbItemRow = NULL;
 578     int* piColPos = NULL;
 579     int piDims[2];
 580
 581     SciErr sciErr = getBooleanSparseMatrix(pvApiCtx, _piVar, &piDims[0], &piDims[1], &iNbItem, &piNbItemRow, &piColPos);
 582     if (sciErr.iErr)
 583     {
 584         printError(&sciErr, 0);
 585         return false;
 586     }
 587
 588     iRet = writeBooleanSparseMatrix(_iH5File, _pstName, piDims[0], piDims[1], iNbItem, piNbItemRow, piColPos);
 589     if (iRet)
 590     {
 591         //Msg ??
 592         return false;
 593     }
 594
 595     //char pstMsg[512];
 596     //sprintf(pstMsg, "boolean sparse (%d x %d)", piDims[0], piDims[1]);
 597     //print_type(pstMsg);
 598     return true;
 599 }
 600
 601 static bool export_sparse(int _iH5File, int *_piVar, char* _pstName)
 602 {
 603     int iRet = 0;
 604     int iNbItem = 0;
 605     int* piNbItemRow = NULL;
 606     int* piColPos = NULL;
 607     double* pdblReal = NULL;
 608     double* pdblImg = NULL;
 609     int piDims[2];
 610     SciErr sciErr;
 611
 612     if (isVarComplex(pvApiCtx, _piVar))
 613     {
 614         sciErr = getComplexSparseMatrix(pvApiCtx, _piVar, &piDims[0], &piDims[1], &iNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
 615         if (sciErr.iErr)
 616         {
 617             printError(&sciErr, 0);
 618             return false;
 619         }
 620
 621         iRet = writeSparseComplexMatrix(_iH5File, _pstName, piDims[0], piDims[1], iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
 622     }
 623     else
 624     {
 625         sciErr = getSparseMatrix(pvApiCtx, _piVar, &piDims[0], &piDims[1], &iNbItem, &piNbItemRow, &piColPos, &pdblReal);
 626         if (sciErr.iErr)
 627         {
 628             printError(&sciErr, 0);
 629             return false;
 630         }
 631
 632         iRet = writeSparseMatrix(_iH5File, _pstName, piDims[0], piDims[1], iNbItem, piNbItemRow, piColPos, pdblReal);
 633     }
 634
 635     if (iRet)
 636     {
 637         return false;
 638     }
 639
 640     //char pstMsg[512];
 641     //sprintf(pstMsg, "sparse (%d x %d)", piDims[0], piDims[1]);
 642     //print_type(pstMsg);
 643     return true;
 644 }
 645
 646 static bool export_matlab_sparse(int *_piVar, char* _pstName)
 647 {
 648     //print_type(_pstName);
 649     return false;
 650 }
 651
 652 static bool export_ints(int _iH5File, int *_piVar, char* _pstName)
 653 {
 654     int iRet = 0;
 655     void *piData = NULL;
 656     int iPrec = 0;
 657     int piDims[2];
 658
 659     SciErr sciErr = getMatrixOfIntegerPrecision(pvApiCtx, _piVar, &iPrec);
 660     if (sciErr.iErr)
 661     {
 662         printError(&sciErr, 0);
 663         return false;
 664     }
 665
 666     switch (iPrec)
 667     {
 668         case SCI_INT8 :
 669             sciErr = getMatrixOfInteger8(pvApiCtx, _piVar, &piDims[0], &piDims[1], (char**)&piData);
 670             if (sciErr.iErr)
 671             {
 672                 printError(&sciErr, 0);
 673                 return false;
 674             }
 675             iRet = writeInteger8Matrix(_iH5File, _pstName, 2, piDims, (char*)piData);
 676             break;
 677         case SCI_UINT8 :
 678             sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, _piVar, &piDims[0], &piDims[1], (unsigned char**)&piData);
 679             if (sciErr.iErr)
 680             {
 681                 printError(&sciErr, 0);
 682                 return false;
 683             }
 684             iRet = writeUnsignedInteger8Matrix(_iH5File, _pstName, 2, piDims, (unsigned char*)piData);
 685             break;
 686         case SCI_INT16 :
 687             sciErr = getMatrixOfInteger16(pvApiCtx, _piVar, &piDims[0], &piDims[1], (short**)&piData);
 688             if (sciErr.iErr)
 689             {
 690                 printError(&sciErr, 0);
 691                 return false;
 692             }
 693             iRet = writeInteger16Matrix(_iH5File, _pstName, 2, piDims, (short*)piData);
 694             break;
 695         case SCI_UINT16 :
 696             sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, _piVar, &piDims[0], &piDims[1], (unsigned short**)&piData);
 697             if (sciErr.iErr)
 698             {
 699                 printError(&sciErr, 0);
 700                 return false;
 701             }
 702             iRet = writeUnsignedInteger16Matrix(_iH5File, _pstName, 2, piDims, (unsigned short*)piData);
 703             break;
 704         case SCI_INT32 :
 705             sciErr = getMatrixOfInteger32(pvApiCtx, _piVar, &piDims[0], &piDims[1], (int**)&piData);
 706             if (sciErr.iErr)
 707             {
 708                 printError(&sciErr, 0);
 709                 return false;
 710             }
 711             iRet = writeInteger32Matrix(_iH5File, _pstName, 2, piDims, (int*)piData);
 712             break;
 713         case SCI_UINT32 :
 714             sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, _piVar, &piDims[0], &piDims[1], (unsigned int**)&piData);
 715             if (sciErr.iErr)
 716             {
 717                 printError(&sciErr, 0);
 718                 return false;
 719             }
 720             iRet = writeUnsignedInteger32Matrix(_iH5File, _pstName, 2, piDims, (unsigned int*)piData);
 721             break;
 722         case SCI_INT64 :
 723             //sciErr = getMatrixOfInteger64(_piVar, &piDims[0], &piDims[1], (long long**)&piData);
 724             //if(sciErr.iErr)
 725             //{
 726             //  printError(&sciErr, 0);
 727             //  return false;
 728             //}
 729             //iRet = writeInteger64Matrix(_iH5File, _pstName, 2, piDims, (long long*)piData);
 730             //break;
 731         case SCI_UINT64 :
 732             //sciErr = getMatrixOfUnsignedInteger64(_piVar, &piDims[0], &piDims[1], (unsigned long long**)&piData);
 733             //if(sciErr.iErr)
 734             //{
 735             //  printError(&sciErr, 0);
 736             //  return false;
 737             //}
 738             //iRet = writeUnsignedInteger64Matrix(_iH5File, _pstName, 2, piDims, (unsigned long long*)piData);
 739             //break;
 740         default :
 741             return 1;
 742             break;
 743     }
 744
 745     if (iRet)
 746     {
 747         return false;
 748     }
 749
 750     //char pstMsg[512];
 751     //sprintf(pstMsg, "int%d (%d x %d)", 8 * iPrec, piDims[0], piDims[1]);
 752     //print_type(pstMsg);
 753     return true;
 754 }
 755
 756 static bool export_handles(int *_piVar, char* _pstName)
 757 {
 758     //print_type(_pstName);
 759     return false;
 760 }
 761
 762 static bool export_strings(int _iH5File, int *_piVar, char* _pstName)
 763 {
 764     int iRet = 0;
 765     char** pstData = NULL;
 766     int piDims[2];
 767
 768     SciErr sciErr = getMatrixOfString(pvApiCtx, _piVar, &piDims[0], &piDims[1], NULL, NULL);
 769     if (sciErr.iErr)
 770     {
 771         printError(&sciErr, 0);
 772         return false;
 773     }
 774
 775     if (getAllocatedMatrixOfString(pvApiCtx, _piVar, &piDims[0], &piDims[1], &pstData))
 776     {
 777         if (pstData)
 778         {
 779             freeAllocatedMatrixOfString(piDims[0], piDims[1], pstData);
 780         }
 781
 782         return false;
 783     }
 784
 785     iRet = writeStringMatrix(_iH5File, _pstName, 2, piDims, pstData);
 786     freeAllocatedMatrixOfString(piDims[0], piDims[1], pstData);
 787     if (iRet)
 788     {
 789         return false;
 790     }
 791
 792     //char pstMsg[512];
 793     //sprintf(pstMsg, "string (%d x %d)", piDims[0], piDims[1]);
 794     //print_type(pstMsg);
 795
 796     return true;
 797 }
 798
 799 static bool export_u_function(int *_piVar, char* _pstName)
 800 {
 801     //print_type(_pstName);
 802     return false;
 803 }
 804
 805 static bool export_c_function(int *_piVar, char* _pstName)
 806 {
 807     //print_type(_pstName);
 808     return false;
 809 }
 810
 811 static bool export_lib(int *_piVar, char* _pstName)
 812 {
 813     //print_type(_pstName);
 814     return false;
 815 }
 816
 817 static bool export_lufact_pointer(int *_piVar, char* _pstName)
 818 {
 819     /*print_type*/(_pstName);
 820     return false;
 821 }
 822
 823 void print_type(char* _pstType)
 824 {
 825 #ifdef PRINT_DEBUG
 826     for (int i = 0 ; i < iLevel ; i++)
 827     {
 828         sciprint("\t");
 829     }
 830     sciprint("%s\n", _pstType);
 831 #endif
 832 }
 833
 834 int extractVarNameList(int _iStart, int _iEnd, char** _pstNameList)
 835 {
 836     int iCount = 0;
 837
 838     for (int i = _iStart ; i <= _iEnd ; i++)
 839     {
 840         int* piAddr = NULL;
 841         int iType   = 0;
 842
 843         SciErr sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddr);
 844         if (sciErr.iErr)
 845         {
 846             printError(&sciErr, 0);
 847             return 0;
 848         }
 849
 850         if (getAllocatedSingleString(pvApiCtx, piAddr, &_pstNameList[iCount]))
 851         {
 852             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), "export_to_hdf5", i);
 853             return 0;
 854         }
 855
 856         iCount++;
 857     }
 858     return iCount;
 859 }
 860
 861 static bool isVarExist(int _iFile, char* _pstVarName)
 862 {
 863     //check if variable already exists
 864     int iNbItem = getVariableNames(_iFile, NULL);
 865     if (iNbItem)
 866     {
 867         char **pstVarNameList = (char **)MALLOC(sizeof(char *) * iNbItem);
 868
 869         iNbItem = getVariableNames(_iFile, pstVarNameList);
 870
 871         //import all data
 872         for (int i = 0 ; i < iNbItem ; i++)
 873         {
 874             if (strcmp(pstVarNameList[i], _pstVarName) == 0)
 875             {
 876                 return true;
 877             }
 878         }
 879
 880         freeArrayOfString(pstVarNameList, iNbItem);
 881     }
 882
 883     return false;
 884 }
 885 /*--------------------------------------------------------------------------*/