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