Bug HDF5: Correct the write of emptymatrix test_run('optimization','bug_7093')
[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 _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     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
452     space = H5Screate_simple(_iDims, piDims, NULL);
453     if (space < 0)
454     {
455         free(piDims);
456         return -1;
457     }
458
459     if (_iDims == 2 && piDims[0] == 0 && piDims[1] == 0)
460     {
461         // []
462       
463
464         //Create the dataset and write the array data to it.
465         iCompress = enableCompression(9, _iDims, piDims);
466         free(piDims);
467
468         dset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_DOUBLE, space, iCompress);
469         if (dset < 0)
470         {
471             return -1;
472         }
473
474         //Add attribute SCILAB_Class = double to dataset
475         status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
476         if (status < 0)
477         {
478             return -1;
479         }
480
481         //Close and release resources.
482         status = H5Dclose(dset);
483         if (status < 0)
484         {
485             return -1;
486         }
487
488         status = H5Sclose(space);
489         if (status < 0)
490         {
491             return -1;
492         }
493         return 0;
494     }
495
496     
497
498     //Create the dataset and write the array data to it.
499     iCompress = enableCompression(9, _iDims, piDims);
500     free(piDims);
501
502     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_DOUBLE, space, iCompress);
503     if (dset < 0)
504     {
505         return -1;
506     }
507
508     status = H5Dwrite(dset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pdblData);
509     if (status < 0)
510     {
511         return -1;
512     }
513
514     //Add attribute SCILAB_Class = double to dataset
515     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
516     if (status < 0)
517     {
518         return -1;
519     }
520
521     //Close and release resources.
522     status = H5Dclose(dset);
523     if (status < 0)
524     {
525         return -1;
526     }
527
528     status = H5Sclose(space);
529     if (status < 0)
530     {
531         return -1;
532     }
533
534     return status;
535 }
536
537 int writeDoubleComplexMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, double *_pdblReal, double *_pdblImg)
538 {
539     hid_t space = 0;
540     hid_t dset = 0;
541     herr_t status = 0;
542     hsize_t *piDims = NULL;
543     hid_t iCompress = 0;
544     hid_t compoundId;
545     int iSize = 1;
546     doublecomplex* pData = NULL;
547
548     //create sub group only for non empty matrix
549     if (_iDims == 2 && _piDims[0] == 0 && _piDims[1] == 0)
550     {
551         // [] complex
552         //a revoir
553         return -1;
554     }
555
556     compoundId = H5Tcreate (H5T_COMPOUND, sizeof(doublecomplex));
557     H5Tinsert(compoundId, "real", HOFFSET(doublecomplex, r), H5T_NATIVE_DOUBLE);
558     H5Tinsert(compoundId, "imag", HOFFSET(doublecomplex, i), H5T_NATIVE_DOUBLE);
559     piDims = convertDims(_iDims, _piDims, &iSize);
560
561     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
562     space = H5Screate_simple(_iDims, piDims, NULL);
563     if (space < 0)
564     {
565         free(piDims);
566         return -1;
567     }
568
569     //Create the dataset and write the array data to it.
570     iCompress = enableCompression(9, _iDims, piDims);
571     free(piDims);
572
573     dset = H5Dcreate(_iFile, _pstDatasetName, compoundId, space, iCompress);
574     if (dset < 0)
575     {
576         return -1;
577     }
578
579     //convert double data doublecomplex data
580     pData = oGetDoubleComplexFromPointer(_pdblReal, _pdblImg, iSize);
581     status = H5Dwrite(dset, compoundId, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
582     FREE(pData);
583     if (status < 0)
584     {
585         return -1;
586     }
587
588     //Add attribute SCILAB_Class = double to dataset
589     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
590     if (status < 0)
591     {
592         return -1;
593     }
594
595     //Close and release resources.
596     status = H5Dclose(dset);
597     if (status < 0)
598     {
599         return -1;
600     }
601
602     status = H5Sclose(space);
603     if (status < 0)
604     {
605         return -1;
606     }
607
608     return status;
609 }
610
611 int writeBooleanMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, int *_piData)
612 {
613     int iSize = 0;
614     hsize_t* piDims = NULL;
615     herr_t status;
616     hid_t iSpace;
617     hid_t iCompress;
618     hid_t iDataset;
619
620     piDims = convertDims(_iDims, _piDims, &iSize);
621
622     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
623     iSpace = H5Screate_simple(_iDims, piDims, NULL);
624     if (iSpace < 0)
625     {
626         return -1;
627     }
628
629     //Create the dataset and write the array data to it.
630     iCompress = enableCompression(9, _iDims, piDims);
631     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT, iSpace, iCompress);
632     if (iDataset < 0)
633     {
634         return -1;
635     }
636
637     status = H5Dwrite(iDataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
638     if (status < 0)
639     {
640         return -1;
641     }
642
643     //Add attribute SCILAB_Class = double to dataset
644     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_BOOLEAN);
645     if (status < 0)
646     {
647         return -1;
648     }
649
650     //Close and release resources.
651     status = H5Dclose(iDataset);
652     if (status < 0)
653     {
654         return -1;
655     }
656
657     status = H5Sclose(iSpace);
658     if (status < 0)
659     {
660         return -1;
661     }
662
663     return 0;
664 }
665
666 static int writeCommonPolyMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iComplex, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal, double **_pdblImg)
667 {
668     int i = 0;
669     hsize_t* piDims = NULL;
670     herr_t status = 0;
671     hid_t space = 0;
672     hid_t dset = 0;
673     hid_t group = 0;
674     hid_t iCompress = 0;
675     hobj_ref_t *pData = 0;
676     int iSize = 0;
677
678     char *pstPathName = NULL;
679     char *pstGroupName = NULL;
680
681     piDims = convertDims(_iDims, _piDims, &iSize);
682     // Create ref matrix
683     pData = (hobj_ref_t *)MALLOC(iSize * sizeof(hobj_ref_t));
684
685     // Generate groupname #<dataSetName>#
686     pstGroupName = createGroupName(_pstDatasetName);
687
688     //First create a group to store all referenced objects.
689     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
690     status = H5Gclose(group);
691
692     //Now create each String as a dedicated DataSet.
693     for (i = 0 ; i < iSize ; i++)
694     {
695         pstPathName = createPathName(pstGroupName, i);
696
697         // Write the string to ref
698         if (_iComplex)
699         {
700             status = writeDoubleComplexMatrix(_iFile, pstPathName, 1, &_piNbCoef[i], _pdblReal[i], _pdblImg[i]);
701         }
702         else
703         {
704             status = writeDoubleMatrix(_iFile, pstPathName, 1, &_piNbCoef[i], _pdblReal[i]);
705         }
706
707         if (status < 0)
708         {
709             FREE(pstPathName);
710             FREE(pstGroupName);
711             FREE(pData);
712             FREE(piDims);
713             return -1;
714         }
715
716         // create the ref
717         status = H5Rcreate(&pData[i], _iFile, pstPathName, H5R_OBJECT, -1);
718         if (status < 0)
719         {
720             FREE(pstPathName);
721             FREE(pstGroupName);
722             FREE(pData);
723             FREE(piDims);
724             return -1;
725         }
726
727         FREE(pstPathName);
728     }
729
730     FREE(pstGroupName);
731     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
732     space = H5Screate_simple(_iDims, piDims, NULL);
733     if (status < 0)
734     {
735         FREE(piDims);
736         FREE(pData);
737         return -1;
738     }
739
740     //Create the dataset and write the array data to it.
741     iCompress = enableCompression(9, _iDims, piDims);
742     FREE(piDims);
743     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
744     if (dset < 0)
745     {
746         FREE(pData);
747         return -1;
748     }
749
750     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
751     if (status < 0)
752     {
753         FREE(pData);
754         return -1;
755     }
756
757     FREE(pData);
758     //Add attribute SCILAB_Class = poly to dataset
759     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_POLY);
760     if (status < 0)
761     {
762         return -1;
763     }
764
765     //Add attribute Varname attribute to dataset
766     status = addAttribute(dset, g_SCILAB_CLASS_VARNAME, _pstVarName);
767     if (status < 0)
768     {
769         return -1;
770     }
771
772     if (_iComplex)
773     {
774         //Add attribute Varname attribute to dataset
775         status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
776         if (status < 0)
777         {
778             return -1;
779         }
780     }
781
782     //Close and release resources.
783     status = H5Dclose(dset);
784     if (status < 0)
785     {
786         return -1;
787     }
788
789     status = H5Sclose(space);
790     if (status < 0)
791     {
792         return -1;
793     }
794
795     return 0;
796 }
797
798 int writePolyMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal)
799 {
800     return writeCommonPolyMatrix(_iFile, _pstDatasetName, _pstVarName, 0, _iDims, _piDims, _piNbCoef, _pdblReal, NULL);
801 }
802
803 int writePolyComplexMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal,
804                            double **_pdblImg)
805 {
806     return writeCommonPolyMatrix(_iFile, _pstDatasetName, _pstVarName, 1, _iDims, _piDims, _piNbCoef, _pdblReal, _pdblImg);
807 }
808
809 int writeInteger8Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, char *_pcData)
810 {
811     hsize_t* piDims = NULL;
812     herr_t status = 0;
813     hid_t iSpace = 0;
814     hid_t iDataset = 0;
815     hid_t iCompress = 0;
816     int iSize = 0;
817
818     piDims = convertDims(_iDims, _piDims, &iSize);
819
820     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
821     iSpace = H5Screate_simple(_iDims, piDims, NULL);
822     if (iSpace < 0)
823     {
824         FREE(piDims);
825         return -1;
826     }
827     //Create the dataset and write the array data to it.
828     iCompress = enableCompression(9, _iDims, piDims);
829     FREE(piDims);
830     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress);
831     if (iDataset < 0)
832     {
833         return -1;
834     }
835
836     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pcData);
837     if (status < 0)
838     {
839         return -1;
840     }
841
842     //Add attribute SCILAB_Class = double to dataset
843     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
844     if (status < 0)
845     {
846         return -1;
847     }
848
849     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "8");
850     if (status < 0)
851     {
852         return -1;
853     }
854
855     //Close and release resources.
856     status = H5Dclose(iDataset);
857     if (status < 0)
858     {
859         return -1;
860     }
861
862     status = H5Sclose(iSpace);
863     if (status < 0)
864     {
865         return -1;
866     }
867
868     return 0;
869 }
870
871 int writeInteger16Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, short *_psData)
872 {
873     hsize_t* piDims = NULL;
874     herr_t status = 0;
875     hid_t iSpace = 0;
876     hid_t iDataset = 0;
877     hid_t iCompress = 0;
878     int iSize = 0;
879
880     piDims = convertDims(_iDims, _piDims, &iSize);
881
882     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
883     iSpace = H5Screate_simple(_iDims, piDims, NULL);
884     if (iSpace < 0)
885     {
886         FREE(piDims);
887         return -1;
888     }
889     //Create the dataset and write the array data to it.
890     iCompress = enableCompression(9, _iDims, piDims);
891     FREE(piDims);
892     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT16, iSpace, iCompress);
893     if (iDataset < 0)
894     {
895         return -1;
896     }
897     status = H5Dwrite(iDataset, H5T_NATIVE_INT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _psData);
898     if (status < 0)
899     {
900         return -1;
901     }
902
903     //Add attribute SCILAB_Class = double to dataset
904     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
905     if (status < 0)
906     {
907         return -1;
908     }
909
910     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "16");
911     if (status < 0)
912     {
913         return -1;
914     }
915
916     //Close and release resources.
917     status = H5Dclose(iDataset);
918     if (status < 0)
919     {
920         return -1;
921     }
922
923     status = H5Sclose(iSpace);
924     if (status < 0)
925     {
926         return -1;
927     }
928
929     return 0;
930 }
931
932 int writeInteger32Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, int *_piData)
933 {
934     hsize_t* piDims = NULL;
935     herr_t status = 0;
936     hid_t iSpace = 0;
937     hid_t iDataset = 0;
938     hid_t iCompress = 0;
939     int iSize = 0;
940
941     piDims = convertDims(_iDims, _piDims, &iSize);
942
943     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
944     iSpace = H5Screate_simple(_iDims, piDims, NULL);
945     if (iSpace < 0)
946     {
947         FREE(piDims);
948         return -1;
949     }
950     //Create the dataset and write the array data to it.
951     iCompress = enableCompression(9, _iDims, piDims);
952     FREE(piDims);
953     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT32, iSpace, iCompress);
954     if (iDataset < 0)
955     {
956         return -1;
957     }
958
959     status = H5Dwrite(iDataset, H5T_NATIVE_INT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
960     if (status < 0)
961     {
962         return -1;
963     }
964
965     //Add attribute SCILAB_Class = double to dataset
966     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
967     if (status < 0)
968     {
969         return -1;
970     }
971
972     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "32");
973     if (status < 0)
974     {
975         return -1;
976     }
977
978     //Close and release resources.
979     status = H5Dclose(iDataset);
980     if (status < 0)
981     {
982         return -1;
983     }
984
985     status = H5Sclose(iSpace);
986     if (status < 0)
987     {
988         return -1;
989     }
990
991     return 0;
992 }
993
994 int writeInteger64Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, long long *_pllData)
995 {
996     hsize_t* piDims = NULL;
997     herr_t status = 0;
998     hid_t iSpace = 0;
999     hid_t iDataset = 0;
1000     hid_t iCompress = 0;
1001     int iSize = 0;
1002
1003     piDims = convertDims(_iDims, _piDims, &iSize);
1004
1005     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1006     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1007     if (iSpace < 0)
1008     {
1009         FREE(piDims);
1010         return -1;
1011     }
1012     //Create the dataset and write the array data to it.
1013     iCompress = enableCompression(9, _iDims, piDims);
1014     FREE(piDims);
1015     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT64, iSpace, iCompress);
1016     if (iDataset < 0)
1017     {
1018         return -1;
1019     }
1020
1021     status = H5Dwrite(iDataset, H5T_NATIVE_INT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pllData);
1022     if (status < 0)
1023     {
1024         return -1;
1025     }
1026
1027     //Add attribute SCILAB_Class = double to dataset
1028     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1029     if (status < 0)
1030     {
1031         return -1;
1032     }
1033
1034     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "64");
1035     if (status < 0)
1036     {
1037         return -1;
1038     }
1039
1040     //Close and release resources.
1041     status = H5Dclose(iDataset);
1042     if (status < 0)
1043     {
1044         return -1;
1045     }
1046
1047     status = H5Sclose(iSpace);
1048     if (status < 0)
1049     {
1050         return -1;
1051     }
1052
1053     return 0;
1054 }
1055
1056 int writeUnsignedInteger8Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned char *_pucData)
1057 {
1058     hsize_t* piDims = NULL;
1059     herr_t status = 0;
1060     hid_t iSpace = 0;
1061     hid_t iDataset = 0;
1062     hid_t iCompress = 0;
1063     int iSize = 0;
1064
1065     piDims = convertDims(_iDims, _piDims, &iSize);
1066
1067     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1068     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1069     if (iSpace < 0)
1070     {
1071         FREE(piDims);
1072         return -1;
1073     }
1074     //Create the dataset and write the array data to it.
1075     iCompress = enableCompression(9, _iDims, piDims);
1076     FREE(piDims);
1077     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT8, iSpace, iCompress);
1078     if (iDataset < 0)
1079     {
1080         return -1;
1081     }
1082
1083     status = H5Dwrite(iDataset, H5T_NATIVE_UINT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pucData);
1084     if (status < 0)
1085     {
1086         return -1;
1087     }
1088
1089     //Add attribute SCILAB_Class = double to dataset
1090     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1091     if (status < 0)
1092     {
1093         return -1;
1094     }
1095
1096     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u8");
1097     if (status < 0)
1098     {
1099         return -1;
1100     }
1101
1102     //Close and release resources.
1103     status = H5Dclose(iDataset);
1104     if (status < 0)
1105     {
1106         return -1;
1107     }
1108
1109     status = H5Sclose(iSpace);
1110     if (status < 0)
1111     {
1112         return -1;
1113     }
1114
1115     return 0;
1116 }
1117
1118 int writeUnsignedInteger16Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned short *_pusData)
1119 {
1120     hsize_t* piDims = NULL;
1121     herr_t status = 0;
1122     hid_t iSpace = 0;
1123     hid_t iDataset = 0;
1124     hid_t iCompress = 0;
1125     int iSize = 0;
1126
1127     piDims = convertDims(_iDims, _piDims, &iSize);
1128
1129     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1130     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1131     if (iSpace < 0)
1132     {
1133         FREE(piDims);
1134         return -1;
1135     }
1136     //Create the dataset and write the array data to it.
1137     iCompress = enableCompression(9, _iDims, piDims);
1138     FREE(piDims);
1139     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT16, iSpace, iCompress);
1140     if (iDataset < 0)
1141     {
1142         return -1;
1143     }
1144
1145     status = H5Dwrite(iDataset, H5T_NATIVE_UINT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pusData);
1146     if (status < 0)
1147     {
1148         return -1;
1149     }
1150
1151     //Add attribute SCILAB_Class = double to dataset
1152     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1153     if (status < 0)
1154     {
1155         return -1;
1156     }
1157
1158     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u16");
1159     if (status < 0)
1160     {
1161         return -1;
1162     }
1163
1164     //Close and release resources.
1165     status = H5Dclose(iDataset);
1166     if (status < 0)
1167     {
1168         return -1;
1169     }
1170
1171     status = H5Sclose(iSpace);
1172     if (status < 0)
1173     {
1174         return -1;
1175     }
1176
1177     return 0;
1178 }
1179
1180 int writeUnsignedInteger32Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned int *_puiData)
1181 {
1182     hsize_t* piDims = NULL;
1183     herr_t status = 0;
1184     hid_t iSpace = 0;
1185     hid_t iDataset = 0;
1186     hid_t iCompress = 0;
1187     int iSize = 0;
1188
1189     piDims = convertDims(_iDims, _piDims, &iSize);
1190
1191     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1192     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1193     if (iSpace < 0)
1194     {
1195         FREE(piDims);
1196         return -1;
1197     }
1198     //Create the dataset and write the array data to it.
1199     iCompress = enableCompression(9, _iDims, piDims);
1200     FREE(piDims);
1201     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT32, iSpace, iCompress);
1202     if (iDataset < 0)
1203     {
1204         return -1;
1205     }
1206
1207     status = H5Dwrite(iDataset, H5T_NATIVE_UINT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _puiData);
1208     if (status < 0)
1209     {
1210         return -1;
1211     }
1212
1213     //Add attribute SCILAB_Class = double to dataset
1214     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1215     if (status < 0)
1216     {
1217         return -1;
1218     }
1219
1220     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u32");
1221     if (status < 0)
1222     {
1223         return -1;
1224     }
1225
1226     //Close and release resources.
1227     status = H5Dclose(iDataset);
1228     if (status < 0)
1229     {
1230         return -1;
1231     }
1232
1233     status = H5Sclose(iSpace);
1234     if (status < 0)
1235     {
1236         return -1;
1237     }
1238
1239     return 0;
1240 }
1241
1242 int writeUnsignedInteger64Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned long long *_pullData)
1243 {
1244     hsize_t* piDims = NULL;
1245     herr_t status = 0;
1246     hid_t iSpace = 0;
1247     hid_t iDataset = 0;
1248     hid_t iCompress = 0;
1249     int iSize = 0;
1250
1251     piDims = convertDims(_iDims, _piDims, &iSize);
1252
1253     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1254     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1255     if (iSpace < 0)
1256     {
1257         FREE(piDims);
1258         return -1;
1259     }
1260     //Create the dataset and write the array data to it.
1261     iCompress = enableCompression(9, _iDims, piDims);
1262     FREE(piDims);
1263     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT64, iSpace, iCompress);
1264     if (iDataset < 0)
1265     {
1266         return -1;
1267     }
1268
1269     status = H5Dwrite(iDataset, H5T_NATIVE_UINT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pullData);
1270     if (status < 0)
1271     {
1272         return -1;
1273     }
1274
1275     //Add attribute SCILAB_Class = double to dataset
1276     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1277     if (status < 0)
1278     {
1279         return -1;
1280     }
1281
1282     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u64");
1283     if (status < 0)
1284     {
1285         return -1;
1286     }
1287
1288     //Close and release resources.
1289     status = H5Dclose(iDataset);
1290     if (status < 0)
1291     {
1292         return -1;
1293     }
1294
1295     status = H5Sclose(iSpace);
1296     if (status < 0)
1297     {
1298         return -1;
1299     }
1300
1301     return 0;
1302 }
1303
1304 int writeCommonSparseComplexMatrix(int _iFile, char *_pstDatasetName, int _iComplex, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow,
1305                                    int *_piColPos, double *_pdblReal, double *_pdblImg)
1306 {
1307     hsize_t dims[1] = { 3 };
1308     herr_t status = 0;
1309     hid_t space = 0;
1310     hid_t dset = 0;
1311     hid_t group = 0;
1312     hid_t iCompress = 0;
1313     hobj_ref_t pDataRef[3] = {0};
1314
1315     char *pstRowPath = NULL;
1316     char *pstColPath = NULL;
1317     char *pstDataPath = NULL;
1318     char *pstGroupName = NULL;
1319
1320     // Generate groupname #<dataSetName>#
1321     pstGroupName = createGroupName(_pstDatasetName);
1322
1323     //First create a group to store all referenced objects.
1324     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
1325     status = H5Gclose(group);
1326     if (status < 0)
1327     {
1328         FREE(pstGroupName);
1329         return -1;
1330     }
1331
1332     //Create each sub dataset and insert data
1333     pstRowPath = createPathName(pstGroupName, 0);
1334     status = writeInteger32Matrix(_iFile, pstRowPath, 1, &_iRows, _piNbItemRow);
1335     if (status < 0)
1336     {
1337         FREE(pstRowPath);
1338         FREE(pstGroupName);
1339         return -1;
1340     }
1341
1342     status = H5Rcreate(&pDataRef[0], _iFile, pstRowPath, H5R_OBJECT, -1);
1343     if (status < 0)
1344     {
1345         FREE(pstRowPath);
1346         FREE(pstGroupName);
1347         return -1;
1348     }
1349
1350     pstColPath = createPathName(pstGroupName, 1);
1351     status = writeInteger32Matrix(_iFile, pstColPath, 1, &_iNbItem, _piColPos);
1352     if (status < 0)
1353     {
1354         FREE(pstRowPath);
1355         FREE(pstColPath);
1356         FREE(pstGroupName);
1357         return -1;
1358     }
1359
1360     status = H5Rcreate(&pDataRef[1], _iFile, pstColPath, H5R_OBJECT, -1);
1361     if (status < 0)
1362     {
1363         FREE(pstRowPath);
1364         FREE(pstColPath);
1365         FREE(pstGroupName);
1366         return -1;
1367     }
1368
1369     pstDataPath = createPathName(pstGroupName, 2);
1370     if (_iComplex)
1371     {
1372         status = writeDoubleComplexMatrix(_iFile, pstDataPath, 1, &_iNbItem, _pdblReal, _pdblImg);
1373     }
1374     else
1375     {
1376         status = writeDoubleMatrix(_iFile, pstDataPath, 1, &_iNbItem, _pdblReal);
1377     }
1378
1379     if (status < 0)
1380     {
1381         FREE(pstRowPath);
1382         FREE(pstColPath);
1383         FREE(pstDataPath);
1384         FREE(pstGroupName);
1385         return -1;
1386     }
1387
1388     status = H5Rcreate(&pDataRef[2], _iFile, pstDataPath, H5R_OBJECT, -1);
1389     if (status < 0)
1390     {
1391         FREE(pstRowPath);
1392         FREE(pstColPath);
1393         FREE(pstDataPath);
1394         FREE(pstGroupName);
1395         return -1;
1396     }
1397
1398     //FREE group names
1399     FREE(pstRowPath);
1400     FREE(pstColPath);
1401     FREE(pstDataPath);
1402     FREE(pstGroupName);
1403
1404     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1405     space = H5Screate_simple(1, dims, NULL);
1406     if (space < 0)
1407     {
1408         return -1;
1409     }
1410
1411     //Create the dataset and write the array data to it.
1412     iCompress = enableCompression(9, 1, dims);
1413     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
1414     if (dset < 0)
1415     {
1416         return -1;
1417     }
1418
1419     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
1420     if (status < 0)
1421     {
1422         return -1;
1423     }
1424     //Add attribute SCILAB_Class = poly to dataset
1425     //sprintf(pstRow, "%d", _iRows);
1426     //sprintf(pstCol, "%d", _iCols);
1427     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_SPARSE);
1428     if (status < 0)
1429     {
1430         return -1;
1431     }
1432
1433     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
1434     if (status < 0)
1435     {
1436         return -1;
1437     }
1438
1439     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
1440     if (status < 0)
1441     {
1442         return -1;
1443     }
1444
1445     status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1446     if (status < 0)
1447     {
1448         return -1;
1449     }
1450
1451     if (_iComplex)
1452     {
1453         //Add attribute Varname attribute to dataset
1454         status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
1455         if (status < 0)
1456         {
1457             return -1;
1458         }
1459     }
1460
1461     //Close and release resources.
1462     status = H5Dclose(dset);
1463     if (status < 0)
1464     {
1465         return -1;
1466     }
1467
1468     status = H5Sclose(space);
1469     if (status < 0)
1470     {
1471         return -1;
1472     }
1473
1474     return 0;
1475 }
1476
1477 int writeSparseMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos, double *_pdblReal)
1478 {
1479     return writeCommonSparseComplexMatrix(_iFile, _pstDatasetName, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
1480 }
1481
1482 int writeSparseComplexMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos,
1483                              double *_pdblReal, double *_pdblImg)
1484 {
1485     return writeCommonSparseComplexMatrix(_iFile, _pstDatasetName, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
1486 }
1487
1488 int writeBooleanSparseMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos)
1489 {
1490     hsize_t dims[1] = { 2 };
1491     herr_t status = 0;
1492     hid_t space = 0;
1493     hid_t dset = 0;
1494     hid_t group = 0;
1495     hid_t iCompress = 0;
1496     hobj_ref_t pDataRef[2] = {0};
1497
1498     char *pstRowPath = NULL;
1499     char *pstColPath = NULL;
1500     char *pstGroupName = NULL;
1501
1502     // Generate groupname #<dataSetName>#
1503     pstGroupName = createGroupName(_pstDatasetName);
1504
1505     //First create a group to store all referenced objects.
1506     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
1507     status = H5Gclose(group);
1508     if (status < 0)
1509     {
1510         FREE(pstGroupName);
1511         return -1;
1512     }
1513
1514     //Create each sub dataset and insert data
1515     pstRowPath = createPathName(pstGroupName, 0);
1516     status = writeInteger32Matrix(_iFile, pstRowPath, 1, &_iRows, _piNbItemRow);
1517     if (status < 0)
1518     {
1519         FREE(pstRowPath);
1520         FREE(pstGroupName);
1521         return -1;
1522     }
1523
1524     status = H5Rcreate(&pDataRef[0], _iFile, pstRowPath, H5R_OBJECT, -1);
1525     if (status < 0)
1526     {
1527         FREE(pstRowPath);
1528         FREE(pstGroupName);
1529         return -1;
1530     }
1531
1532     pstColPath = createPathName(pstGroupName, 1);
1533     status = writeInteger32Matrix(_iFile, pstColPath, 1, &_iNbItem, _piColPos);
1534     if (status < 0)
1535     {
1536         FREE(pstRowPath);
1537         FREE(pstColPath);
1538         FREE(pstGroupName);
1539         return -1;
1540     }
1541
1542     status = H5Rcreate(&pDataRef[1], _iFile, pstColPath, H5R_OBJECT, -1);
1543     if (status < 0)
1544     {
1545         FREE(pstRowPath);
1546         FREE(pstColPath);
1547         FREE(pstGroupName);
1548         return -1;
1549     }
1550
1551     //FREE group names
1552     FREE(pstRowPath);
1553     FREE(pstColPath);
1554     FREE(pstGroupName);
1555
1556     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1557     space = H5Screate_simple(1, dims, NULL);
1558     if (space < 0)
1559     {
1560         return -1;
1561     }
1562
1563     //Create the dataset and write the array data to it.
1564     iCompress = enableCompression(9, 1, dims);
1565     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
1566     if (dset < 0)
1567     {
1568         return -1;
1569     }
1570
1571     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
1572     if (status < 0)
1573     {
1574         return -1;
1575     }
1576
1577     //Add attribute SCILAB_Class = boolean sparse to dataset
1578     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_BSPARSE);
1579     if (status < 0)
1580     {
1581         return -1;
1582     }
1583
1584     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
1585     if (status < 0)
1586     {
1587         return -1;
1588     }
1589
1590     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
1591     if (status < 0)
1592     {
1593         return -1;
1594     }
1595
1596     status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1597     if (status < 0)
1598     {
1599         return -1;
1600     }
1601     //Close and release resources.
1602     status = H5Dclose(dset);
1603     if (status < 0)
1604     {
1605         return -1;
1606     }
1607
1608     status = H5Sclose(space);
1609     if (status < 0)
1610     {
1611         return -1;
1612     }
1613
1614     return 0;
1615 }
1616
1617 //create a group and create hobj_ref_t array
1618 void *openList(int _iFile, char *pstDatasetName, int _iNbItem)
1619 {
1620     herr_t status = 0;
1621     hid_t group = 0;
1622     hobj_ref_t *pobjArray = NULL;
1623
1624     //First create a group to store all referenced objects.
1625     group = H5Gcreate(_iFile, pstDatasetName, H5P_DEFAULT);
1626     status = H5Gclose(group);
1627     if (status < 0)
1628     {
1629         return NULL;
1630     }
1631
1632     if (_iNbItem)
1633     {
1634         pobjArray = MALLOC(sizeof(hobj_ref_t) * _iNbItem);
1635     }
1636
1637     return pobjArray;
1638 }
1639
1640 int addItemInList(int _iFile, void *_pvList, int _iPos, char *_pstItemName)
1641 {
1642     hobj_ref_t *pobjArray = (hobj_ref_t *) _pvList;
1643
1644     return H5Rcreate(&pobjArray[_iPos], _iFile, _pstItemName, H5R_OBJECT, -1);
1645 }
1646
1647 int closeList(int _iFile, void *_pvList, char *_pstListName, int _iNbItem, int _iVarType)
1648 {
1649     herr_t status = 0;
1650     hsize_t dims[1] = { _iNbItem };
1651     hid_t space = 0;
1652     hid_t dset = 0;
1653     hid_t iCompress = 0;
1654     const char *pcstClass = NULL;
1655
1656     switch (_iVarType)
1657     {
1658         case sci_list:
1659             pcstClass = g_SCILAB_CLASS_LIST;
1660             break;
1661         case sci_tlist:
1662             pcstClass = g_SCILAB_CLASS_TLIST;
1663             break;
1664         case sci_mlist:
1665             pcstClass = g_SCILAB_CLASS_MLIST;
1666             break;
1667         default:
1668             return 1;
1669     }
1670
1671     if (_iNbItem == 0)
1672     {
1673         //tips for empty list
1674         //insert a fake refence in the array, value = 0
1675
1676         hobj_ref_t pvList[1];
1677
1678         pvList[0] = 0;
1679         //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1680
1681         dims[0] = 1;
1682         space = H5Screate_simple(1, dims, NULL);
1683         if (space < 0)
1684         {
1685             return -1;
1686         }
1687
1688         //Create the dataset and write the array data to it.
1689         iCompress = enableCompression(9, 1, dims);
1690         dset = H5Dcreate(_iFile, _pstListName, H5T_STD_REF_OBJ, space, iCompress);
1691         if (dset < 0)
1692         {
1693             return -1;
1694         }
1695
1696         status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, (hobj_ref_t *) pvList);
1697         if (status < 0)
1698         {
1699             return -1;
1700         }
1701
1702         //Add attribute SCILAB_Class = string to dataset
1703         status = addAttribute(dset, g_SCILAB_CLASS, pcstClass);
1704         if (status < 0)
1705         {
1706             return -1;
1707         }
1708
1709         status = addAttribute(dset, g_SCILAB_CLASS_EMPTY, "true");
1710         if (status < 0)
1711         {
1712             return -1;
1713         }
1714     }
1715     else
1716     {
1717         //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1718         space = H5Screate_simple(1, dims, NULL);
1719         if (status < 0)
1720         {
1721             return -1;
1722         }
1723
1724         //Create the dataset and write the array data to it.
1725         iCompress = enableCompression(9, 1, dims);
1726         dset = H5Dcreate(_iFile, _pstListName, H5T_STD_REF_OBJ, space, iCompress);
1727         if (dset < 0)
1728         {
1729             return -1;
1730         }
1731
1732         status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, (hobj_ref_t *) _pvList);
1733         if (status < 0)
1734         {
1735             return -1;
1736         }
1737
1738         //Add attribute SCILAB_Class = string to dataset
1739         status = addAttribute(dset, g_SCILAB_CLASS, pcstClass);
1740         if (status < 0)
1741         {
1742             return -1;
1743         }
1744
1745         status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1746         if (status < 0)
1747         {
1748             return -1;
1749         }
1750     }
1751
1752     //Close and release resources.
1753     status = H5Dclose(dset);
1754     if (status < 0)
1755     {
1756         return -1;
1757     }
1758
1759     status = H5Sclose(space);
1760     if (status < 0)
1761     {
1762         return -1;
1763     }
1764
1765     FREE(_pvList);
1766     return 0;
1767 }