Compilation: fix implicit-function-declaration and implicit-int warnings
[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  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13 *
14 */
15
16 #define H5_USE_16_API
17
18 #include <hdf5.h>
19 #include <sci_malloc.h>
20 #include <math.h>
21 #include <string.h>
22 #include <stdlib.h>
23 #include "sci_types.h"
24 #include "version.h"
25 #include "core_math.h"
26 #include "h5_writeDataToFile.h"
27 #include "h5_readDataFromFile.h"
28 #include "h5_attributeConstants.h"
29 #include "doublecomplex.h"
30
31 static hid_t enableCompression(int _iLevel, int _iRank, const hsize_t * _piDims)
32 {
33     /*hid_t iRet = 0;
34     int iLevel = _iLevel;*/
35
36     return H5P_DEFAULT;
37     /*
38       if(iLevel < 0)
39         {
40             iLevel = 0;
41         }
42
43       if(iLevel > 9)
44         {
45             iLevel = 9;
46         }
47
48         if(iLevel)
49         {
50             iRet = H5Pcreate(H5P_DATASET_CREATE);
51             if(iRet < 0)
52             {
53                 iRet = 0;
54             }
55             else
56             {
57                 if(H5Pset_layout(iRet,H5D_COMPACT)<0)
58                 {
59                     H5Pclose(iRet);
60                     iRet = 0;
61                 }
62                 else
63                 {
64                     if(H5Pset_chunk(iRet,_iRank, _piDims)<0)
65                     {
66                         H5Pclose(iRet);
67                         iRet = 0;
68                     }
69                     else
70                     {
71                         if(H5Pset_deflate(iRet,iLevel)<0)
72                         {
73                             H5Pclose(iRet);
74                             iRet = 0;
75                         }
76                     }
77                 }
78             }
79         }
80         else
81         {
82             iRet = H5Pcopy(H5P_DEFAULT);
83         }
84         return iRet;
85     */
86 }
87
88 static hsize_t* convertDims(int* _piRank, int* _piDims, int* _piSize)
89 {
90     int iSize = 1;
91     int i = 0;
92     hsize_t* piDims = (hsize_t*)malloc(sizeof(hsize_t) **_piRank);
93     for (i = 0 ; i < *_piRank ; i++)
94     {
95         //reverse dimensions to improve rendering in external tools
96         piDims[i] = _piDims[*_piRank - 1 - i];
97         iSize *= (int)piDims[i];
98     }
99     /*
100      * Fix bug under Linux due to this HDF5 error:
101      * HDF5-DIAG: Error detected in HDF5 (1.8.4-patch1) thread 140525686855488:
102      *   #000: ../../../src/H5S.c line 1335 in H5Screate_simple(): zero sized dimension for non-unlimited dimension
103      *     major: Invalid arguments to routine
104      *     minor: Bad value
105      */
106     if (iSize == 0)
107     {
108         *_piRank = 0;
109     }
110
111     *_piSize = iSize;
112     return piDims;
113 }
114
115 static herr_t addIntAttribute(int _iDatasetId, const char *_pstName, const int _iVal)
116 {
117     hsize_t attributeDims[1] = { 1 };
118     hid_t attributeTypeId, attributeSpace;
119     herr_t status;
120
121     //Create attribute dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
122     attributeSpace = H5Screate_simple(1, attributeDims, NULL);
123
124     //Create the attribute and write it.
125     attributeTypeId = H5Acreate(_iDatasetId, _pstName, H5T_NATIVE_INT, attributeSpace, H5P_DEFAULT, H5P_DEFAULT);
126     if (attributeTypeId < 0)
127     {
128         return -1;
129     }
130
131     status = H5Awrite(attributeTypeId, H5T_NATIVE_INT, &_iVal);
132     if (status < 0)
133     {
134         return -1;
135     }
136
137     //Close and release resources.
138     status = H5Aclose(attributeTypeId);
139     if (status < 0)
140     {
141         return -1;
142     }
143
144     status = H5Sclose(attributeSpace);
145     if (status < 0)
146     {
147         return -1;
148     }
149
150     return 0;
151 }
152
153 static herr_t addAttribute(int _iDatasetId, const char *_pstName, const char *_pstValue)
154 {
155     hsize_t attributeDims[1] = { 1 };
156     hid_t attributeTypeId, attributeSpace, attr;
157     herr_t status;
158
159     //Create attribute dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
160     attributeSpace = H5Screate_simple(1, attributeDims, NULL);
161
162     //Create special attribute type
163     attributeTypeId = H5Tcopy(H5T_C_S1);
164     status = H5Tset_size(attributeTypeId, strlen(_pstValue));
165     if (status < 0)
166     {
167         return -1;
168     }
169
170     //Create the attribute and write it.
171     attr = H5Acreate(_iDatasetId, _pstName, attributeTypeId, attributeSpace, H5P_DEFAULT, H5P_DEFAULT);
172     if (attr < 0)
173     {
174         return -1;
175     }
176
177     status = H5Awrite(attr, attributeTypeId, _pstValue);
178     if (status < 0)
179     {
180         return -1;
181     }
182
183     //Close and release resources.
184     status = H5Aclose(attr);
185     if (status < 0)
186     {
187         return -1;
188     }
189
190     status = H5Tclose(attributeTypeId);
191     if (status < 0)
192     {
193         return -1;
194     }
195
196     return 0;
197 }
198
199
200 int updateScilabVersion(int _iFile)
201 {
202     herr_t status;
203     //try to read attribute
204     char* pstScilabVersion = getScilabVersionAttribute(_iFile);
205     if (pstScilabVersion)
206     {
207         FREE(pstScilabVersion);
208
209         //delete before write
210         status = H5Adelete(_iFile, g_SCILAB_CLASS_SCI_VERSION);
211         if (status < 0)
212         {
213             return -1;
214         }
215     }
216
217     if (strstr(SCI_VERSION_STRING, "branch"))
218     {
219         //compiled by user
220         char pstVersion[64];
221         sprintf(pstVersion, "%s %d.%d.%d", SCI_VERSION_STRING, SCI_VERSION_MAJOR, SCI_VERSION_MINOR, SCI_VERSION_MAINTENANCE);
222         status = addAttribute(_iFile, g_SCILAB_CLASS_SCI_VERSION, pstVersion);
223     }
224     else
225     {
226         //compiled by compilation chain
227         status = addAttribute(_iFile, g_SCILAB_CLASS_SCI_VERSION, SCI_VERSION_STRING);
228     }
229
230     return status;
231 }
232
233 int updateFileVersion(int _iFile)
234 {
235     herr_t status;
236     //try to read attribute
237     int iHdf5Version = getSODFormatAttribute(_iFile);
238     if (iHdf5Version != -1)
239     {
240         status = H5Adelete(_iFile, g_SCILAB_CLASS_SOD_VERSION);
241         if (status < 0)
242         {
243             return -1;
244         }
245     }
246
247     return addIntAttribute(_iFile, g_SCILAB_CLASS_SOD_VERSION, SOD_FILE_VERSION);
248 }
249
250 int writeStringMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, char **data)
251 {
252     int iSize = 0;
253     hsize_t* piDims = NULL;
254     hid_t typeId = 0, space = 0, dset = 0;
255     herr_t status = 0;
256     hid_t iCompress = 0;
257     hid_t dprop = 0;
258
259     piDims = convertDims(&_iDims, _piDims, &iSize);
260     //Create string dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
261     space = H5Screate_simple(_iDims, piDims, NULL);
262     if (space < 0)
263     {
264         FREE(piDims);
265         return -1;
266     }
267
268     //Create special string type
269     typeId = H5Tcopy(H5T_C_S1);
270     status = H5Tset_size(typeId, H5T_VARIABLE);
271     if (status < 0)
272     {
273         FREE(piDims);
274         return -1;
275     }
276
277     //Create the data set and write it.
278     iCompress = enableCompression(9, _iDims, piDims);
279     FREE(piDims);
280
281     dprop = H5Pcreate(H5P_DATASET_CREATE);
282     H5Pset_obj_track_times(dprop, 0);
283     dset = H5Dcreate(_iFile, _pstDatasetName, typeId, space, iCompress, dprop, H5P_DEFAULT);
284     if (dset < 0)
285     {
286         return -1;
287     }
288
289     status = H5Dwrite(dset, typeId, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
290     if (status < 0)
291     {
292         return -1;
293     }
294
295     //Add attribute SCILAB_Class = string to dataset
296     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_STRING);
297     if (status < 0)
298     {
299         return -1;
300     }
301
302     //Close and release resources.
303     status = H5Dclose(dset);
304     if (status < 0)
305     {
306         return -1;
307     }
308
309     status = H5Pclose(dprop);
310     if (status < 0)
311     {
312         return -1;
313     }
314
315     status = H5Tclose(typeId);
316     if (status < 0)
317     {
318         return -1;
319     }
320
321     return 0;
322 }
323
324 char *createGroupName(const char *_pstGroupName)
325 {
326     char *pstSlash = NULL;
327     char *pstGroupName = (char *)MALLOC((strlen(_pstGroupName) + 3) * sizeof(char));
328
329     // Generate groupname #<dataSetName>#
330     sprintf(pstGroupName, "#%s#", _pstGroupName);
331     pstSlash = strstr(pstGroupName, "/");
332     if (pstSlash != NULL)
333     {
334         pstSlash[0] = '_';
335     }
336
337     return pstGroupName;
338 }
339
340 char* createPathName(char *_pstGroupName, int _iIndex)
341 {
342     char *pstName = NULL;
343     char *pstPathName = NULL;
344
345     int iNameLen = (int)log10((double)_iIndex + 1) + 1;
346     iNameLen += 2; //for both '#'
347     iNameLen += 1; //for null termanation
348
349     pstName = (char *)MALLOC(iNameLen * sizeof(char));
350     //1 for null termination, 2 for '#' characters
351     sprintf(pstName, "#%d#", _iIndex);
352
353     pstPathName = (char *)MALLOC((strlen(_pstGroupName) + strlen(pstName) + 2) * sizeof(char));
354     //1 for null termination, 1 for separator, 2 for '#' characters
355     sprintf(pstPathName, "%s/%s", _pstGroupName, pstName);
356     FREE(pstName);
357     return pstPathName;
358 }
359
360 int writeVoid(int _iFile, char *_pstDatasetName)
361 {
362     hsize_t piDims[1] = { 1 };
363     herr_t status = 0;
364     hid_t iSpace = 0;
365     hid_t iDataset = 0;
366     hid_t iCompress = 0;
367     hid_t dprop = 0;
368     char cData = 0;
369
370     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
371     iSpace = H5Screate_simple(1, piDims, NULL);
372     if (iSpace < 0)
373     {
374         return -1;
375     }
376     //Create the dataset and write the array data to it.
377     iCompress = enableCompression(9, 1, piDims);
378
379     dprop = H5Pcreate(H5P_DATASET_CREATE);
380     H5Pset_obj_track_times(dprop, 0);
381     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress, dprop, H5P_DEFAULT);
382     if (iDataset < 0)
383     {
384         return -1;
385     }
386
387     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, &cData);
388     if (status < 0)
389     {
390         return -1;
391     }
392
393     //Add attribute SCILAB_Class = double to dataset
394     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_VOID);
395     if (status < 0)
396     {
397         return -1;
398     }
399
400     //Close and release resources.
401     status = H5Dclose(iDataset);
402     if (status < 0)
403     {
404         return -1;
405     }
406
407     status = H5Pclose(dprop);
408     if (status < 0)
409     {
410         return -1;
411     }
412
413     status = H5Sclose(iSpace);
414     if (status < 0)
415     {
416         return -1;
417     }
418
419     return 0;
420 }
421
422 int writeUndefined(int _iFile, char *_pstDatasetName)
423 {
424     hsize_t piDims[1] = { 1 };
425     herr_t status = 0;
426     hid_t iSpace = 0;
427     hid_t iDataset = 0;
428     hid_t iCompress = 0;
429     hid_t dprop = 0;
430     char cData = 0;
431
432     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
433     iSpace = H5Screate_simple(1, piDims, NULL);
434     if (iSpace < 0)
435     {
436         return -1;
437     }
438     //Create the dataset and write the array data to it.
439     iCompress = enableCompression(9, 1, piDims);
440
441     dprop = H5Pcreate(H5P_DATASET_CREATE);
442     H5Pset_obj_track_times(dprop, 0);
443     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress, dprop, H5P_DEFAULT);
444     if (iDataset < 0)
445     {
446         return -1;
447     }
448
449     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, &cData);
450     if (status < 0)
451     {
452         return -1;
453     }
454
455     //Add attribute SCILAB_Class = double to dataset
456     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_UNDEFINED);
457     if (status < 0)
458     {
459         return -1;
460     }
461
462     //Close and release resources.
463     status = H5Dclose(iDataset);
464     if (status < 0)
465     {
466         return -1;
467     }
468
469     status = H5Pclose(dprop);
470     if (status < 0)
471     {
472         return -1;
473     }
474
475     status = H5Sclose(iSpace);
476     if (status < 0)
477     {
478         return -1;
479     }
480
481     return 0;
482 }
483
484 int writeDoubleMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, double *_pdblData)
485 {
486     hid_t space = 0;
487     hid_t dset = 0;
488     herr_t status = 0;
489     hsize_t *piDims = NULL;
490     hid_t iCompress = 0;
491     hid_t dprop = 0;
492     int i = 0;
493     int iSize = 0;
494
495     piDims = convertDims(&_iDims, _piDims, &iSize);
496
497     if (_iDims == 2 && piDims[0] == 0 && piDims[1] == 0)
498     {
499         // []
500         space = H5Screate_simple(0, NULL, NULL);
501         if (space < 0)
502         {
503             free(piDims);
504             return -1;
505         }
506
507         //Create the dataset and write the array data to it.
508         iCompress = enableCompression(9, _iDims, piDims);
509         free(piDims);
510
511         dprop = H5Pcreate(H5P_DATASET_CREATE);
512         H5Pset_obj_track_times(dprop, 0);
513         dset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_DOUBLE, space, iCompress, dprop, H5P_DEFAULT);
514         if (dset < 0)
515         {
516             return -1;
517         }
518
519         //Add attribute SCILAB_Class = double to dataset
520         status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
521         if (status < 0)
522         {
523             return -1;
524         }
525
526         //Close and release resources.
527         status = H5Dclose(dset);
528         if (status < 0)
529         {
530             return -1;
531         }
532
533         status = H5Pclose(dprop);
534         if (status < 0)
535         {
536             return -1;
537         }
538
539         status = H5Sclose(space);
540         if (status < 0)
541         {
542             return -1;
543         }
544         return 0;
545     }
546
547     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
548     space = H5Screate_simple(_iDims, piDims, NULL);
549     if (space < 0)
550     {
551         free(piDims);
552         return -1;
553     }
554
555     //Create the dataset and write the array data to it.
556     iCompress = enableCompression(9, _iDims, piDims);
557     free(piDims);
558
559     dprop = H5Pcreate(H5P_DATASET_CREATE);
560     H5Pset_obj_track_times(dprop, 0);
561     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_DOUBLE, space, iCompress, dprop, H5P_DEFAULT);
562     if (dset < 0)
563     {
564         return -1;
565     }
566
567     status = H5Dwrite(dset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pdblData);
568     if (status < 0)
569     {
570         return -1;
571     }
572
573     //Add attribute SCILAB_Class = double to dataset
574     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
575     if (status < 0)
576     {
577         return -1;
578     }
579
580     //Close and release resources.
581     status = H5Dclose(dset);
582     if (status < 0)
583     {
584         return -1;
585     }
586
587     status = H5Pclose(dprop);
588     if (status < 0)
589     {
590         return -1;
591     }
592
593     status = H5Sclose(space);
594     if (status < 0)
595     {
596         return -1;
597     }
598
599     return status;
600 }
601
602 int writeDoubleComplexMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, double *_pdblReal, double *_pdblImg)
603 {
604     hid_t space = 0;
605     hid_t dset = 0;
606     herr_t status = 0;
607     hsize_t *piDims = NULL;
608     hid_t iCompress = 0;
609     hid_t compoundId = 0;
610     hid_t dprop = 0;
611     int iSize = 1;
612     doublecomplex* pData = NULL;
613
614     //create sub group only for non empty matrix
615     if (_iDims == 2 && _piDims[0] == 0 && _piDims[1] == 0)
616     {
617         // [] complex
618         //a revoir
619         return -1;
620     }
621
622     compoundId = H5Tcreate (H5T_COMPOUND, sizeof(doublecomplex));
623     H5Tinsert(compoundId, "real", HOFFSET(doublecomplex, r), H5T_NATIVE_DOUBLE);
624     H5Tinsert(compoundId, "imag", HOFFSET(doublecomplex, i), H5T_NATIVE_DOUBLE);
625     piDims = convertDims(&_iDims, _piDims, &iSize);
626
627     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
628     space = H5Screate_simple(_iDims, piDims, NULL);
629     if (space < 0)
630     {
631         free(piDims);
632         return -1;
633     }
634
635     //Create the dataset and write the array data to it.
636     iCompress = enableCompression(9, _iDims, piDims);
637     free(piDims);
638
639     dprop = H5Pcreate(H5P_DATASET_CREATE);
640     H5Pset_obj_track_times(dprop, 0);
641     dset = H5Dcreate(_iFile, _pstDatasetName, compoundId, space, iCompress, dprop, H5P_DEFAULT);
642     if (dset < 0)
643     {
644         return -1;
645     }
646
647     //convert double data doublecomplex data
648     pData = oGetDoubleComplexFromPointer(_pdblReal, _pdblImg, iSize);
649     status = H5Dwrite(dset, compoundId, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
650     FREE(pData);
651     if (status < 0)
652     {
653         return -1;
654     }
655
656     //Add attribute SCILAB_Class = double to dataset
657     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
658     if (status < 0)
659     {
660         return -1;
661     }
662
663     //Close and release resources.
664     status = H5Dclose(dset);
665     if (status < 0)
666     {
667         return -1;
668     }
669
670     status = H5Pclose(dprop);
671     if (status < 0)
672     {
673         return -1;
674     }
675
676     status = H5Sclose(space);
677     if (status < 0)
678     {
679         return -1;
680     }
681
682     return status;
683 }
684
685 int writeBooleanMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, int *_piData)
686 {
687     int iSize = 0;
688     hsize_t* piDims = NULL;
689     herr_t status = 0;
690     hid_t iSpace = 0;
691     hid_t iCompress = 0;
692     hid_t iDataset = 0;
693     hid_t dprop = 0;
694
695     piDims = convertDims(&_iDims, _piDims, &iSize);
696
697     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
698     iSpace = H5Screate_simple(_iDims, piDims, NULL);
699     if (iSpace < 0)
700     {
701         return -1;
702     }
703
704     //Create the dataset and write the array data to it.
705     iCompress = enableCompression(9, _iDims, piDims);
706
707     dprop = H5Pcreate(H5P_DATASET_CREATE);
708     H5Pset_obj_track_times(dprop, 0);
709     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT, iSpace, iCompress, dprop, H5P_DEFAULT);
710     if (iDataset < 0)
711     {
712         return -1;
713     }
714
715     status = H5Dwrite(iDataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
716     if (status < 0)
717     {
718         return -1;
719     }
720
721     //Add attribute SCILAB_Class = double to dataset
722     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_BOOLEAN);
723     if (status < 0)
724     {
725         return -1;
726     }
727
728     //Close and release resources.
729     status = H5Dclose(iDataset);
730     if (status < 0)
731     {
732         return -1;
733     }
734
735     status = H5Pclose(dprop);
736     if (status < 0)
737     {
738         return -1;
739     }
740
741     status = H5Sclose(iSpace);
742     if (status < 0)
743     {
744         return -1;
745     }
746
747     return 0;
748 }
749
750 static int writeCommonPolyMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iComplex, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal, double **_pdblImg)
751 {
752     int i = 0;
753     hsize_t* piDims = NULL;
754     herr_t status = 0;
755     hid_t space = 0;
756     hid_t dset = 0;
757     hid_t group = 0;
758     hid_t iCompress = 0;
759     hid_t dprop = 0;
760     hobj_ref_t *pData = 0;
761     int iSize = 0;
762
763     char *pstPathName = NULL;
764     char *pstGroupName = NULL;
765
766     piDims = convertDims(&_iDims, _piDims, &iSize);
767     // Create ref matrix
768     pData = (hobj_ref_t *)MALLOC(iSize * sizeof(hobj_ref_t));
769
770     // Generate groupname #<dataSetName>#
771     pstGroupName = createGroupName(_pstDatasetName);
772
773     //First create a group to store all referenced objects.
774     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
775     status = H5Gclose(group);
776
777     //Now create each String as a dedicated DataSet.
778     for (i = 0 ; i < iSize ; i++)
779     {
780         pstPathName = createPathName(pstGroupName, i);
781
782         // Write the string to ref
783         if (_iComplex)
784         {
785             status = writeDoubleComplexMatrix(_iFile, pstPathName, 1, &_piNbCoef[i], _pdblReal[i], _pdblImg[i]);
786         }
787         else
788         {
789             status = writeDoubleMatrix(_iFile, pstPathName, 1, &_piNbCoef[i], _pdblReal[i]);
790         }
791
792         if (status < 0)
793         {
794             FREE(pstPathName);
795             FREE(pstGroupName);
796             FREE(pData);
797             FREE(piDims);
798             return -1;
799         }
800
801         // create the ref
802         status = H5Rcreate(&pData[i], _iFile, pstPathName, H5R_OBJECT, -1);
803         if (status < 0)
804         {
805             FREE(pstPathName);
806             FREE(pstGroupName);
807             FREE(pData);
808             FREE(piDims);
809             return -1;
810         }
811
812         FREE(pstPathName);
813     }
814
815     FREE(pstGroupName);
816     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
817     space = H5Screate_simple(_iDims, piDims, NULL);
818     if (status < 0)
819     {
820         FREE(piDims);
821         FREE(pData);
822         return -1;
823     }
824
825     //Create the dataset and write the array data to it.
826     iCompress = enableCompression(9, _iDims, piDims);
827     FREE(piDims);
828
829     dprop = H5Pcreate(H5P_DATASET_CREATE);
830     H5Pset_obj_track_times(dprop, 0);
831     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress, dprop, H5P_DEFAULT);
832     if (dset < 0)
833     {
834         FREE(pData);
835         return -1;
836     }
837
838     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
839     if (status < 0)
840     {
841         FREE(pData);
842         return -1;
843     }
844
845     FREE(pData);
846     //Add attribute SCILAB_Class = poly to dataset
847     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_POLY);
848     if (status < 0)
849     {
850         return -1;
851     }
852
853     //Add attribute Varname attribute to dataset
854     status = addAttribute(dset, g_SCILAB_CLASS_VARNAME, _pstVarName);
855     if (status < 0)
856     {
857         return -1;
858     }
859
860     if (_iComplex)
861     {
862         //Add attribute Varname attribute to dataset
863         status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
864         if (status < 0)
865         {
866             return -1;
867         }
868     }
869
870     //Close and release resources.
871     status = H5Dclose(dset);
872     if (status < 0)
873     {
874         return -1;
875     }
876
877     status = H5Pclose(dprop);
878     if (status < 0)
879     {
880         return -1;
881     }
882
883     status = H5Sclose(space);
884     if (status < 0)
885     {
886         return -1;
887     }
888
889     return 0;
890 }
891
892 int writePolyMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal)
893 {
894     return writeCommonPolyMatrix(_iFile, _pstDatasetName, _pstVarName, 0, _iDims, _piDims, _piNbCoef, _pdblReal, NULL);
895 }
896
897 int writePolyComplexMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal,
898                            double **_pdblImg)
899 {
900     return writeCommonPolyMatrix(_iFile, _pstDatasetName, _pstVarName, 1, _iDims, _piDims, _piNbCoef, _pdblReal, _pdblImg);
901 }
902
903 int writeInteger8Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, char *_pcData)
904 {
905     hsize_t* piDims = NULL;
906     herr_t status = 0;
907     hid_t iSpace = 0;
908     hid_t iDataset = 0;
909     hid_t iCompress = 0;
910     hid_t dprop = 0;
911     int iSize = 0;
912
913     piDims = convertDims(&_iDims, _piDims, &iSize);
914
915     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
916     iSpace = H5Screate_simple(_iDims, piDims, NULL);
917     if (iSpace < 0)
918     {
919         FREE(piDims);
920         return -1;
921     }
922     //Create the dataset and write the array data to it.
923     iCompress = enableCompression(9, _iDims, piDims);
924     FREE(piDims);
925
926     dprop = H5Pcreate(H5P_DATASET_CREATE);
927     H5Pset_obj_track_times(dprop, 0);
928     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress, dprop, H5P_DEFAULT);
929     if (iDataset < 0)
930     {
931         return -1;
932     }
933
934     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pcData);
935     if (status < 0)
936     {
937         return -1;
938     }
939
940     //Add attribute SCILAB_Class = double to dataset
941     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
942     if (status < 0)
943     {
944         return -1;
945     }
946
947     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "8");
948     if (status < 0)
949     {
950         return -1;
951     }
952
953     //Close and release resources.
954     status = H5Dclose(iDataset);
955     if (status < 0)
956     {
957         return -1;
958     }
959
960     status = H5Pclose(dprop);
961     if (status < 0)
962     {
963         return -1;
964     }
965
966     status = H5Sclose(iSpace);
967     if (status < 0)
968     {
969         return -1;
970     }
971
972     return 0;
973 }
974
975 int writeInteger16Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, short *_psData)
976 {
977     hsize_t* piDims = NULL;
978     herr_t status = 0;
979     hid_t iSpace = 0;
980     hid_t iDataset = 0;
981     hid_t iCompress = 0;
982     hid_t dprop = 0;
983     int iSize = 0;
984
985     piDims = convertDims(&_iDims, _piDims, &iSize);
986
987     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
988     iSpace = H5Screate_simple(_iDims, piDims, NULL);
989     if (iSpace < 0)
990     {
991         FREE(piDims);
992         return -1;
993     }
994     //Create the dataset and write the array data to it.
995     iCompress = enableCompression(9, _iDims, piDims);
996     FREE(piDims);
997
998     dprop = H5Pcreate(H5P_DATASET_CREATE);
999     H5Pset_obj_track_times(dprop, 0);
1000     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT16, iSpace, iCompress, dprop, H5P_DEFAULT);
1001     if (iDataset < 0)
1002     {
1003         return -1;
1004     }
1005     status = H5Dwrite(iDataset, H5T_NATIVE_INT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _psData);
1006     if (status < 0)
1007     {
1008         return -1;
1009     }
1010
1011     //Add attribute SCILAB_Class = double to dataset
1012     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1013     if (status < 0)
1014     {
1015         return -1;
1016     }
1017
1018     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "16");
1019     if (status < 0)
1020     {
1021         return -1;
1022     }
1023
1024     //Close and release resources.
1025     status = H5Dclose(iDataset);
1026     if (status < 0)
1027     {
1028         return -1;
1029     }
1030
1031     status = H5Pclose(dprop);
1032     if (status < 0)
1033     {
1034         return -1;
1035     }
1036
1037     status = H5Sclose(iSpace);
1038     if (status < 0)
1039     {
1040         return -1;
1041     }
1042
1043     return 0;
1044 }
1045
1046 int writeInteger32Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, int *_piData)
1047 {
1048     hsize_t* piDims = NULL;
1049     herr_t status = 0;
1050     hid_t iSpace = 0;
1051     hid_t iDataset = 0;
1052     hid_t iCompress = 0;
1053     hid_t dprop = 0;
1054     int iSize = 0;
1055
1056     piDims = convertDims(&_iDims, _piDims, &iSize);
1057
1058     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1059     iSpace = H5Screate_simple(_iDims, piDims, piDims);
1060     if (iSpace < 0)
1061     {
1062         FREE(piDims);
1063         return -1;
1064     }
1065     //Create the dataset and write the array data to it.
1066     iCompress = enableCompression(9, _iDims, piDims);
1067     FREE(piDims);
1068
1069     dprop = H5Pcreate(H5P_DATASET_CREATE);
1070     H5Pset_obj_track_times(dprop, 0);
1071     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT32, iSpace, iCompress, dprop, H5P_DEFAULT);
1072     if (iDataset < 0)
1073     {
1074         return -1;
1075     }
1076
1077     status = H5Dwrite(iDataset, H5T_NATIVE_INT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
1078     if (status < 0)
1079     {
1080         return -1;
1081     }
1082
1083     //Add attribute SCILAB_Class = double to dataset
1084     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1085     if (status < 0)
1086     {
1087         return -1;
1088     }
1089
1090     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "32");
1091     if (status < 0)
1092     {
1093         return -1;
1094     }
1095
1096     //Close and release resources.
1097     status = H5Dclose(iDataset);
1098     if (status < 0)
1099     {
1100         return -1;
1101     }
1102
1103     status = H5Pclose(dprop);
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 writeInteger64Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, long long *_pllData)
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     hid_t dprop = 0;
1126     int iSize = 0;
1127
1128     piDims = convertDims(&_iDims, _piDims, &iSize);
1129
1130     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1131     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1132     if (iSpace < 0)
1133     {
1134         FREE(piDims);
1135         return -1;
1136     }
1137     //Create the dataset and write the array data to it.
1138     iCompress = enableCompression(9, _iDims, piDims);
1139     FREE(piDims);
1140
1141     dprop = H5Pcreate(H5P_DATASET_CREATE);
1142     H5Pset_obj_track_times(dprop, 0);
1143     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT64, iSpace, iCompress, dprop, H5P_DEFAULT);
1144     if (iDataset < 0)
1145     {
1146         return -1;
1147     }
1148
1149     status = H5Dwrite(iDataset, H5T_NATIVE_INT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pllData);
1150     if (status < 0)
1151     {
1152         return -1;
1153     }
1154
1155     //Add attribute SCILAB_Class = double to dataset
1156     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1157     if (status < 0)
1158     {
1159         return -1;
1160     }
1161
1162     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "64");
1163     if (status < 0)
1164     {
1165         return -1;
1166     }
1167
1168     //Close and release resources.
1169     status = H5Dclose(iDataset);
1170     if (status < 0)
1171     {
1172         return -1;
1173     }
1174
1175     status = H5Pclose(dprop);
1176     if (status < 0)
1177     {
1178         return -1;
1179     }
1180
1181     status = H5Sclose(iSpace);
1182     if (status < 0)
1183     {
1184         return -1;
1185     }
1186
1187     return 0;
1188 }
1189
1190 int writeUnsignedInteger8Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned char *_pucData)
1191 {
1192     hsize_t* piDims = NULL;
1193     herr_t status = 0;
1194     hid_t iSpace = 0;
1195     hid_t iDataset = 0;
1196     hid_t iCompress = 0;
1197     hid_t dprop = 0;
1198     int iSize = 0;
1199
1200     piDims = convertDims(&_iDims, _piDims, &iSize);
1201
1202     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1203     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1204     if (iSpace < 0)
1205     {
1206         FREE(piDims);
1207         return -1;
1208     }
1209     //Create the dataset and write the array data to it.
1210     iCompress = enableCompression(9, _iDims, piDims);
1211     FREE(piDims);
1212
1213     dprop = H5Pcreate(H5P_DATASET_CREATE);
1214     H5Pset_obj_track_times(dprop, 0);
1215     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT8, iSpace, iCompress, dprop, H5P_DEFAULT);
1216     if (iDataset < 0)
1217     {
1218         return -1;
1219     }
1220
1221     status = H5Dwrite(iDataset, H5T_NATIVE_UINT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pucData);
1222     if (status < 0)
1223     {
1224         return -1;
1225     }
1226
1227     //Add attribute SCILAB_Class = double to dataset
1228     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1229     if (status < 0)
1230     {
1231         return -1;
1232     }
1233
1234     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u8");
1235     if (status < 0)
1236     {
1237         return -1;
1238     }
1239
1240     //Close and release resources.
1241     status = H5Dclose(iDataset);
1242     if (status < 0)
1243     {
1244         return -1;
1245     }
1246
1247     status = H5Pclose(dprop);
1248     if (status < 0)
1249     {
1250         return -1;
1251     }
1252
1253     status = H5Sclose(iSpace);
1254     if (status < 0)
1255     {
1256         return -1;
1257     }
1258
1259     return 0;
1260 }
1261
1262 int writeUnsignedInteger16Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned short *_pusData)
1263 {
1264     hsize_t* piDims = NULL;
1265     herr_t status = 0;
1266     hid_t iSpace = 0;
1267     hid_t iDataset = 0;
1268     hid_t iCompress = 0;
1269     hid_t dprop = 0;
1270     int iSize = 0;
1271
1272     piDims = convertDims(&_iDims, _piDims, &iSize);
1273
1274     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1275     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1276     if (iSpace < 0)
1277     {
1278         FREE(piDims);
1279         return -1;
1280     }
1281     //Create the dataset and write the array data to it.
1282     iCompress = enableCompression(9, _iDims, piDims);
1283     FREE(piDims);
1284
1285     dprop = H5Pcreate(H5P_DATASET_CREATE);
1286     H5Pset_obj_track_times(dprop, 0);
1287     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT16, iSpace, iCompress, dprop, H5P_DEFAULT);
1288     if (iDataset < 0)
1289     {
1290         return -1;
1291     }
1292
1293     status = H5Dwrite(iDataset, H5T_NATIVE_UINT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pusData);
1294     if (status < 0)
1295     {
1296         return -1;
1297     }
1298
1299     //Add attribute SCILAB_Class = double to dataset
1300     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1301     if (status < 0)
1302     {
1303         return -1;
1304     }
1305
1306     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u16");
1307     if (status < 0)
1308     {
1309         return -1;
1310     }
1311
1312     //Close and release resources.
1313     status = H5Dclose(iDataset);
1314     if (status < 0)
1315     {
1316         return -1;
1317     }
1318
1319     status = H5Pclose(dprop);
1320     if (status < 0)
1321     {
1322         return -1;
1323     }
1324
1325     status = H5Sclose(iSpace);
1326     if (status < 0)
1327     {
1328         return -1;
1329     }
1330
1331     return 0;
1332 }
1333
1334 int writeUnsignedInteger32Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned int *_puiData)
1335 {
1336     hsize_t* piDims = NULL;
1337     herr_t status = 0;
1338     hid_t iSpace = 0;
1339     hid_t iDataset = 0;
1340     hid_t iCompress = 0;
1341     hid_t dprop = 0;
1342     int iSize = 0;
1343
1344     piDims = convertDims(&_iDims, _piDims, &iSize);
1345
1346     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1347     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1348     if (iSpace < 0)
1349     {
1350         FREE(piDims);
1351         return -1;
1352     }
1353     //Create the dataset and write the array data to it.
1354     iCompress = enableCompression(9, _iDims, piDims);
1355     FREE(piDims);
1356
1357     dprop = H5Pcreate(H5P_DATASET_CREATE);
1358     H5Pset_obj_track_times(dprop, 0);
1359     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT32, iSpace, iCompress, dprop, H5P_DEFAULT);
1360     if (iDataset < 0)
1361     {
1362         return -1;
1363     }
1364
1365     status = H5Dwrite(iDataset, H5T_NATIVE_UINT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _puiData);
1366     if (status < 0)
1367     {
1368         return -1;
1369     }
1370
1371     //Add attribute SCILAB_Class = double to dataset
1372     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1373     if (status < 0)
1374     {
1375         return -1;
1376     }
1377
1378     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u32");
1379     if (status < 0)
1380     {
1381         return -1;
1382     }
1383
1384     //Close and release resources.
1385     status = H5Dclose(iDataset);
1386     if (status < 0)
1387     {
1388         return -1;
1389     }
1390
1391     status = H5Pclose(dprop);
1392     if (status < 0)
1393     {
1394         return -1;
1395     }
1396
1397     status = H5Sclose(iSpace);
1398     if (status < 0)
1399     {
1400         return -1;
1401     }
1402
1403     return 0;
1404 }
1405
1406 int writeUnsignedInteger64Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned long long *_pullData)
1407 {
1408     hsize_t* piDims = NULL;
1409     herr_t status = 0;
1410     hid_t iSpace = 0;
1411     hid_t iDataset = 0;
1412     hid_t iCompress = 0;
1413     hid_t dprop = 0;
1414     int iSize = 0;
1415
1416     piDims = convertDims(&_iDims, _piDims, &iSize);
1417
1418     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1419     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1420     if (iSpace < 0)
1421     {
1422         FREE(piDims);
1423         return -1;
1424     }
1425     //Create the dataset and write the array data to it.
1426     iCompress = enableCompression(9, _iDims, piDims);
1427     FREE(piDims);
1428
1429     dprop = H5Pcreate(H5P_DATASET_CREATE);
1430     H5Pset_obj_track_times(dprop, 0);
1431     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT64, iSpace, iCompress, dprop, H5P_DEFAULT);
1432     if (iDataset < 0)
1433     {
1434         return -1;
1435     }
1436
1437     status = H5Dwrite(iDataset, H5T_NATIVE_UINT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pullData);
1438     if (status < 0)
1439     {
1440         return -1;
1441     }
1442
1443     //Add attribute SCILAB_Class = double to dataset
1444     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1445     if (status < 0)
1446     {
1447         return -1;
1448     }
1449
1450     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u64");
1451     if (status < 0)
1452     {
1453         return -1;
1454     }
1455
1456     //Close and release resources.
1457     status = H5Dclose(iDataset);
1458     if (status < 0)
1459     {
1460         return -1;
1461     }
1462
1463     status = H5Pclose(dprop);
1464     if (status < 0)
1465     {
1466         return -1;
1467     }
1468
1469     status = H5Sclose(iSpace);
1470     if (status < 0)
1471     {
1472         return -1;
1473     }
1474
1475     return 0;
1476 }
1477
1478 int writeCommonSparseComplexMatrix(int _iFile, char *_pstDatasetName, int _iComplex, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow,
1479                                    int *_piColPos, double *_pdblReal, double *_pdblImg)
1480 {
1481     hsize_t dims[1] = { 3 };
1482     herr_t status = 0;
1483     hid_t space = 0;
1484     hid_t dset = 0;
1485     hid_t group = 0;
1486     hid_t iCompress = 0;
1487     hid_t dprop = 0;
1488     hobj_ref_t pDataRef[3] = {0};
1489
1490     char *pstRowPath = NULL;
1491     char *pstColPath = NULL;
1492     char *pstDataPath = NULL;
1493     char *pstGroupName = NULL;
1494
1495     // Generate groupname #<dataSetName>#
1496     pstGroupName = createGroupName(_pstDatasetName);
1497
1498     //First create a group to store all referenced objects.
1499     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
1500     status = H5Gclose(group);
1501     if (status < 0)
1502     {
1503         FREE(pstGroupName);
1504         return -1;
1505     }
1506
1507     //Create each sub dataset and insert data
1508     pstRowPath = createPathName(pstGroupName, 0);
1509     status = writeInteger32Matrix(_iFile, pstRowPath, 1, &_iRows, _piNbItemRow);
1510     if (status < 0)
1511     {
1512         FREE(pstRowPath);
1513         FREE(pstGroupName);
1514         return -1;
1515     }
1516
1517     status = H5Rcreate(&pDataRef[0], _iFile, pstRowPath, H5R_OBJECT, -1);
1518     if (status < 0)
1519     {
1520         FREE(pstRowPath);
1521         FREE(pstGroupName);
1522         return -1;
1523     }
1524
1525     pstColPath = createPathName(pstGroupName, 1);
1526     status = writeInteger32Matrix(_iFile, pstColPath, 1, &_iNbItem, _piColPos);
1527     if (status < 0)
1528     {
1529         FREE(pstRowPath);
1530         FREE(pstColPath);
1531         FREE(pstGroupName);
1532         return -1;
1533     }
1534
1535     status = H5Rcreate(&pDataRef[1], _iFile, pstColPath, H5R_OBJECT, -1);
1536     if (status < 0)
1537     {
1538         FREE(pstRowPath);
1539         FREE(pstColPath);
1540         FREE(pstGroupName);
1541         return -1;
1542     }
1543
1544     pstDataPath = createPathName(pstGroupName, 2);
1545     if (_iComplex)
1546     {
1547         status = writeDoubleComplexMatrix(_iFile, pstDataPath, 1, &_iNbItem, _pdblReal, _pdblImg);
1548     }
1549     else
1550     {
1551         status = writeDoubleMatrix(_iFile, pstDataPath, 1, &_iNbItem, _pdblReal);
1552     }
1553
1554     if (status < 0)
1555     {
1556         FREE(pstRowPath);
1557         FREE(pstColPath);
1558         FREE(pstDataPath);
1559         FREE(pstGroupName);
1560         return -1;
1561     }
1562
1563     status = H5Rcreate(&pDataRef[2], _iFile, pstDataPath, H5R_OBJECT, -1);
1564     if (status < 0)
1565     {
1566         FREE(pstRowPath);
1567         FREE(pstColPath);
1568         FREE(pstDataPath);
1569         FREE(pstGroupName);
1570         return -1;
1571     }
1572
1573     //FREE group names
1574     FREE(pstRowPath);
1575     FREE(pstColPath);
1576     FREE(pstDataPath);
1577     FREE(pstGroupName);
1578
1579     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1580     space = H5Screate_simple(1, dims, NULL);
1581     if (space < 0)
1582     {
1583         return -1;
1584     }
1585
1586     //Create the dataset and write the array data to it.
1587     iCompress = enableCompression(9, 1, dims);
1588
1589     dprop = H5Pcreate(H5P_DATASET_CREATE);
1590     H5Pset_obj_track_times(dprop, 0);
1591     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress, dprop, H5P_DEFAULT);
1592     if (dset < 0)
1593     {
1594         return -1;
1595     }
1596
1597     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
1598     if (status < 0)
1599     {
1600         return -1;
1601     }
1602     //Add attribute SCILAB_Class = poly to dataset
1603     //sprintf(pstRow, "%d", _iRows);
1604     //sprintf(pstCol, "%d", _iCols);
1605     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_SPARSE);
1606     if (status < 0)
1607     {
1608         return -1;
1609     }
1610
1611     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
1612     if (status < 0)
1613     {
1614         return -1;
1615     }
1616
1617     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
1618     if (status < 0)
1619     {
1620         return -1;
1621     }
1622
1623     status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1624     if (status < 0)
1625     {
1626         return -1;
1627     }
1628
1629     if (_iComplex)
1630     {
1631         //Add attribute Varname attribute to dataset
1632         status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
1633         if (status < 0)
1634         {
1635             return -1;
1636         }
1637     }
1638
1639     //Close and release resources.
1640     status = H5Dclose(dset);
1641     if (status < 0)
1642     {
1643         return -1;
1644     }
1645
1646     status = H5Pclose(dprop);
1647     if (status < 0)
1648     {
1649         return -1;
1650     }
1651
1652     status = H5Sclose(space);
1653     if (status < 0)
1654     {
1655         return -1;
1656     }
1657
1658     return 0;
1659 }
1660
1661 int writeSparseMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos, double *_pdblReal)
1662 {
1663     return writeCommonSparseComplexMatrix(_iFile, _pstDatasetName, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
1664 }
1665
1666 int writeSparseComplexMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos,
1667                              double *_pdblReal, double *_pdblImg)
1668 {
1669     return writeCommonSparseComplexMatrix(_iFile, _pstDatasetName, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
1670 }
1671
1672 int writeBooleanSparseMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos)
1673 {
1674     hsize_t dims[1] = { 2 };
1675     herr_t status = 0;
1676     hid_t space = 0;
1677     hid_t dset = 0;
1678     hid_t group = 0;
1679     hid_t iCompress = 0;
1680     hid_t dprop = 0;
1681     hobj_ref_t pDataRef[2] = {0};
1682
1683     char *pstRowPath = NULL;
1684     char *pstColPath = NULL;
1685     char *pstGroupName = NULL;
1686
1687     // Generate groupname #<dataSetName>#
1688     pstGroupName = createGroupName(_pstDatasetName);
1689
1690     //First create a group to store all referenced objects.
1691     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
1692     status = H5Gclose(group);
1693     if (status < 0)
1694     {
1695         FREE(pstGroupName);
1696         return -1;
1697     }
1698
1699     //Create each sub dataset and insert data
1700     pstRowPath = createPathName(pstGroupName, 0);
1701     status = writeInteger32Matrix(_iFile, pstRowPath, 1, &_iRows, _piNbItemRow);
1702     if (status < 0)
1703     {
1704         FREE(pstRowPath);
1705         FREE(pstGroupName);
1706         return -1;
1707     }
1708
1709     status = H5Rcreate(&pDataRef[0], _iFile, pstRowPath, H5R_OBJECT, -1);
1710     if (status < 0)
1711     {
1712         FREE(pstRowPath);
1713         FREE(pstGroupName);
1714         return -1;
1715     }
1716
1717     pstColPath = createPathName(pstGroupName, 1);
1718     if (_iNbItem != 0)
1719     {
1720         status = writeInteger32Matrix(_iFile, pstColPath, 1, &_iNbItem, _piColPos);
1721         if (status < 0)
1722         {
1723             FREE(pstRowPath);
1724             FREE(pstColPath);
1725             FREE(pstGroupName);
1726             return -1;
1727         }
1728
1729         status = H5Rcreate(&pDataRef[1], _iFile, pstColPath, H5R_OBJECT, -1);
1730         if (status < 0)
1731         {
1732             FREE(pstRowPath);
1733             FREE(pstColPath);
1734             FREE(pstGroupName);
1735             return -1;
1736         }
1737     }
1738     else
1739     {
1740         dims[0] = 1;
1741     }
1742
1743
1744     //FREE group names
1745     FREE(pstRowPath);
1746     FREE(pstColPath);
1747     FREE(pstGroupName);
1748
1749     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1750     space = H5Screate_simple(1, dims, NULL);
1751     if (space < 0)
1752     {
1753         return -1;
1754     }
1755
1756     //Create the dataset and write the array data to it.
1757     iCompress = enableCompression(9, 1, dims);
1758
1759     dprop = H5Pcreate(H5P_DATASET_CREATE);
1760     H5Pset_obj_track_times(dprop, 0);
1761     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress, dprop, H5P_DEFAULT);
1762     if (dset < 0)
1763     {
1764         return -1;
1765     }
1766
1767     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
1768     if (status < 0)
1769     {
1770         return -1;
1771     }
1772
1773     //Add attribute SCILAB_Class = boolean sparse to dataset
1774     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_BSPARSE);
1775     if (status < 0)
1776     {
1777         return -1;
1778     }
1779
1780     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
1781     if (status < 0)
1782     {
1783         return -1;
1784     }
1785
1786     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
1787     if (status < 0)
1788     {
1789         return -1;
1790     }
1791
1792     status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1793     if (status < 0)
1794     {
1795         return -1;
1796     }
1797     //Close and release resources.
1798     status = H5Dclose(dset);
1799     if (status < 0)
1800     {
1801         return -1;
1802     }
1803
1804     status = H5Pclose(dprop);
1805     if (status < 0)
1806     {
1807         return -1;
1808     }
1809
1810     status = H5Sclose(space);
1811     if (status < 0)
1812     {
1813         return -1;
1814     }
1815
1816     return 0;
1817 }
1818
1819 //create a group and create hobj_ref_t array
1820 void *openList(int _iFile, char *pstDatasetName, int _iNbItem)
1821 {
1822     herr_t status = 0;
1823     hid_t group = 0;
1824     hobj_ref_t *pobjArray = NULL;
1825
1826     //First create a group to store all referenced objects.
1827     group = H5Gcreate(_iFile, pstDatasetName, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
1828     status = H5Gclose(group);
1829     if (status < 0)
1830     {
1831         return NULL;
1832     }
1833
1834     if (_iNbItem)
1835     {
1836         pobjArray = (hobj_ref_t*)MALLOC(sizeof(hobj_ref_t) * _iNbItem);
1837     }
1838
1839     return pobjArray;
1840 }
1841
1842 int addItemInList(int _iFile, void *_pvList, int _iPos, char *_pstItemName)
1843 {
1844     hobj_ref_t *pobjArray = (hobj_ref_t *) _pvList;
1845
1846     return H5Rcreate(&pobjArray[_iPos], _iFile, _pstItemName, H5R_OBJECT, -1);
1847 }
1848
1849 int closeList(int _iFile, void *_pvList, char *_pstListName, int _iNbItem, int _iVarType)
1850 {
1851     herr_t status = 0;
1852     hsize_t dims[1] = { _iNbItem };
1853     hid_t space = 0;
1854     hid_t dset = 0;
1855     hid_t dprop = 0;
1856     hid_t iCompress = 0;
1857     const char *pcstClass = NULL;
1858
1859     switch (_iVarType)
1860     {
1861         case sci_list:
1862             pcstClass = g_SCILAB_CLASS_LIST;
1863             break;
1864         case sci_tlist:
1865             pcstClass = g_SCILAB_CLASS_TLIST;
1866             break;
1867         case sci_mlist:
1868             pcstClass = g_SCILAB_CLASS_MLIST;
1869             break;
1870         default:
1871             return 1;
1872     }
1873
1874     dprop = H5Pcreate(H5P_DATASET_CREATE);
1875     H5Pset_obj_track_times(dprop, 0);
1876     if (_iNbItem == 0)
1877     {
1878         //tips for empty list
1879         //insert a fake refence in the array, value = 0
1880
1881         hobj_ref_t pvList[1];
1882
1883         pvList[0] = 0;
1884         //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1885
1886         dims[0] = 1;
1887         space = H5Screate_simple(1, dims, NULL);
1888         if (space < 0)
1889         {
1890             return -1;
1891         }
1892
1893         //Create the dataset and write the array data to it.
1894         iCompress = enableCompression(9, 1, dims);
1895
1896         dset = H5Dcreate(_iFile, _pstListName, H5T_STD_REF_OBJ, space, iCompress, dprop, H5P_DEFAULT);
1897         if (dset < 0)
1898         {
1899             return -1;
1900         }
1901
1902         status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, (hobj_ref_t *) pvList);
1903         if (status < 0)
1904         {
1905             return -1;
1906         }
1907
1908         //Add attribute SCILAB_Class = string to dataset
1909         status = addAttribute(dset, g_SCILAB_CLASS, pcstClass);
1910         if (status < 0)
1911         {
1912             return -1;
1913         }
1914
1915         status = addAttribute(dset, g_SCILAB_CLASS_EMPTY, "true");
1916         if (status < 0)
1917         {
1918             return -1;
1919         }
1920     }
1921     else
1922     {
1923         //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1924         space = H5Screate_simple(1, dims, NULL);
1925         if (space < 0)
1926         {
1927             return -1;
1928         }
1929
1930         //Create the dataset and write the array data to it.
1931         iCompress = enableCompression(9, 1, dims);
1932
1933         dset = H5Dcreate(_iFile, _pstListName, H5T_STD_REF_OBJ, space, iCompress, dprop, H5P_DEFAULT);
1934         if (dset < 0)
1935         {
1936             return -1;
1937         }
1938
1939         status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, (hobj_ref_t *) _pvList);
1940         if (status < 0)
1941         {
1942             return -1;
1943         }
1944
1945         //Add attribute SCILAB_Class = string to dataset
1946         status = addAttribute(dset, g_SCILAB_CLASS, pcstClass);
1947         if (status < 0)
1948         {
1949             return -1;
1950         }
1951
1952         status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1953         if (status < 0)
1954         {
1955             return -1;
1956         }
1957     }
1958
1959     //Close and release resources.
1960     status = H5Dclose(dset);
1961     if (status < 0)
1962     {
1963         return -1;
1964     }
1965
1966     status = H5Pclose(dprop);
1967     if (status < 0)
1968     {
1969         return -1;
1970     }
1971
1972     status = H5Sclose(space);
1973     if (status < 0)
1974     {
1975         return -1;
1976     }
1977
1978     FREE(_pvList);
1979     return 0;
1980 }
1981
1982 static int deleteHDF5group(int _iFile, const char* _pstName)
1983 {
1984     H5G_info_t groupInfo;
1985     hid_t status = 0;
1986     //open group
1987     hid_t groupID = H5Gopen(_iFile, _pstName, H5P_DEFAULT);
1988     //hid_t groupID = H5Gopen(_iFile, _pstName, H5P_DEFAULT);
1989
1990     if (groupID < 0)
1991     {
1992         return -1;
1993     }
1994
1995     //get children count
1996     status = H5Gget_info(groupID, &groupInfo);
1997     if (status != -1)
1998     {
1999         int index = 0;
2000         int i = 0;
2001
2002         //for each child,
2003         for (i = 0; i < groupInfo.nlinks; i++)
2004         {
2005             int ret = 0;
2006             //get child name
2007             ssize_t size = H5Lget_name_by_idx(groupID, ".", H5_INDEX_NAME, H5_ITER_INC, index, 0, 0, H5P_DEFAULT) + 1;
2008             char* pstChildName = (char*)MALLOC(sizeof(char) * size);
2009             H5Lget_name_by_idx(groupID, ".", H5_INDEX_NAME, H5_ITER_INC, index, pstChildName, size, H5P_DEFAULT);
2010             ret = deleteHDF5group(groupID, pstChildName);
2011             if (ret == -1)
2012             {
2013                 ++index;
2014             }
2015             ////unlink child
2016             //status = H5Ldelete(groupID, pstChildName, H5P_DEFAULT);
2017             FREE(pstChildName);
2018
2019             //if (status < 0)
2020             //{
2021             //    return -1;
2022             //}
2023         }
2024     }
2025
2026     //close group
2027     status = closeList6(groupID);
2028     if (status < 0)
2029     {
2030         return -1;
2031     }
2032
2033     //delete group
2034     status = H5Ldelete(_iFile, _pstName, H5P_DEFAULT);
2035     if (status < 0)
2036     {
2037         return -1;
2038     }
2039
2040     return 0;
2041 }
2042
2043 //According to 5.5.2. Deleting a Dataset from a File and Reclaiming Space of http://www.hdfgroup.org/HDF5/doc/UG/10_Datasets.html
2044 //it is actually impossible to really remove data from HDF5 file so unlink dataset to main group
2045 int deleteHDF5Var(int _iFile, const char* _pstName)
2046 {
2047     int ret = 0;
2048     void *oldclientdata = NULL;
2049     H5E_auto2_t oldfunc;
2050
2051     /* Save old error handler */
2052     H5Eget_auto2(H5E_DEFAULT, &oldfunc, &oldclientdata);
2053
2054     /* Turn off error handling */
2055     H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
2056
2057     //try to unlink potential subgroups
2058     ret = deleteHDF5group(_iFile, _pstName);
2059     if (ret == -1)
2060     {
2061         //delete current dataset link
2062         hid_t status = H5Ldelete(_iFile, _pstName, H5P_DEFAULT);
2063         if (status < 0)
2064         {
2065             H5Eset_auto2(H5E_DEFAULT, oldfunc, oldclientdata);
2066             return -1;
2067         }
2068         ret = 0;
2069     }
2070
2071     H5Eset_auto2(H5E_DEFAULT, oldfunc, oldclientdata);
2072     return ret;
2073 }
2074
2075 /*Scilab 6*/
2076 int writeDoubleMatrix6(int parent, const char* name, int dims, int* pdims, double* data)
2077 {
2078     hid_t space = 0;
2079     hid_t dset = 0;
2080     herr_t status = 0;
2081     hsize_t *piDims = NULL;
2082     hid_t iCompress = 0;
2083     int i = 0;
2084     int iSize = 0;
2085     hid_t dprop = 0;
2086
2087     piDims = convertDims(&dims, pdims, &iSize);
2088
2089     if (dims == 0 || (dims == 2 && pdims[0] == 0 && pdims[1] == 0))
2090     {
2091         // []
2092         space = H5Screate_simple(0, NULL, NULL);
2093         if (space < 0)
2094         {
2095             free(piDims);
2096             return -1;
2097         }
2098
2099         //Create the dataset and write the array data to it.
2100         iCompress = enableCompression(9, dims, piDims);
2101         free(piDims);
2102
2103         dprop = H5Pcreate(H5P_DATASET_CREATE);
2104         H5Pset_obj_track_times(dprop, 0);
2105         dset = H5Dcreate(parent, name, H5T_NATIVE_DOUBLE, space, iCompress, dprop, H5P_DEFAULT);
2106         if (dset < 0)
2107         {
2108             return -1;
2109         }
2110     }
2111     else
2112     {
2113         //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
2114         space = H5Screate_simple(dims, piDims, NULL);
2115         if (space < 0)
2116         {
2117             free(piDims);
2118             return -1;
2119         }
2120
2121         //Create the dataset and write the array data to it.
2122         iCompress = enableCompression(9, dims, piDims);
2123         free(piDims);
2124
2125         dprop = H5Pcreate(H5P_DATASET_CREATE);
2126         H5Pset_obj_track_times(dprop, 0);
2127         dset = H5Dcreate(parent, name, H5T_NATIVE_DOUBLE, space, iCompress, dprop, H5P_DEFAULT);
2128         if (dset < 0)
2129         {
2130             return -1;
2131         }
2132
2133         status = H5Dwrite(dset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
2134         if (status < 0)
2135         {
2136             return -1;
2137         }
2138     }
2139
2140     //Add attribute SCILAB_Class = double to dataset
2141     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
2142     if (status < 0)
2143     {
2144         return -1;
2145     }
2146
2147     //Close and release resources.
2148     status = H5Dclose(dset);
2149     if (status < 0)
2150     {
2151         return -1;
2152     }
2153
2154     status = H5Pclose(dprop);
2155     if (status < 0)
2156     {
2157         return -1;
2158     }
2159
2160     status = H5Sclose(space);
2161     if (status < 0)
2162     {
2163         return -1;
2164     }
2165
2166     return dset;
2167 }
2168
2169 hid_t writeDoubleComplexMatrix6(int parent, const char* name, int dims, int* pdims, double* real, double* img)
2170 {
2171     hid_t space = 0;
2172     hid_t dset = 0;
2173     herr_t status = 0;
2174     hsize_t *piDims = NULL;
2175     hid_t iCompress = 0;
2176     hid_t compoundId = 0;
2177     hid_t dprop = 0;
2178     int iSize = 1;
2179     doublecomplex* pData = NULL;
2180
2181     //create sub group only for non empty matrix
2182     if (dims == 2 && pdims[0] == 0 && pdims[1] == 0)
2183     {
2184         // [] complex
2185         //a revoir
2186         return -1;
2187     }
2188
2189     compoundId = H5Tcreate(H5T_COMPOUND, sizeof(doublecomplex));
2190     H5Tinsert(compoundId, "real", HOFFSET(doublecomplex, r), H5T_NATIVE_DOUBLE);
2191     H5Tinsert(compoundId, "imag", HOFFSET(doublecomplex, i), H5T_NATIVE_DOUBLE);
2192     piDims = convertDims(&dims, pdims, &iSize);
2193
2194     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
2195     space = H5Screate_simple(dims, piDims, NULL);
2196     if (space < 0)
2197     {
2198         free(piDims);
2199         return -1;
2200     }
2201
2202     //Create the dataset and write the array data to it.
2203     iCompress = enableCompression(9, dims, piDims);
2204     free(piDims);
2205
2206     dprop = H5Pcreate(H5P_DATASET_CREATE);
2207     H5Pset_obj_track_times(dprop, 0);
2208     dset = H5Dcreate(parent, name, compoundId, space, iCompress, dprop, H5P_DEFAULT);
2209     if (dset < 0)
2210     {
2211         return -1;
2212     }
2213
2214     //convert double data doublecomplex data
2215     pData = oGetDoubleComplexFromPointer(real, img, iSize);
2216     status = H5Dwrite(dset, compoundId, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
2217     FREE(pData);
2218     if (status < 0)
2219     {
2220         return -1;
2221     }
2222
2223     //Add attribute SCILAB_Class = double to dataset
2224     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
2225     if (status < 0)
2226     {
2227         return -1;
2228     }
2229
2230     //Close and release resources.
2231     status = H5Dclose(dset);
2232     if (status < 0)
2233     {
2234         return -1;
2235     }
2236
2237     status = H5Pclose(dprop);
2238     if (status < 0)
2239     {
2240         return -1;
2241     }
2242
2243     status = H5Sclose(space);
2244     if (status < 0)
2245     {
2246         return -1;
2247     }
2248
2249     return dset;
2250 }
2251
2252 int writeStringMatrix6(int parent, const char* name, int dims, int* pdims, char** data)
2253 {
2254     int iSize = 0;
2255     hsize_t* piDims = NULL;
2256     hid_t typeId = 0, space = 0, dset = 0, dprop = 0;
2257     herr_t status;
2258     hid_t iCompress;
2259
2260     piDims = convertDims(&dims, pdims, &iSize);
2261
2262     //Create special string type
2263     typeId = H5Tcopy(H5T_C_S1);
2264     status = H5Tset_size(typeId, H5T_VARIABLE);
2265     if (status < 0)
2266     {
2267         FREE(piDims);
2268         return -1;
2269     }
2270
2271     if (dims == 0 || (dims == 2 && pdims[0] == 0 && pdims[1] == 0))
2272     {
2273         // []
2274         space = H5Screate_simple(0, NULL, NULL);
2275         if (space < 0)
2276         {
2277             free(piDims);
2278             return -1;
2279         }
2280
2281         //Create the dataset and write the array data to it.
2282         iCompress = enableCompression(9, dims, piDims);
2283         free(piDims);
2284
2285         dprop = H5Pcreate(H5P_DATASET_CREATE);
2286         H5Pset_obj_track_times(dprop, 0);
2287         dset = H5Dcreate(parent, name, typeId, space, iCompress, dprop, H5P_DEFAULT);
2288         if (dset < 0)
2289         {
2290             return -1;
2291         }
2292     }
2293     else
2294     {
2295         //Create string dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
2296         space = H5Screate_simple(dims, piDims, NULL);
2297         if (space < 0)
2298         {
2299             FREE(piDims);
2300             return -1;
2301         }
2302
2303         //Create the data set and write it.
2304         iCompress = enableCompression(9, dims, piDims);
2305         FREE(piDims);
2306
2307         dprop = H5Pcreate(H5P_DATASET_CREATE);
2308         H5Pset_obj_track_times(dprop, 0);
2309         dset = H5Dcreate(parent, name, typeId, space, iCompress, dprop, H5P_DEFAULT);
2310         if (dset < 0)
2311         {
2312             return -1;
2313         }
2314
2315         status = H5Dwrite(dset, typeId, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
2316         if (status < 0)
2317         {
2318             return -1;
2319         }
2320     }
2321
2322     //Add attribute SCILAB_Class = string to dataset
2323     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_STRING);
2324     if (status < 0)
2325     {
2326         return -1;
2327     }
2328
2329     //Close and release resources.
2330     status = H5Dclose(dset);
2331     if (status < 0)
2332     {
2333         return -1;
2334     }
2335
2336     status = H5Pclose(dprop);
2337     if (status < 0)
2338     {
2339         return -1;
2340     }
2341
2342     status = H5Tclose(typeId);
2343     if (status < 0)
2344     {
2345         return -1;
2346     }
2347
2348     return dset;
2349 }
2350
2351 int writeBooleanMatrix6(int parent, const char* name, int dims, int* pdims, int* data)
2352 {
2353     int iSize = 0;
2354     hsize_t* piDims = NULL;
2355     herr_t status = 0;
2356     hid_t iSpace = 0;
2357     hid_t iCompress = 0;
2358     hid_t dset = 0;
2359     hid_t dprop = 0;
2360
2361     piDims = convertDims(&dims, pdims, &iSize);
2362
2363     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
2364     iSpace = H5Screate_simple(dims, piDims, NULL);
2365     if (iSpace < 0)
2366     {
2367         FREE(piDims);
2368         return -1;
2369     }
2370
2371     //Create the dataset and write the array data to it.
2372     iCompress = enableCompression(9, dims, piDims);
2373     FREE(piDims);
2374
2375     dprop = H5Pcreate(H5P_DATASET_CREATE);
2376     H5Pset_obj_track_times(dprop, 0);
2377     dset = H5Dcreate(parent, name, H5T_NATIVE_INT, iSpace, iCompress, dprop, H5P_DEFAULT);
2378     if (dset < 0)
2379     {
2380         return -1;
2381     }
2382
2383     status = H5Dwrite(dset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
2384     if (status < 0)
2385     {
2386         return -1;
2387     }
2388
2389     //Add attribute SCILAB_Class = double to dataset
2390     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_BOOLEAN);
2391     if (status < 0)
2392     {
2393         return -1;
2394     }
2395
2396     //Close and release resources.
2397     status = H5Dclose(dset);
2398     if (status < 0)
2399     {
2400         return -1;
2401     }
2402
2403     status = H5Pclose(dprop);
2404     if (status < 0)
2405     {
2406         return -1;
2407     }
2408
2409     status = H5Sclose(iSpace);
2410     if (status < 0)
2411     {
2412         return -1;
2413     }
2414
2415     return dset;
2416 }
2417
2418 int writeIntegerMatrix6(int parent, const char* name, int type, const char* prec, int dims, int* pdims, void* data)
2419 {
2420     hsize_t* piDims = NULL;
2421     herr_t status = 0;
2422     hid_t space = 0;
2423     hid_t dset = 0;
2424     hid_t compress = 0;
2425     int size = 0;
2426     hid_t dprop = 0;
2427
2428     piDims = convertDims(&dims, pdims, &size);
2429
2430     if (dims == 0 || (dims == 2 && pdims[0] == 0 && pdims[1] == 0))
2431     {
2432         // []
2433         space = H5Screate_simple(0, NULL, NULL);
2434         if (space < 0)
2435         {
2436             free(piDims);
2437             return -1;
2438         }
2439
2440         //Create the dataset and write the array data to it.
2441         compress = enableCompression(9, dims, piDims);
2442         free(piDims);
2443
2444         dprop = H5Pcreate(H5P_DATASET_CREATE);
2445         H5Pset_obj_track_times(dprop, 0);
2446         dset = H5Dcreate(parent, name, H5T_NATIVE_DOUBLE, space, compress, dprop, H5P_DEFAULT);
2447         if (dset < 0)
2448         {
2449             return -1;
2450         }
2451     }
2452     else
2453     {
2454         //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
2455         space = H5Screate_simple(dims, piDims, NULL);
2456         if (space < 0)
2457         {
2458             FREE(piDims);
2459             return -1;
2460         }
2461         //Create the dataset and write the array data to it.
2462         compress = enableCompression(9, dims, piDims);
2463         FREE(piDims);
2464
2465         dprop = H5Pcreate(H5P_DATASET_CREATE);
2466         H5Pset_obj_track_times(dprop, 0);
2467         dset = H5Dcreate(parent, name, type, space, compress, dprop, H5P_DEFAULT);
2468         if (dset < 0)
2469         {
2470             return -1;
2471         }
2472
2473         status = H5Dwrite(dset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
2474         if (status < 0)
2475         {
2476             return -1;
2477         }
2478     }
2479     //Add attribute SCILAB_Class = double to dataset
2480     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
2481     if (status < 0)
2482     {
2483         return -1;
2484     }
2485
2486     status = addAttribute(dset, g_SCILAB_CLASS_PREC, prec);
2487     if (status < 0)
2488     {
2489         return -1;
2490     }
2491
2492     //Close and release resources.
2493     status = H5Dclose(dset);
2494     if (status < 0)
2495     {
2496         return -1;
2497     }
2498
2499     status = H5Pclose(dprop);
2500     if (status < 0)
2501     {
2502         return -1;
2503     }
2504
2505     status = H5Sclose(space);
2506     if (status < 0)
2507     {
2508         return -1;
2509     }
2510
2511     return 0;
2512 }
2513
2514 int openList6(int parent, const char *name, const char* type)
2515 {
2516     //First create a group to store all referenced objects.
2517     int group = H5Gcreate(parent, name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
2518     //Add attribute SCILAB_Class = string to dataset
2519     if (addAttribute(group, g_SCILAB_CLASS, type) < 0)
2520     {
2521         return -1;
2522     }
2523
2524     return group;
2525 }
2526
2527 int closeList6(int lst)
2528 {
2529     if (H5Gclose(lst) < 0)
2530     {
2531         return -1;
2532     }
2533
2534     return 0;
2535 }
2536
2537 int addItemStruct6(int dataset, hobj_ref_t * refs, int pos, const char *name)
2538 {
2539     herr_t status = H5Rcreate(&refs[pos], dataset, name, H5R_OBJECT, -1);
2540     if (status < 0)
2541     {
2542         return -1;
2543     }
2544
2545     return status;
2546 }
2547
2548 int writeStructField6(int parent, const char* name, int dims, int* pdims, hobj_ref_t * refs)
2549 {
2550     hid_t space = 0;
2551     hid_t dset = 0;
2552     herr_t status = 0;
2553     hsize_t *piDims = NULL;
2554     hid_t iCompress = 0;
2555     hid_t dprop = 0;
2556     int i = 0;
2557     int iSize = 0;
2558
2559     piDims = convertDims(&dims, pdims, &iSize);
2560
2561     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
2562     space = H5Screate_simple(dims, piDims, NULL);
2563     if (space < 0)
2564     {
2565         free(piDims);
2566         return -1;
2567     }
2568
2569     //Create the dataset and write the array data to it.
2570     iCompress = enableCompression(9, dims, piDims);
2571     free(piDims);
2572
2573     dprop = H5Pcreate(H5P_DATASET_CREATE);
2574     H5Pset_obj_track_times(dprop, 0);
2575     dset = H5Dcreate(parent, name, H5T_STD_REF_OBJ, space, iCompress, dprop, H5P_DEFAULT);
2576     if (dset < 0)
2577     {
2578         return -1;
2579     }
2580
2581     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, refs);
2582     if (status < 0)
2583     {
2584         return -1;
2585     }
2586
2587     //Close and release resources.
2588     status = H5Dclose(dset);
2589     if (status < 0)
2590     {
2591         return -1;
2592     }
2593
2594     status = H5Pclose(dprop);
2595     if (status < 0)
2596     {
2597         return -1;
2598     }
2599
2600     status = H5Sclose(space);
2601     if (status < 0)
2602     {
2603         return -1;
2604     }
2605
2606     return dset;
2607 }
2608
2609 int writeVoid6(int parent, const char* name)
2610 {
2611     hsize_t piDims[1] = {1};
2612     herr_t status = 0;
2613     hid_t iSpace = 0;
2614     hid_t iDataset = 0;
2615     hid_t iCompress = 0;
2616     hid_t dprop = 0;
2617     char cData = 0;
2618
2619     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
2620     iSpace = H5Screate_simple(1, piDims, NULL);
2621     if (iSpace < 0)
2622     {
2623         return -1;
2624     }
2625     //Create the dataset and write the array data to it.
2626     iCompress = enableCompression(9, 1, piDims);
2627
2628     dprop = H5Pcreate(H5P_DATASET_CREATE);
2629     H5Pset_obj_track_times(dprop, 0);
2630     iDataset = H5Dcreate(parent, name, H5T_NATIVE_INT8, iSpace, iCompress, dprop, H5P_DEFAULT);
2631     if (iDataset < 0)
2632     {
2633         return -1;
2634     }
2635
2636     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, &cData);
2637     if (status < 0)
2638     {
2639         return -1;
2640     }
2641
2642     //Add attribute SCILAB_Class = double to dataset
2643     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_VOID);
2644     if (status < 0)
2645     {
2646         return -1;
2647     }
2648
2649     //Close and release resources.
2650     status = H5Dclose(iDataset);
2651     if (status < 0)
2652     {
2653         return -1;
2654     }
2655
2656     status = H5Pclose(dprop);
2657     if (status < 0)
2658     {
2659         return -1;
2660     }
2661
2662     status = H5Sclose(iSpace);
2663     if (status < 0)
2664     {
2665         return -1;
2666     }
2667
2668     return 0;
2669 }
2670
2671 int writeUndefined6(int parent, const char* name)
2672 {
2673     hsize_t piDims[1] = {1};
2674     herr_t status = 0;
2675     hid_t iSpace = 0;
2676     hid_t iDataset = 0;
2677     hid_t iCompress = 0;
2678     hid_t dprop = 0;
2679     char cData = 0;
2680
2681     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
2682     iSpace = H5Screate_simple(1, piDims, NULL);
2683     if (iSpace < 0)
2684     {
2685         return -1;
2686     }
2687     //Create the dataset and write the array data to it.
2688     iCompress = enableCompression(9, 1, piDims);
2689
2690     dprop = H5Pcreate(H5P_DATASET_CREATE);
2691     H5Pset_obj_track_times(dprop, 0);
2692     iDataset = H5Dcreate(parent, name, H5T_NATIVE_INT8, iSpace, iCompress, dprop, H5P_DEFAULT);
2693     if (iDataset < 0)
2694     {
2695         return -1;
2696     }
2697
2698     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, &cData);
2699     if (status < 0)
2700     {
2701         return -1;
2702     }
2703
2704     //Add attribute SCILAB_Class = double to dataset
2705     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_UNDEFINED);
2706     if (status < 0)
2707     {
2708         return -1;
2709     }
2710
2711     //Close and release resources.
2712     status = H5Dclose(iDataset);
2713     if (status < 0)
2714     {
2715         return -1;
2716     }
2717
2718     status = H5Pclose(dprop);
2719     if (status < 0)
2720     {
2721         return -1;
2722     }
2723
2724     status = H5Sclose(iSpace);
2725     if (status < 0)
2726     {
2727         return -1;
2728     }
2729
2730     return 0;
2731 }