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