scilab/modules/hdf5/src/c/h5_writeDataToFile.c

   1 /*
   2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3 *  Copyright (C) 2012 - Scilab Enterprises - 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 #define H5_USE_16_API
  14
  15 #include <hdf5.h>
  16 #include <MALLOC.h>
  17 #include <math.h>
  18 #include <string.h>
  19 #include <stdlib.h>
  20 #include "sci_types.h"
  21 #include "version.h"
  22 #include "core_math.h"
  23 #include "h5_writeDataToFile.h"
  24 #include "h5_readDataFromFile.h"
  25 #include "h5_attributeConstants.h"
  26 #include "doublecomplex.h"
  27 #include "stack3.h"
  28
  29 static hid_t enableCompression(int _iLevel, int _iRank, const hsize_t * _piDims)
  30 {
  31     /*hid_t iRet = 0;
  32     int iLevel = _iLevel;*/
  33
  34     return H5P_DEFAULT;
  35     /*
  36       if(iLevel < 0)
  37         {
  38             iLevel = 0;
  39         }
  40
  41       if(iLevel > 9)
  42         {
  43             iLevel = 9;
  44         }
  45
  46         if(iLevel)
  47         {
  48             iRet = H5Pcreate(H5P_DATASET_CREATE);
  49             if(iRet < 0)
  50             {
  51                 iRet = 0;
  52             }
  53             else
  54             {
  55                 if(H5Pset_layout(iRet,H5D_COMPACT)<0)
  56                 {
  57                     H5Pclose(iRet);
  58                     iRet = 0;
  59                 }
  60                 else
  61                 {
  62                     if(H5Pset_chunk(iRet,_iRank, _piDims)<0)
  63                     {
  64                         H5Pclose(iRet);
  65                         iRet = 0;
  66                     }
  67                     else
  68                     {
  69                         if(H5Pset_deflate(iRet,iLevel)<0)
  70                         {
  71                             H5Pclose(iRet);
  72                             iRet = 0;
  73                         }
  74                     }
  75                 }
  76             }
  77         }
  78         else
  79         {
  80             iRet = H5Pcopy(H5P_DEFAULT);
  81         }
  82         return iRet;
  83     */
  84 }
  85
  86 static hsize_t* convertDims(int _iDims, int* _piDims, int* _piSize)
  87 {
  88     int iSize = 1;
  89     int i = 0;
  90     hsize_t* piDims = (hsize_t*)malloc(sizeof(hsize_t) * _iDims);
  91     for (i = 0 ; i < _iDims ; i++)
  92     {
  93         //reverse dimensions to improve rendering in external tools
  94         piDims[i] = _piDims[_iDims - 1 - i];
  95         iSize *= (int)piDims[i];
  96     }
  97
  98     *_piSize = iSize;
  99     return piDims;
 100 }
 101
 102 static herr_t addIntAttribute(int _iDatasetId, const char *_pstName, const int _iVal)
 103 {
 104     hsize_t attributeDims[1] = { 1 };
 105     hid_t attributeTypeId, attributeSpace;
 106     herr_t status;
 107
 108     //Create attribute dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 109     attributeSpace = H5Screate_simple(1, attributeDims, NULL);
 110
 111     //Create the attribute and write it.
 112     attributeTypeId = H5Acreate(_iDatasetId, _pstName, H5T_NATIVE_INT, attributeSpace, H5P_DEFAULT);
 113     if (attributeTypeId < 0)
 114     {
 115         return -1;
 116     }
 117
 118     status = H5Awrite(attributeTypeId, H5T_NATIVE_INT, &_iVal);
 119     if (status < 0)
 120     {
 121         return -1;
 122     }
 123
 124     //Close and release resources.
 125     status = H5Aclose(attributeTypeId);
 126     if (status < 0)
 127     {
 128         return -1;
 129     }
 130
 131     status = H5Sclose(attributeSpace);
 132     if (status < 0)
 133     {
 134         return -1;
 135     }
 136
 137     return 0;
 138 }
 139
 140 static herr_t addAttribute(int _iDatasetId, const char *_pstName, const char *_pstValue)
 141 {
 142     hsize_t attributeDims[1] = { 1 };
 143     hid_t attributeTypeId, attributeSpace, attr;
 144     herr_t status;
 145
 146     //Create attribute dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 147     attributeSpace = H5Screate_simple(1, attributeDims, NULL);
 148
 149     //Create special attribute type
 150     attributeTypeId = H5Tcopy(H5T_C_S1);
 151     status = H5Tset_size(attributeTypeId, strlen(_pstValue));
 152     if (status < 0)
 153     {
 154         return -1;
 155     }
 156
 157     //Create the attribute and write it.
 158     attr = H5Acreate(_iDatasetId, _pstName, attributeTypeId, attributeSpace, H5P_DEFAULT);
 159     if (attr < 0)
 160     {
 161         return -1;
 162     }
 163
 164     status = H5Awrite(attr, attributeTypeId, _pstValue);
 165     if (status < 0)
 166     {
 167         return -1;
 168     }
 169
 170     //Close and release resources.
 171     status = H5Aclose(attr);
 172     if (status < 0)
 173     {
 174         return -1;
 175     }
 176
 177     status = H5Tclose(attributeTypeId);
 178     if (status < 0)
 179     {
 180         return -1;
 181     }
 182
 183     return 0;
 184 }
 185
 186
 187 int updateScilabVersion(int _iFile)
 188 {
 189     herr_t status;
 190     //try to read attribute
 191     char* pstScilabVersion = getScilabVersionAttribute(_iFile);
 192     if (pstScilabVersion)
 193     {
 194         //delete before write
 195         status = H5Adelete(_iFile, g_SCILAB_CLASS_SCI_VERSION);
 196         if (status < 0)
 197         {
 198             return -1;
 199         }
 200     }
 201
 202     if (strstr(SCI_VERSION_STRING, "branch"))
 203     {
 204         //compiled by user
 205         char pstVersion[64];
 206         sprintf(pstVersion, "%s %d.%d.%d", SCI_VERSION_STRING, SCI_VERSION_MAJOR, SCI_VERSION_MINOR, SCI_VERSION_MAINTENANCE);
 207         status = addAttribute(_iFile, g_SCILAB_CLASS_SCI_VERSION, pstVersion);
 208     }
 209     else
 210     {
 211         //compiled by compilation chain
 212         status = addAttribute(_iFile, g_SCILAB_CLASS_SCI_VERSION, SCI_VERSION_STRING);
 213     }
 214
 215     return status;
 216 }
 217
 218 int updateFileVersion(int _iFile)
 219 {
 220     herr_t status;
 221     //try to read attribute
 222     int iHdf5Version = getSODFormatAttribute(_iFile);
 223     if (iHdf5Version != -1)
 224     {
 225         status = H5Adelete(_iFile, g_SCILAB_CLASS_SOD_VERSION);
 226         if (status < 0)
 227         {
 228             return -1;
 229         }
 230     }
 231
 232     return addIntAttribute(_iFile, g_SCILAB_CLASS_SOD_VERSION, SOD_FILE_VERSION);
 233 }
 234
 235 int writeStringMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, char **data)
 236 {
 237     int iSize = 0;
 238     hsize_t* piDims = NULL;
 239     hid_t typeId, space, dset;
 240     herr_t status;
 241     hid_t iCompress;
 242
 243     piDims = convertDims(_iDims, _piDims, &iSize);
 244     //Create string dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 245     space = H5Screate_simple(_iDims, piDims, NULL);
 246     if (space < 0)
 247     {
 248         FREE(piDims);
 249         return -1;
 250     }
 251
 252     //Create special string type
 253     typeId = H5Tcopy(H5T_C_S1);
 254     status = H5Tset_size(typeId, H5T_VARIABLE);
 255     if (status < 0)
 256     {
 257         FREE(piDims);
 258         return -1;
 259     }
 260
 261     //Create the data set and write it.
 262     iCompress = enableCompression(9, _iDims, piDims);
 263     FREE(piDims);
 264     dset = H5Dcreate(_iFile, _pstDatasetName, typeId, space, iCompress);
 265     if (dset < 0)
 266     {
 267         return -1;
 268     }
 269
 270     status = H5Dwrite(dset, typeId, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
 271     if (status < 0)
 272     {
 273         return -1;
 274     }
 275
 276     //Add attribute SCILAB_Class = string to dataset
 277     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_STRING);
 278     if (status < 0)
 279     {
 280         return -1;
 281     }
 282
 283     //Close and release resources.
 284     status = H5Dclose(dset);
 285     if (status < 0)
 286     {
 287         return -1;
 288     }
 289
 290     status = H5Tclose(typeId);
 291     if (status < 0)
 292     {
 293         return -1;
 294     }
 295
 296     return 0;
 297 }
 298
 299 char *createGroupName(char *_pstGroupName)
 300 {
 301     char *pstSlash = NULL;
 302     char *pstGroupName = (char *)MALLOC((strlen(_pstGroupName) + 3) * sizeof(char));
 303
 304     // Generate groupname #<dataSetName>#
 305     sprintf(pstGroupName, "#%s#", _pstGroupName);
 306     pstSlash = strstr(pstGroupName, "/");
 307     if (pstSlash != NULL)
 308     {
 309         pstSlash[0] = '_';
 310     }
 311
 312     return pstGroupName;
 313 }
 314
 315 char* createPathName(char *_pstGroupName, int _iIndex)
 316 {
 317     char *pstName = NULL;
 318     char *pstPathName = NULL;
 319
 320     int iNameLen = (int)log10((double)_iIndex + 1) + 1;
 321     iNameLen += 2; //for both '#'
 322     iNameLen += 1; //for null termanation
 323
 324     pstName = (char *)MALLOC(iNameLen * sizeof(char));
 325     //1 for null termination, 2 for '#' characters
 326     sprintf(pstName, "#%d#", _iIndex);
 327
 328     pstPathName = (char *)MALLOC((strlen(_pstGroupName) + strlen(pstName) + 2) * sizeof(char));
 329     //1 for null termination, 1 for separator, 2 for '#' characters
 330     sprintf(pstPathName, "%s/%s", _pstGroupName, pstName);
 331     FREE(pstName);
 332     return pstPathName;
 333 }
 334
 335 int writeVoid(int _iFile, char *_pstDatasetName)
 336 {
 337     hsize_t piDims[1] = { 1 };
 338     herr_t status = 0;
 339     hid_t iSpace = 0;
 340     hid_t iDataset = 0;
 341     hid_t iCompress = 0;
 342     char cData = 0;
 343
 344     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 345     iSpace = H5Screate_simple(1, piDims, NULL);
 346     if (iSpace < 0)
 347     {
 348         return -1;
 349     }
 350     //Create the dataset and write the array data to it.
 351     iCompress = enableCompression(9, 1, piDims);
 352     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress);
 353     if (iDataset < 0)
 354     {
 355         return -1;
 356     }
 357
 358     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, &cData);
 359     if (status < 0)
 360     {
 361         return -1;
 362     }
 363
 364     //Add attribute SCILAB_Class = double to dataset
 365     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_VOID);
 366     if (status < 0)
 367     {
 368         return -1;
 369     }
 370
 371     //Close and release resources.
 372     status = H5Dclose(iDataset);
 373     if (status < 0)
 374     {
 375         return -1;
 376     }
 377
 378     status = H5Sclose(iSpace);
 379     if (status < 0)
 380     {
 381         return -1;
 382     }
 383
 384     return 0;
 385 }
 386
 387 int writeUndefined(int _iFile, char *_pstDatasetName)
 388 {
 389     hsize_t piDims[1] = { 1 };
 390     herr_t status = 0;
 391     hid_t iSpace = 0;
 392     hid_t iDataset = 0;
 393     hid_t iCompress = 0;
 394     char cData = 0;
 395
 396     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 397     iSpace = H5Screate_simple(1, piDims, NULL);
 398     if (iSpace < 0)
 399     {
 400         return -1;
 401     }
 402     //Create the dataset and write the array data to it.
 403     iCompress = enableCompression(9, 1, piDims);
 404     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress);
 405     if (iDataset < 0)
 406     {
 407         return -1;
 408     }
 409
 410     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, &cData);
 411     if (status < 0)
 412     {
 413         return -1;
 414     }
 415
 416     //Add attribute SCILAB_Class = double to dataset
 417     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_UNDEFINED);
 418     if (status < 0)
 419     {
 420         return -1;
 421     }
 422
 423     //Close and release resources.
 424     status = H5Dclose(iDataset);
 425     if (status < 0)
 426     {
 427         return -1;
 428     }
 429
 430     status = H5Sclose(iSpace);
 431     if (status < 0)
 432     {
 433         return -1;
 434     }
 435
 436     return 0;
 437 }
 438
 439 int writeDoubleMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, double *_pdblData)
 440 {
 441     hid_t space = 0;
 442     hid_t dset = 0;
 443     herr_t status = 0;
 444     hsize_t *piDims = NULL;
 445     hid_t iCompress = 0;
 446     int i = 0;
 447     int iSize = 0;
 448
 449     piDims = convertDims(_iDims, _piDims, &iSize);
 450
 451     if (_iDims == 2 && piDims[0] == 0 && piDims[1] == 0)
 452     {
 453         // []
 454         space = H5Screate_simple(0, NULL, NULL);
 455         if (space < 0)
 456         {
 457             free(piDims);
 458             return -1;
 459         }
 460
 461         //Create the dataset and write the array data to it.
 462         iCompress = enableCompression(9, _iDims, piDims);
 463         free(piDims);
 464
 465         dset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_DOUBLE, space, iCompress);
 466         if (dset < 0)
 467         {
 468             return -1;
 469         }
 470
 471         //Add attribute SCILAB_Class = double to dataset
 472         status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
 473         if (status < 0)
 474         {
 475             return -1;
 476         }
 477
 478         //Close and release resources.
 479         status = H5Dclose(dset);
 480         if (status < 0)
 481         {
 482             return -1;
 483         }
 484
 485         status = H5Sclose(space);
 486         if (status < 0)
 487         {
 488             return -1;
 489         }
 490         return 0;
 491     }
 492
 493     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 494     space = H5Screate_simple(_iDims, piDims, NULL);
 495     if (space < 0)
 496     {
 497         free(piDims);
 498         return -1;
 499     }
 500
 501     //Create the dataset and write the array data to it.
 502     iCompress = enableCompression(9, _iDims, piDims);
 503     free(piDims);
 504
 505     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_DOUBLE, space, iCompress);
 506     if (dset < 0)
 507     {
 508         return -1;
 509     }
 510
 511     status = H5Dwrite(dset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pdblData);
 512     if (status < 0)
 513     {
 514         return -1;
 515     }
 516
 517     //Add attribute SCILAB_Class = double to dataset
 518     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
 519     if (status < 0)
 520     {
 521         return -1;
 522     }
 523
 524     //Close and release resources.
 525     status = H5Dclose(dset);
 526     if (status < 0)
 527     {
 528         return -1;
 529     }
 530
 531     status = H5Sclose(space);
 532     if (status < 0)
 533     {
 534         return -1;
 535     }
 536
 537     return status;
 538 }
 539
 540 int writeDoubleComplexMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, double *_pdblReal, double *_pdblImg)
 541 {
 542     hid_t space = 0;
 543     hid_t dset = 0;
 544     herr_t status = 0;
 545     hsize_t *piDims = NULL;
 546     hid_t iCompress = 0;
 547     hid_t compoundId;
 548     int iSize = 1;
 549     doublecomplex* pData = NULL;
 550
 551     //create sub group only for non empty matrix
 552     if (_iDims == 2 && _piDims[0] == 0 && _piDims[1] == 0)
 553     {
 554         // [] complex
 555         //a revoir
 556         return -1;
 557     }
 558
 559     compoundId = H5Tcreate (H5T_COMPOUND, sizeof(doublecomplex));
 560     H5Tinsert(compoundId, "real", HOFFSET(doublecomplex, r), H5T_NATIVE_DOUBLE);
 561     H5Tinsert(compoundId, "imag", HOFFSET(doublecomplex, i), H5T_NATIVE_DOUBLE);
 562     piDims = convertDims(_iDims, _piDims, &iSize);
 563
 564     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 565     space = H5Screate_simple(_iDims, piDims, NULL);
 566     if (space < 0)
 567     {
 568         free(piDims);
 569         return -1;
 570     }
 571
 572     //Create the dataset and write the array data to it.
 573     iCompress = enableCompression(9, _iDims, piDims);
 574     free(piDims);
 575
 576     dset = H5Dcreate(_iFile, _pstDatasetName, compoundId, space, iCompress);
 577     if (dset < 0)
 578     {
 579         return -1;
 580     }
 581
 582     //convert double data doublecomplex data
 583     pData = oGetDoubleComplexFromPointer(_pdblReal, _pdblImg, iSize);
 584     status = H5Dwrite(dset, compoundId, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
 585     FREE(pData);
 586     if (status < 0)
 587     {
 588         return -1;
 589     }
 590
 591     //Add attribute SCILAB_Class = double to dataset
 592     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
 593     if (status < 0)
 594     {
 595         return -1;
 596     }
 597
 598     //Close and release resources.
 599     status = H5Dclose(dset);
 600     if (status < 0)
 601     {
 602         return -1;
 603     }
 604
 605     status = H5Sclose(space);
 606     if (status < 0)
 607     {
 608         return -1;
 609     }
 610
 611     return status;
 612 }
 613
 614 int writeBooleanMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, int *_piData)
 615 {
 616     int iSize = 0;
 617     hsize_t* piDims = NULL;
 618     herr_t status;
 619     hid_t iSpace;
 620     hid_t iCompress;
 621     hid_t iDataset;
 622
 623     piDims = convertDims(_iDims, _piDims, &iSize);
 624
 625     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 626     iSpace = H5Screate_simple(_iDims, piDims, NULL);
 627     if (iSpace < 0)
 628     {
 629         return -1;
 630     }
 631
 632     //Create the dataset and write the array data to it.
 633     iCompress = enableCompression(9, _iDims, piDims);
 634     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT, iSpace, iCompress);
 635     if (iDataset < 0)
 636     {
 637         return -1;
 638     }
 639
 640     status = H5Dwrite(iDataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
 641     if (status < 0)
 642     {
 643         return -1;
 644     }
 645
 646     //Add attribute SCILAB_Class = double to dataset
 647     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_BOOLEAN);
 648     if (status < 0)
 649     {
 650         return -1;
 651     }
 652
 653     //Close and release resources.
 654     status = H5Dclose(iDataset);
 655     if (status < 0)
 656     {
 657         return -1;
 658     }
 659
 660     status = H5Sclose(iSpace);
 661     if (status < 0)
 662     {
 663         return -1;
 664     }
 665
 666     return 0;
 667 }
 668
 669 static int writeCommonPolyMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iComplex, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal, double **_pdblImg)
 670 {
 671     int i = 0;
 672     hsize_t* piDims = NULL;
 673     herr_t status = 0;
 674     hid_t space = 0;
 675     hid_t dset = 0;
 676     hid_t group = 0;
 677     hid_t iCompress = 0;
 678     hobj_ref_t *pData = 0;
 679     int iSize = 0;
 680
 681     char *pstPathName = NULL;
 682     char *pstGroupName = NULL;
 683
 684     piDims = convertDims(_iDims, _piDims, &iSize);
 685     // Create ref matrix
 686     pData = (hobj_ref_t *)MALLOC(iSize * sizeof(hobj_ref_t));
 687
 688     // Generate groupname #<dataSetName>#
 689     pstGroupName = createGroupName(_pstDatasetName);
 690
 691     //First create a group to store all referenced objects.
 692     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
 693     status = H5Gclose(group);
 694
 695     //Now create each String as a dedicated DataSet.
 696     for (i = 0 ; i < iSize ; i++)
 697     {
 698         pstPathName = createPathName(pstGroupName, i);
 699
 700         // Write the string to ref
 701         if (_iComplex)
 702         {
 703             status = writeDoubleComplexMatrix(_iFile, pstPathName, 1, &_piNbCoef[i], _pdblReal[i], _pdblImg[i]);
 704         }
 705         else
 706         {
 707             status = writeDoubleMatrix(_iFile, pstPathName, 1, &_piNbCoef[i], _pdblReal[i]);
 708         }
 709
 710         if (status < 0)
 711         {
 712             FREE(pstPathName);
 713             FREE(pstGroupName);
 714             FREE(pData);
 715             FREE(piDims);
 716             return -1;
 717         }
 718
 719         // create the ref
 720         status = H5Rcreate(&pData[i], _iFile, pstPathName, H5R_OBJECT, -1);
 721         if (status < 0)
 722         {
 723             FREE(pstPathName);
 724             FREE(pstGroupName);
 725             FREE(pData);
 726             FREE(piDims);
 727             return -1;
 728         }
 729
 730         FREE(pstPathName);
 731     }
 732
 733     FREE(pstGroupName);
 734     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 735     space = H5Screate_simple(_iDims, piDims, NULL);
 736     if (status < 0)
 737     {
 738         FREE(piDims);
 739         FREE(pData);
 740         return -1;
 741     }
 742
 743     //Create the dataset and write the array data to it.
 744     iCompress = enableCompression(9, _iDims, piDims);
 745     FREE(piDims);
 746     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
 747     if (dset < 0)
 748     {
 749         FREE(pData);
 750         return -1;
 751     }
 752
 753     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
 754     if (status < 0)
 755     {
 756         FREE(pData);
 757         return -1;
 758     }
 759
 760     FREE(pData);
 761     //Add attribute SCILAB_Class = poly to dataset
 762     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_POLY);
 763     if (status < 0)
 764     {
 765         return -1;
 766     }
 767
 768     //Add attribute Varname attribute to dataset
 769     status = addAttribute(dset, g_SCILAB_CLASS_VARNAME, _pstVarName);
 770     if (status < 0)
 771     {
 772         return -1;
 773     }
 774
 775     if (_iComplex)
 776     {
 777         //Add attribute Varname attribute to dataset
 778         status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
 779         if (status < 0)
 780         {
 781             return -1;
 782         }
 783     }
 784
 785     //Close and release resources.
 786     status = H5Dclose(dset);
 787     if (status < 0)
 788     {
 789         return -1;
 790     }
 791
 792     status = H5Sclose(space);
 793     if (status < 0)
 794     {
 795         return -1;
 796     }
 797
 798     return 0;
 799 }
 800
 801 int writePolyMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal)
 802 {
 803     return writeCommonPolyMatrix(_iFile, _pstDatasetName, _pstVarName, 0, _iDims, _piDims, _piNbCoef, _pdblReal, NULL);
 804 }
 805
 806 int writePolyComplexMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal,
 807                            double **_pdblImg)
 808 {
 809     return writeCommonPolyMatrix(_iFile, _pstDatasetName, _pstVarName, 1, _iDims, _piDims, _piNbCoef, _pdblReal, _pdblImg);
 810 }
 811
 812 int writeInteger8Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, char *_pcData)
 813 {
 814     hsize_t* piDims = NULL;
 815     herr_t status = 0;
 816     hid_t iSpace = 0;
 817     hid_t iDataset = 0;
 818     hid_t iCompress = 0;
 819     int iSize = 0;
 820
 821     piDims = convertDims(_iDims, _piDims, &iSize);
 822
 823     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 824     iSpace = H5Screate_simple(_iDims, piDims, NULL);
 825     if (iSpace < 0)
 826     {
 827         FREE(piDims);
 828         return -1;
 829     }
 830     //Create the dataset and write the array data to it.
 831     iCompress = enableCompression(9, _iDims, piDims);
 832     FREE(piDims);
 833     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress);
 834     if (iDataset < 0)
 835     {
 836         return -1;
 837     }
 838
 839     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pcData);
 840     if (status < 0)
 841     {
 842         return -1;
 843     }
 844
 845     //Add attribute SCILAB_Class = double to dataset
 846     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
 847     if (status < 0)
 848     {
 849         return -1;
 850     }
 851
 852     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "8");
 853     if (status < 0)
 854     {
 855         return -1;
 856     }
 857
 858     //Close and release resources.
 859     status = H5Dclose(iDataset);
 860     if (status < 0)
 861     {
 862         return -1;
 863     }
 864
 865     status = H5Sclose(iSpace);
 866     if (status < 0)
 867     {
 868         return -1;
 869     }
 870
 871     return 0;
 872 }
 873
 874 int writeInteger16Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, short *_psData)
 875 {
 876     hsize_t* piDims = NULL;
 877     herr_t status = 0;
 878     hid_t iSpace = 0;
 879     hid_t iDataset = 0;
 880     hid_t iCompress = 0;
 881     int iSize = 0;
 882
 883     piDims = convertDims(_iDims, _piDims, &iSize);
 884
 885     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 886     iSpace = H5Screate_simple(_iDims, piDims, NULL);
 887     if (iSpace < 0)
 888     {
 889         FREE(piDims);
 890         return -1;
 891     }
 892     //Create the dataset and write the array data to it.
 893     iCompress = enableCompression(9, _iDims, piDims);
 894     FREE(piDims);
 895     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT16, iSpace, iCompress);
 896     if (iDataset < 0)
 897     {
 898         return -1;
 899     }
 900     status = H5Dwrite(iDataset, H5T_NATIVE_INT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _psData);
 901     if (status < 0)
 902     {
 903         return -1;
 904     }
 905
 906     //Add attribute SCILAB_Class = double to dataset
 907     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
 908     if (status < 0)
 909     {
 910         return -1;
 911     }
 912
 913     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "16");
 914     if (status < 0)
 915     {
 916         return -1;
 917     }
 918
 919     //Close and release resources.
 920     status = H5Dclose(iDataset);
 921     if (status < 0)
 922     {
 923         return -1;
 924     }
 925
 926     status = H5Sclose(iSpace);
 927     if (status < 0)
 928     {
 929         return -1;
 930     }
 931
 932     return 0;
 933 }
 934
 935 int writeInteger32Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, int *_piData)
 936 {
 937     hsize_t* piDims = NULL;
 938     herr_t status = 0;
 939     hid_t iSpace = 0;
 940     hid_t iDataset = 0;
 941     hid_t iCompress = 0;
 942     int iSize = 0;
 943
 944     piDims = convertDims(_iDims, _piDims, &iSize);
 945
 946     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 947     iSpace = H5Screate_simple(_iDims, piDims, NULL);
 948     if (iSpace < 0)
 949     {
 950         FREE(piDims);
 951         return -1;
 952     }
 953     //Create the dataset and write the array data to it.
 954     iCompress = enableCompression(9, _iDims, piDims);
 955     FREE(piDims);
 956     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT32, iSpace, iCompress);
 957     if (iDataset < 0)
 958     {
 959         return -1;
 960     }
 961
 962     status = H5Dwrite(iDataset, H5T_NATIVE_INT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
 963     if (status < 0)
 964     {
 965         return -1;
 966     }
 967
 968     //Add attribute SCILAB_Class = double to dataset
 969     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
 970     if (status < 0)
 971     {
 972         return -1;
 973     }
 974
 975     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "32");
 976     if (status < 0)
 977     {
 978         return -1;
 979     }
 980
 981     //Close and release resources.
 982     status = H5Dclose(iDataset);
 983     if (status < 0)
 984     {
 985         return -1;
 986     }
 987
 988     status = H5Sclose(iSpace);
 989     if (status < 0)
 990     {
 991         return -1;
 992     }
 993
 994     return 0;
 995 }
 996
 997 int writeInteger64Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, long long *_pllData)
 998 {
 999     hsize_t* piDims = NULL;
1000     herr_t status = 0;
1001     hid_t iSpace = 0;
1002     hid_t iDataset = 0;
1003     hid_t iCompress = 0;
1004     int iSize = 0;
1005
1006     piDims = convertDims(_iDims, _piDims, &iSize);
1007
1008     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1009     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1010     if (iSpace < 0)
1011     {
1012         FREE(piDims);
1013         return -1;
1014     }
1015     //Create the dataset and write the array data to it.
1016     iCompress = enableCompression(9, _iDims, piDims);
1017     FREE(piDims);
1018     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT64, iSpace, iCompress);
1019     if (iDataset < 0)
1020     {
1021         return -1;
1022     }
1023
1024     status = H5Dwrite(iDataset, H5T_NATIVE_INT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pllData);
1025     if (status < 0)
1026     {
1027         return -1;
1028     }
1029
1030     //Add attribute SCILAB_Class = double to dataset
1031     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1032     if (status < 0)
1033     {
1034         return -1;
1035     }
1036
1037     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "64");
1038     if (status < 0)
1039     {
1040         return -1;
1041     }
1042
1043     //Close and release resources.
1044     status = H5Dclose(iDataset);
1045     if (status < 0)
1046     {
1047         return -1;
1048     }
1049
1050     status = H5Sclose(iSpace);
1051     if (status < 0)
1052     {
1053         return -1;
1054     }
1055
1056     return 0;
1057 }
1058
1059 int writeUnsignedInteger8Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned char *_pucData)
1060 {
1061     hsize_t* piDims = NULL;
1062     herr_t status = 0;
1063     hid_t iSpace = 0;
1064     hid_t iDataset = 0;
1065     hid_t iCompress = 0;
1066     int iSize = 0;
1067
1068     piDims = convertDims(_iDims, _piDims, &iSize);
1069
1070     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1071     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1072     if (iSpace < 0)
1073     {
1074         FREE(piDims);
1075         return -1;
1076     }
1077     //Create the dataset and write the array data to it.
1078     iCompress = enableCompression(9, _iDims, piDims);
1079     FREE(piDims);
1080     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT8, iSpace, iCompress);
1081     if (iDataset < 0)
1082     {
1083         return -1;
1084     }
1085
1086     status = H5Dwrite(iDataset, H5T_NATIVE_UINT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pucData);
1087     if (status < 0)
1088     {
1089         return -1;
1090     }
1091
1092     //Add attribute SCILAB_Class = double to dataset
1093     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1094     if (status < 0)
1095     {
1096         return -1;
1097     }
1098
1099     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u8");
1100     if (status < 0)
1101     {
1102         return -1;
1103     }
1104
1105     //Close and release resources.
1106     status = H5Dclose(iDataset);
1107     if (status < 0)
1108     {
1109         return -1;
1110     }
1111
1112     status = H5Sclose(iSpace);
1113     if (status < 0)
1114     {
1115         return -1;
1116     }
1117
1118     return 0;
1119 }
1120
1121 int writeUnsignedInteger16Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned short *_pusData)
1122 {
1123     hsize_t* piDims = NULL;
1124     herr_t status = 0;
1125     hid_t iSpace = 0;
1126     hid_t iDataset = 0;
1127     hid_t iCompress = 0;
1128     int iSize = 0;
1129
1130     piDims = convertDims(_iDims, _piDims, &iSize);
1131
1132     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1133     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1134     if (iSpace < 0)
1135     {
1136         FREE(piDims);
1137         return -1;
1138     }
1139     //Create the dataset and write the array data to it.
1140     iCompress = enableCompression(9, _iDims, piDims);
1141     FREE(piDims);
1142     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT16, iSpace, iCompress);
1143     if (iDataset < 0)
1144     {
1145         return -1;
1146     }
1147
1148     status = H5Dwrite(iDataset, H5T_NATIVE_UINT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pusData);
1149     if (status < 0)
1150     {
1151         return -1;
1152     }
1153
1154     //Add attribute SCILAB_Class = double to dataset
1155     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1156     if (status < 0)
1157     {
1158         return -1;
1159     }
1160
1161     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u16");
1162     if (status < 0)
1163     {
1164         return -1;
1165     }
1166
1167     //Close and release resources.
1168     status = H5Dclose(iDataset);
1169     if (status < 0)
1170     {
1171         return -1;
1172     }
1173
1174     status = H5Sclose(iSpace);
1175     if (status < 0)
1176     {
1177         return -1;
1178     }
1179
1180     return 0;
1181 }
1182
1183 int writeUnsignedInteger32Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned int *_puiData)
1184 {
1185     hsize_t* piDims = NULL;
1186     herr_t status = 0;
1187     hid_t iSpace = 0;
1188     hid_t iDataset = 0;
1189     hid_t iCompress = 0;
1190     int iSize = 0;
1191
1192     piDims = convertDims(_iDims, _piDims, &iSize);
1193
1194     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1195     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1196     if (iSpace < 0)
1197     {
1198         FREE(piDims);
1199         return -1;
1200     }
1201     //Create the dataset and write the array data to it.
1202     iCompress = enableCompression(9, _iDims, piDims);
1203     FREE(piDims);
1204     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT32, iSpace, iCompress);
1205     if (iDataset < 0)
1206     {
1207         return -1;
1208     }
1209
1210     status = H5Dwrite(iDataset, H5T_NATIVE_UINT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _puiData);
1211     if (status < 0)
1212     {
1213         return -1;
1214     }
1215
1216     //Add attribute SCILAB_Class = double to dataset
1217     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1218     if (status < 0)
1219     {
1220         return -1;
1221     }
1222
1223     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u32");
1224     if (status < 0)
1225     {
1226         return -1;
1227     }
1228
1229     //Close and release resources.
1230     status = H5Dclose(iDataset);
1231     if (status < 0)
1232     {
1233         return -1;
1234     }
1235
1236     status = H5Sclose(iSpace);
1237     if (status < 0)
1238     {
1239         return -1;
1240     }
1241
1242     return 0;
1243 }
1244
1245 int writeUnsignedInteger64Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned long long *_pullData)
1246 {
1247     hsize_t* piDims = NULL;
1248     herr_t status = 0;
1249     hid_t iSpace = 0;
1250     hid_t iDataset = 0;
1251     hid_t iCompress = 0;
1252     int iSize = 0;
1253
1254     piDims = convertDims(_iDims, _piDims, &iSize);
1255
1256     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1257     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1258     if (iSpace < 0)
1259     {
1260         FREE(piDims);
1261         return -1;
1262     }
1263     //Create the dataset and write the array data to it.
1264     iCompress = enableCompression(9, _iDims, piDims);
1265     FREE(piDims);
1266     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT64, iSpace, iCompress);
1267     if (iDataset < 0)
1268     {
1269         return -1;
1270     }
1271
1272     status = H5Dwrite(iDataset, H5T_NATIVE_UINT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pullData);
1273     if (status < 0)
1274     {
1275         return -1;
1276     }
1277
1278     //Add attribute SCILAB_Class = double to dataset
1279     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1280     if (status < 0)
1281     {
1282         return -1;
1283     }
1284
1285     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u64");
1286     if (status < 0)
1287     {
1288         return -1;
1289     }
1290
1291     //Close and release resources.
1292     status = H5Dclose(iDataset);
1293     if (status < 0)
1294     {
1295         return -1;
1296     }
1297
1298     status = H5Sclose(iSpace);
1299     if (status < 0)
1300     {
1301         return -1;
1302     }
1303
1304     return 0;
1305 }
1306
1307 int writeCommonSparseComplexMatrix(int _iFile, char *_pstDatasetName, int _iComplex, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow,
1308                                    int *_piColPos, double *_pdblReal, double *_pdblImg)
1309 {
1310     hsize_t dims[1] = { 3 };
1311     herr_t status = 0;
1312     hid_t space = 0;
1313     hid_t dset = 0;
1314     hid_t group = 0;
1315     hid_t iCompress = 0;
1316     hobj_ref_t pDataRef[3] = {0};
1317
1318     char *pstRowPath = NULL;
1319     char *pstColPath = NULL;
1320     char *pstDataPath = NULL;
1321     char *pstGroupName = NULL;
1322
1323     // Generate groupname #<dataSetName>#
1324     pstGroupName = createGroupName(_pstDatasetName);
1325
1326     //First create a group to store all referenced objects.
1327     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
1328     status = H5Gclose(group);
1329     if (status < 0)
1330     {
1331         FREE(pstGroupName);
1332         return -1;
1333     }
1334
1335     //Create each sub dataset and insert data
1336     pstRowPath = createPathName(pstGroupName, 0);
1337     status = writeInteger32Matrix(_iFile, pstRowPath, 1, &_iRows, _piNbItemRow);
1338     if (status < 0)
1339     {
1340         FREE(pstRowPath);
1341         FREE(pstGroupName);
1342         return -1;
1343     }
1344
1345     status = H5Rcreate(&pDataRef[0], _iFile, pstRowPath, H5R_OBJECT, -1);
1346     if (status < 0)
1347     {
1348         FREE(pstRowPath);
1349         FREE(pstGroupName);
1350         return -1;
1351     }
1352
1353     pstColPath = createPathName(pstGroupName, 1);
1354     status = writeInteger32Matrix(_iFile, pstColPath, 1, &_iNbItem, _piColPos);
1355     if (status < 0)
1356     {
1357         FREE(pstRowPath);
1358         FREE(pstColPath);
1359         FREE(pstGroupName);
1360         return -1;
1361     }
1362
1363     status = H5Rcreate(&pDataRef[1], _iFile, pstColPath, H5R_OBJECT, -1);
1364     if (status < 0)
1365     {
1366         FREE(pstRowPath);
1367         FREE(pstColPath);
1368         FREE(pstGroupName);
1369         return -1;
1370     }
1371
1372     pstDataPath = createPathName(pstGroupName, 2);
1373     if (_iComplex)
1374     {
1375         status = writeDoubleComplexMatrix(_iFile, pstDataPath, 1, &_iNbItem, _pdblReal, _pdblImg);
1376     }
1377     else
1378     {
1379         status = writeDoubleMatrix(_iFile, pstDataPath, 1, &_iNbItem, _pdblReal);
1380     }
1381
1382     if (status < 0)
1383     {
1384         FREE(pstRowPath);
1385         FREE(pstColPath);
1386         FREE(pstDataPath);
1387         FREE(pstGroupName);
1388         return -1;
1389     }
1390
1391     status = H5Rcreate(&pDataRef[2], _iFile, pstDataPath, H5R_OBJECT, -1);
1392     if (status < 0)
1393     {
1394         FREE(pstRowPath);
1395         FREE(pstColPath);
1396         FREE(pstDataPath);
1397         FREE(pstGroupName);
1398         return -1;
1399     }
1400
1401     //FREE group names
1402     FREE(pstRowPath);
1403     FREE(pstColPath);
1404     FREE(pstDataPath);
1405     FREE(pstGroupName);
1406
1407     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1408     space = H5Screate_simple(1, dims, NULL);
1409     if (space < 0)
1410     {
1411         return -1;
1412     }
1413
1414     //Create the dataset and write the array data to it.
1415     iCompress = enableCompression(9, 1, dims);
1416     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
1417     if (dset < 0)
1418     {
1419         return -1;
1420     }
1421
1422     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
1423     if (status < 0)
1424     {
1425         return -1;
1426     }
1427     //Add attribute SCILAB_Class = poly to dataset
1428     //sprintf(pstRow, "%d", _iRows);
1429     //sprintf(pstCol, "%d", _iCols);
1430     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_SPARSE);
1431     if (status < 0)
1432     {
1433         return -1;
1434     }
1435
1436     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
1437     if (status < 0)
1438     {
1439         return -1;
1440     }
1441
1442     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
1443     if (status < 0)
1444     {
1445         return -1;
1446     }
1447
1448     status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1449     if (status < 0)
1450     {
1451         return -1;
1452     }
1453
1454     if (_iComplex)
1455     {
1456         //Add attribute Varname attribute to dataset
1457         status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
1458         if (status < 0)
1459         {
1460             return -1;
1461         }
1462     }
1463
1464     //Close and release resources.
1465     status = H5Dclose(dset);
1466     if (status < 0)
1467     {
1468         return -1;
1469     }
1470
1471     status = H5Sclose(space);
1472     if (status < 0)
1473     {
1474         return -1;
1475     }
1476
1477     return 0;
1478 }
1479
1480 int writeSparseMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos, double *_pdblReal)
1481 {
1482     return writeCommonSparseComplexMatrix(_iFile, _pstDatasetName, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
1483 }
1484
1485 int writeSparseComplexMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos,
1486                              double *_pdblReal, double *_pdblImg)
1487 {
1488     return writeCommonSparseComplexMatrix(_iFile, _pstDatasetName, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
1489 }
1490
1491 int writeBooleanSparseMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos)
1492 {
1493     hsize_t dims[1] = { 2 };
1494     herr_t status = 0;
1495     hid_t space = 0;
1496     hid_t dset = 0;
1497     hid_t group = 0;
1498     hid_t iCompress = 0;
1499     hobj_ref_t pDataRef[2] = {0};
1500
1501     char *pstRowPath = NULL;
1502     char *pstColPath = NULL;
1503     char *pstGroupName = NULL;
1504
1505     // Generate groupname #<dataSetName>#
1506     pstGroupName = createGroupName(_pstDatasetName);
1507
1508     //First create a group to store all referenced objects.
1509     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
1510     status = H5Gclose(group);
1511     if (status < 0)
1512     {
1513         FREE(pstGroupName);
1514         return -1;
1515     }
1516
1517     //Create each sub dataset and insert data
1518     pstRowPath = createPathName(pstGroupName, 0);
1519     status = writeInteger32Matrix(_iFile, pstRowPath, 1, &_iRows, _piNbItemRow);
1520     if (status < 0)
1521     {
1522         FREE(pstRowPath);
1523         FREE(pstGroupName);
1524         return -1;
1525     }
1526
1527     status = H5Rcreate(&pDataRef[0], _iFile, pstRowPath, H5R_OBJECT, -1);
1528     if (status < 0)
1529     {
1530         FREE(pstRowPath);
1531         FREE(pstGroupName);
1532         return -1;
1533     }
1534
1535     pstColPath = createPathName(pstGroupName, 1);
1536     status = writeInteger32Matrix(_iFile, pstColPath, 1, &_iNbItem, _piColPos);
1537     if (status < 0)
1538     {
1539         FREE(pstRowPath);
1540         FREE(pstColPath);
1541         FREE(pstGroupName);
1542         return -1;
1543     }
1544
1545     status = H5Rcreate(&pDataRef[1], _iFile, pstColPath, H5R_OBJECT, -1);
1546     if (status < 0)
1547     {
1548         FREE(pstRowPath);
1549         FREE(pstColPath);
1550         FREE(pstGroupName);
1551         return -1;
1552     }
1553
1554     //FREE group names
1555     FREE(pstRowPath);
1556     FREE(pstColPath);
1557     FREE(pstGroupName);
1558
1559     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1560     space = H5Screate_simple(1, dims, NULL);
1561     if (space < 0)
1562     {
1563         return -1;
1564     }
1565
1566     //Create the dataset and write the array data to it.
1567     iCompress = enableCompression(9, 1, dims);
1568     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
1569     if (dset < 0)
1570     {
1571         return -1;
1572     }
1573
1574     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
1575     if (status < 0)
1576     {
1577         return -1;
1578     }
1579
1580     //Add attribute SCILAB_Class = boolean sparse to dataset
1581     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_BSPARSE);
1582     if (status < 0)
1583     {
1584         return -1;
1585     }
1586
1587     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
1588     if (status < 0)
1589     {
1590         return -1;
1591     }
1592
1593     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
1594     if (status < 0)
1595     {
1596         return -1;
1597     }
1598
1599     status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1600     if (status < 0)
1601     {
1602         return -1;
1603     }
1604     //Close and release resources.
1605     status = H5Dclose(dset);
1606     if (status < 0)
1607     {
1608         return -1;
1609     }
1610
1611     status = H5Sclose(space);
1612     if (status < 0)
1613     {
1614         return -1;
1615     }
1616
1617     return 0;
1618 }
1619
1620 //create a group and create hobj_ref_t array
1621 void *openList(int _iFile, char *pstDatasetName, int _iNbItem)
1622 {
1623     herr_t status = 0;
1624     hid_t group = 0;
1625     hobj_ref_t *pobjArray = NULL;
1626
1627     //First create a group to store all referenced objects.
1628     group = H5Gcreate(_iFile, pstDatasetName, H5P_DEFAULT);
1629     status = H5Gclose(group);
1630     if (status < 0)
1631     {
1632         return NULL;
1633     }
1634
1635     if (_iNbItem)
1636     {
1637         pobjArray = MALLOC(sizeof(hobj_ref_t) * _iNbItem);
1638     }
1639
1640     return pobjArray;
1641 }
1642
1643 int addItemInList(int _iFile, void *_pvList, int _iPos, char *_pstItemName)
1644 {
1645     hobj_ref_t *pobjArray = (hobj_ref_t *) _pvList;
1646
1647     return H5Rcreate(&pobjArray[_iPos], _iFile, _pstItemName, H5R_OBJECT, -1);
1648 }
1649
1650 int closeList(int _iFile, void *_pvList, char *_pstListName, int _iNbItem, int _iVarType)
1651 {
1652     herr_t status = 0;
1653     hsize_t dims[1] = { _iNbItem };
1654     hid_t space = 0;
1655     hid_t dset = 0;
1656     hid_t iCompress = 0;
1657     const char *pcstClass = NULL;
1658
1659     switch (_iVarType)
1660     {
1661         case sci_list:
1662             pcstClass = g_SCILAB_CLASS_LIST;
1663             break;
1664         case sci_tlist:
1665             pcstClass = g_SCILAB_CLASS_TLIST;
1666             break;
1667         case sci_mlist:
1668             pcstClass = g_SCILAB_CLASS_MLIST;
1669             break;
1670         default:
1671             return 1;
1672     }
1673
1674     if (_iNbItem == 0)
1675     {
1676         //tips for empty list
1677         //insert a fake refence in the array, value = 0
1678
1679         hobj_ref_t pvList[1];
1680
1681         pvList[0] = 0;
1682         //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1683
1684         dims[0] = 1;
1685         space = H5Screate_simple(1, dims, NULL);
1686         if (space < 0)
1687         {
1688             return -1;
1689         }
1690
1691         //Create the dataset and write the array data to it.
1692         iCompress = enableCompression(9, 1, dims);
1693         dset = H5Dcreate(_iFile, _pstListName, H5T_STD_REF_OBJ, space, iCompress);
1694         if (dset < 0)
1695         {
1696             return -1;
1697         }
1698
1699         status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, (hobj_ref_t *) pvList);
1700         if (status < 0)
1701         {
1702             return -1;
1703         }
1704
1705         //Add attribute SCILAB_Class = string to dataset
1706         status = addAttribute(dset, g_SCILAB_CLASS, pcstClass);
1707         if (status < 0)
1708         {
1709             return -1;
1710         }
1711
1712         status = addAttribute(dset, g_SCILAB_CLASS_EMPTY, "true");
1713         if (status < 0)
1714         {
1715             return -1;
1716         }
1717     }
1718     else
1719     {
1720         //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1721         space = H5Screate_simple(1, dims, NULL);
1722         if (status < 0)
1723         {
1724             return -1;
1725         }
1726
1727         //Create the dataset and write the array data to it.
1728         iCompress = enableCompression(9, 1, dims);
1729         dset = H5Dcreate(_iFile, _pstListName, H5T_STD_REF_OBJ, space, iCompress);
1730         if (dset < 0)
1731         {
1732             return -1;
1733         }
1734
1735         status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, (hobj_ref_t *) _pvList);
1736         if (status < 0)
1737         {
1738             return -1;
1739         }
1740
1741         //Add attribute SCILAB_Class = string to dataset
1742         status = addAttribute(dset, g_SCILAB_CLASS, pcstClass);
1743         if (status < 0)
1744         {
1745             return -1;
1746         }
1747
1748         status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1749         if (status < 0)
1750         {
1751             return -1;
1752         }
1753     }
1754
1755     //Close and release resources.
1756     status = H5Dclose(dset);
1757     if (status < 0)
1758     {
1759         return -1;
1760     }
1761
1762     status = H5Sclose(space);
1763     if (status < 0)
1764     {
1765         return -1;
1766     }
1767
1768     FREE(_pvList);
1769     return 0;
1770 }