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