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