add "-append" argument to export_to_hdf5 function, fix some memory leaks in hdf5...
[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) 2009-2009 - DIGITEO - Bruno JOFRET
4 *
5 *  This file must be used under the terms of the CeCILL.
6 *  This source file is licensed as described in the file COPYING, which
7 *  you should have received as part of this distribution.  The terms
8 *  are also available at
9 *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10 *
11 */
12
13 #define H5_USE_16_API
14
15 #include <hdf5.h>
16 #include <MALLOC.h>
17 #include <math.h>
18 #include <string.h>
19 #include "sci_types.h"
20 #include "core_math.h"
21 #include "h5_writeDataToFile.h"
22 #include "h5_attributeConstants.h"
23
24 static hid_t enableCompression(int _iLevel, int _iRank, const hsize_t * _piDims)
25 {
26     /*hid_t iRet = 0;
27     int iLevel = _iLevel;*/
28
29     return H5P_DEFAULT;
30 /*
31   if(iLevel < 0)
32     {
33         iLevel = 0;
34     }
35
36   if(iLevel > 9)
37     {
38         iLevel = 9;
39     }
40
41     if(iLevel)
42     {
43         iRet = H5Pcreate(H5P_DATASET_CREATE);
44         if(iRet < 0)
45         {
46             iRet = 0;
47         }
48         else
49         {
50             if(H5Pset_layout(iRet,H5D_COMPACT)<0)
51             {
52                 H5Pclose(iRet);
53                 iRet = 0;
54             }
55             else
56             {
57                 if(H5Pset_chunk(iRet,_iRank, _piDims)<0)
58                 {
59                     H5Pclose(iRet);
60                     iRet = 0;
61                 }
62                 else
63                 {
64                     if(H5Pset_deflate(iRet,iLevel)<0)
65                     {
66                         H5Pclose(iRet);
67                         iRet = 0;
68                     }
69                 }
70             }
71         }
72     }
73     else
74     {
75         iRet = H5Pcopy(H5P_DEFAULT);
76     }
77     return iRet;
78 */
79 }
80
81 static herr_t addIntAttribute(int _iDatasetId, const char *_pstName, const int _iVal)
82 {
83     hsize_t attributeDims[1] = { 1 };
84     hid_t attributeTypeId, attributeSpace;
85     herr_t status;
86
87     //Create attribute dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
88     attributeSpace = H5Screate_simple(1, attributeDims, NULL);
89
90     //Create the attribute and write it.
91     attributeTypeId = H5Acreate(_iDatasetId, _pstName, H5T_NATIVE_INT, attributeSpace, H5P_DEFAULT);
92     if (attributeTypeId < 0)
93     {
94         return -1;
95     }
96
97     status = H5Awrite(attributeTypeId, H5T_NATIVE_INT, &_iVal);
98     if (status < 0)
99     {
100         return -1;
101     }
102
103     //Close and release resources.
104     status = H5Aclose(attributeTypeId);
105     if (status < 0)
106     {
107         return -1;
108     }
109
110     status = H5Sclose(attributeSpace);
111     if (status < 0)
112     {
113         return -1;
114     }
115
116     return 0;
117 }
118
119 static herr_t addAttribute(int _iDatasetId, const char *_pstName, const char *_pstValue)
120 {
121     hsize_t attributeDims[1] = { 1 };
122     hid_t attributeTypeId, attributeSpace, attr;
123     herr_t status;
124
125     //Create attribute dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
126     attributeSpace = H5Screate_simple(1, attributeDims, NULL);
127
128     //Create special attribute type
129     attributeTypeId = H5Tcopy(H5T_C_S1);
130     status = H5Tset_size(attributeTypeId, strlen(_pstValue));
131     if (status < 0)
132     {
133         return -1;
134     }
135
136     //Create the attribute and write it.
137     attr = H5Acreate(_iDatasetId, _pstName, attributeTypeId, attributeSpace, H5P_DEFAULT);
138     if (attr < 0)
139     {
140         return -1;
141     }
142
143     status = H5Awrite(attr, attributeTypeId, _pstValue);
144     if (status < 0)
145     {
146         return -1;
147     }
148
149     //Close and release resources.
150     status = H5Aclose(attr);
151     if (status < 0)
152     {
153         return -1;
154     }
155
156     status = H5Tclose(attributeTypeId);
157     if (status < 0)
158     {
159         return -1;
160     }
161
162     return 0;
163 }
164
165 /*
166 static int writeString(int _iFile, char *_pstDatasetName, char *_pstData)
167 {
168     hsize_t dims[1] = { 1 };
169     hid_t typeId, space, dset;
170     herr_t status;
171     hid_t iCompress;
172
173     //Create string dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
174     space = H5Screate_simple(1, dims, NULL);
175     if (space < 0)
176     {
177         return -1;
178     }
179
180     //Create special string type
181     typeId = H5Tcopy(H5T_C_S1);
182     if (strlen(_pstData) > 0)
183     {
184         status = H5Tset_size(typeId, strlen(_pstData));
185         if (status < 0)
186         {
187             return -1;
188         }
189     }
190
191     //Create the data set and write it.
192     iCompress = enableCompression(9, 1, dims);
193     dset = H5Dcreate(_iFile, _pstDatasetName, typeId, space, iCompress);
194     if (dset < 0)
195     {
196         return -1;
197     }
198
199     status = H5Dwrite(dset, typeId, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pstData);
200     if (status < 0)
201     {
202         return -1;
203     }
204
205     //Add attribute SCILAB_Class = string to dataset
206     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_STRING);
207     if (status < 0)
208     {
209         return -1;
210     }
211
212     //Close and release resources.
213     status = H5Dclose(dset);
214     if (status < 0)
215     {
216         return -1;
217     }
218
219     status = H5Tclose(typeId);
220     if (status < 0)
221     {
222         return -1;
223     }
224
225     status = H5Sclose(space);
226     if (status < 0)
227     {
228         return -1;
229     }
230
231     return 0;
232 }
233 */
234 int writeStringMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, char **data)
235 {
236     int i;
237     hsize_t dims[1] = { _iRows * _iCols };
238     hsize_t subdims[1] = { 1 };
239     hid_t typeId, space, dset, memspace;
240     herr_t status;
241     hid_t iCompress;
242     size_t iMaxLen = 0;
243     char *pstDataTemp = NULL;
244
245     for (i = 0; i < _iRows * _iCols; i++)
246     {
247         iMaxLen = Max(iMaxLen, strlen(data[i]));
248     }
249
250     //Create string dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
251     space = H5Screate_simple(1, dims, NULL);
252     if (space < 0)
253     {
254         return -1;
255     }
256
257     //Create special string type
258     typeId = H5Tcopy(H5T_C_S1);
259
260     /* Bug 6474 */
261     /* we allocate datas in fixed length string */
262     /* workaround for memcpy in hdf5 with wrong size */
263     pstDataTemp = MALLOC(sizeof(char) * (iMaxLen + 1));
264
265     if (iMaxLen > 0)
266     {
267         status = H5Tset_size(typeId, iMaxLen);
268         if (status < 0)
269         {
270             FREE(pstDataTemp);
271             return -1;
272         }
273     }
274
275     //Create the data set and write it.
276     iCompress = enableCompression(9, 1, dims);
277     dset = H5Dcreate(_iFile, _pstDatasetName, typeId, space, iCompress);
278     if (dset < 0)
279     {
280         FREE(pstDataTemp);
281         return -1;
282     }
283
284     status = H5Sclose(space);
285     if (status < 0)
286     {
287         FREE(pstDataTemp);
288         return -1;
289     }
290
291     for (i = 0; i < _iRows * _iCols; i++)
292     {
293         hssize_t start[1] = { i };
294         hsize_t count[1] = { 1 };
295
296         strcpy(pstDataTemp, data[i]);
297
298         space = H5Dget_space(dset);
299         if (space < 0)
300         {
301             FREE(pstDataTemp);
302             return -1;
303         }
304
305         status = H5Sselect_hyperslab(space, H5S_SELECT_SET, start, NULL, count, NULL);
306         if (status < 0)
307         {
308             FREE(pstDataTemp);
309             return -1;
310         }
311
312         /*create sub space */
313         memspace = H5Screate_simple(1, subdims, NULL);
314         if (memspace < 0)
315         {
316             FREE(pstDataTemp);
317             return -1;
318         }
319
320         status = H5Dwrite(dset, typeId, memspace, space, H5P_DEFAULT, pstDataTemp);
321
322         if (status < 0)
323         {
324             FREE(pstDataTemp);
325             return -1;
326         }
327
328         status = H5Sclose(space);
329         if (status < 0)
330         {
331             FREE(pstDataTemp);
332             return -1;
333         }
334
335         status = H5Sclose(memspace);
336         if (status < 0)
337         {
338             FREE(pstDataTemp);
339             return -1;
340         }
341
342     }
343
344     //Add attribute SCILAB_Class = string to dataset
345     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_STRING);
346     if (status < 0)
347     {
348         FREE(pstDataTemp);
349         return -1;
350     }
351
352     //Add attribute SCILAB_rows = _iRows
353     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
354     if (status < 0)
355     {
356         FREE(pstDataTemp);
357         return -1;
358     }
359
360     //Add attribute SCILAB_cols = _iCols
361     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
362     if (status < 0)
363     {
364         FREE(pstDataTemp);
365         return -1;
366     }
367
368     //Close and release resources.
369     status = H5Dclose(dset);
370     if (status < 0)
371     {
372         FREE(pstDataTemp);
373         return -1;
374     }
375
376     status = H5Tclose(typeId);
377     if (status < 0)
378     {
379         FREE(pstDataTemp);
380         return -1;
381     }
382
383     FREE(pstDataTemp);
384
385     return 0;
386 }
387
388 char *createGroupName(char *_pstGroupName)
389 {
390     char *pstSlash = NULL;
391     char *pstGroupName = (char *)MALLOC((strlen(_pstGroupName) + 3) * sizeof(char));
392
393     // Generate groupname #<dataSetName>#
394     sprintf(pstGroupName, "#%s#", _pstGroupName);
395     pstSlash = strstr(pstGroupName, "/");
396     if (pstSlash != NULL)
397     {
398         pstSlash[0] = '_';
399     }
400
401     return pstGroupName;
402 }
403
404 char* createPathName(char *_pstGroupName, int _iIndex)
405 {
406     char *pstName = NULL;
407     char *pstPathName = NULL;
408
409     int iNameLen = (int)log10((double)_iIndex + 1) + 1;
410     iNameLen += 2; //for both '#'
411     iNameLen += 1; //for null termanation
412
413     pstName = (char *)MALLOC(iNameLen * sizeof(char));
414     //1 for null termination, 2 for '#' characters
415     sprintf(pstName, "#%d#", _iIndex);
416
417     pstPathName = (char *)MALLOC((strlen(_pstGroupName) + strlen(pstName) + 2) * sizeof(char));
418     //1 for null termination, 1 for separator, 2 for '#' characters
419     sprintf(pstPathName, "%s/%s", _pstGroupName, pstName);
420     FREE(pstName);
421     return pstPathName;
422 }
423
424 int writeVoid(int _iFile, char *_pstDatasetName)
425 {
426     hsize_t piDims[1] = { 1 };
427     herr_t status = 0;
428     hid_t iSpace = 0;
429     hid_t iDataset = 0;
430     hid_t iCompress = 0;
431     char cData = 0;
432
433     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
434     iSpace = H5Screate_simple(1, piDims, NULL);
435     if (iSpace < 0)
436     {
437         return -1;
438     }
439     //Create the dataset and write the array data to it.
440     iCompress = enableCompression(9, 1, piDims);
441     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress);
442     if (iDataset < 0)
443     {
444         return -1;
445     }
446
447     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, &cData);
448     if (status < 0)
449     {
450         return -1;
451     }
452
453     //Add attribute SCILAB_Class = double to dataset
454     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_VOID);
455     if (status < 0)
456     {
457         return -1;
458     }
459
460     //Close and release resources.
461     status = H5Dclose(iDataset);
462     if (status < 0)
463     {
464         return -1;
465     }
466
467     status = H5Sclose(iSpace);
468     if (status < 0)
469     {
470         return -1;
471     }
472
473     return 0;
474 }
475
476 int writeUndefined(int _iFile, char *_pstDatasetName)
477 {
478     hsize_t piDims[1] = { 1 };
479     herr_t status = 0;
480     hid_t iSpace = 0;
481     hid_t iDataset = 0;
482     hid_t iCompress = 0;
483     char cData = 0;
484
485     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
486     iSpace = H5Screate_simple(1, piDims, NULL);
487     if (iSpace < 0)
488     {
489         return -1;
490     }
491     //Create the dataset and write the array data to it.
492     iCompress = enableCompression(9, 1, piDims);
493     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress);
494     if (iDataset < 0)
495     {
496         return -1;
497     }
498
499     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, &cData);
500     if (status < 0)
501     {
502         return -1;
503     }
504
505     //Add attribute SCILAB_Class = double to dataset
506     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_UNDEFINED);
507     if (status < 0)
508     {
509         return -1;
510     }
511
512     //Close and release resources.
513     status = H5Dclose(iDataset);
514     if (status < 0)
515     {
516         return -1;
517     }
518
519     status = H5Sclose(iSpace);
520     if (status < 0)
521     {
522         return -1;
523     }
524
525     return 0;
526 }
527
528 static hobj_ref_t writeCommomDoubleMatrix(int _iFile, char *_pstGroupName, char *_pstDatasetName, int _iIndex, int _iRows, int _iCols,
529                                           double *_pdblData)
530 {
531     hid_t space;
532     hid_t dset;
533     hid_t iCompress = 0;
534     hsize_t dims[1] = { _iRows * _iCols };
535     herr_t status = 0;
536     hobj_ref_t iRef = 0;
537
538     if (_iRows * _iCols == 0)
539     {
540         double dblZero = 0;
541
542         //tips for empty double matrix
543
544         //Create dataspace.  Setting maximum size to NULL sets the maximum
545         //size to be the current size.
546         dims[0] = 1;
547
548         space = H5Screate_simple(1, dims, NULL);
549         if (space < 0)
550         {
551             return (hobj_ref_t) (-1);
552         }
553
554         //Create the dataset and write the array data to it.
555         iCompress = enableCompression(9, 1, dims);
556         dset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_DOUBLE, space, iCompress);
557         if (dset < 0)
558         {
559             return (hobj_ref_t) (-1);
560         }
561
562         status = H5Dwrite(dset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, &dblZero);
563         if (status < 0)
564         {
565             return (hobj_ref_t) (-1);
566         }
567
568         //Add attribute SCILAB_Class = double to dataset
569         status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
570         if (status < 0)
571         {
572             return (hobj_ref_t) (-1);
573         }
574
575         status = addAttribute(dset, g_SCILAB_CLASS_EMPTY, "true");
576         if (status < 0)
577         {
578             return (hobj_ref_t) (-1);
579         }
580     }
581     else
582     {
583         char *pstPathName = NULL;
584
585         //Create dataspace.  Setting maximum size to NULL sets the maximum
586         //size to be the current size.
587         space = H5Screate_simple(1, dims, NULL);
588         if (space < 0)
589         {
590             return (hobj_ref_t) (-1);
591         }
592
593         //createGroupe and dataset name
594         pstPathName = createPathName(_pstGroupName, _iIndex);
595
596         //Create the dataset and write the array data to it.
597         iCompress = enableCompression(9, 1, dims);
598         dset = H5Dcreate(_iFile, pstPathName, H5T_NATIVE_DOUBLE, space, iCompress);
599         if (dset < 0)
600         {
601             FREE(pstPathName);
602             return (hobj_ref_t) (-1);
603         }
604
605         status = H5Dwrite(dset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pdblData);
606         if (status < 0)
607         {
608             FREE(pstPathName);
609             return (hobj_ref_t) (-1);
610         }
611
612         //Add attribute SCILAB_Class = double to dataset
613         status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
614         if (status < 0)
615         {
616             FREE(pstPathName);
617             return (hobj_ref_t) (-1);
618         }
619
620         //Add attribute SCILAB_Class_rows = double to dataset
621         status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
622         if (status < 0)
623         {
624             FREE(pstPathName);
625             return (hobj_ref_t) (-1);
626         }
627
628         //Add attribute SCILAB_Class_cols = double to dataset
629         status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
630         if (status < 0)
631         {
632             FREE(pstPathName);
633             return (hobj_ref_t) (-1);
634         }
635
636         // create the ref
637         status = H5Rcreate(&iRef, _iFile, pstPathName, H5R_OBJECT, -1);
638         if (status < 0)
639         {
640             FREE(pstPathName);
641             return (hobj_ref_t) (-1);
642         }
643
644         FREE(pstPathName);
645     }
646
647     //Close and release resources.
648     status = H5Dclose(dset);
649     if (status < 0)
650     {
651         return (hobj_ref_t) (-1);
652     }
653
654     status = H5Sclose(space);
655     if (status < 0)
656     {
657         return (hobj_ref_t) (-1);
658     }
659
660     return iRef;
661 }
662
663 int writeDoubleMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, double *_pdblData)
664 {
665     hid_t space = 0;
666     hid_t dset = 0;
667     herr_t status = 0;
668     hsize_t dims[1] = { 1 };
669     hid_t iCompress = 0;
670     hobj_ref_t pRef[1] = { 0 };
671
672     hid_t group = 0;
673     char *pstGroupName = NULL;
674
675     pstGroupName = createGroupName(_pstDatasetName);
676
677     //create sub group only for non empty matrix
678     if (_iRows * _iCols != 0)
679     {
680         group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
681         status = H5Gclose(group);
682         if (status < 0)
683         {
684             return -1;
685         }
686     }
687
688     pRef[0] = writeCommomDoubleMatrix(_iFile, pstGroupName, _pstDatasetName, 0, _iRows, _iCols, _pdblData);
689
690     //don't create reference for empty matrix
691     if (_iRows * _iCols == 0)
692     {
693         return 0;
694     }
695
696     if (pRef[0] == 0)
697     {
698         return -1;
699     }
700
701     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
702     space = H5Screate_simple(1, dims, NULL);
703     if (space < 0)
704     {
705         return -1;
706     }
707
708     //Create the dataset and write the array data to it.
709     iCompress = enableCompression(9, 1, dims);
710     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
711     if (dset < 0)
712     {
713         return -1;
714     }
715
716     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pRef);
717     if (status < 0)
718     {
719         return -1;
720     }
721
722     //Add attribute SCILAB_Class = double to dataset
723     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
724     if (status < 0)
725     {
726         return -1;
727     }
728
729     //Add attribute SCILAB_Class_rows = double to dataset
730     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
731     if (status < 0)
732     {
733         return -1;
734     }
735
736     //Add attribute SCILAB_Class_cols = double to dataset
737     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
738     if (status < 0)
739     {
740         return -1;
741     }
742
743     //Close and release resources.
744     status = H5Dclose(dset);
745     if (status < 0)
746     {
747         return -1;
748     }
749
750     status = H5Sclose(space);
751     if (status < 0)
752     {
753         return -1;
754     }
755
756     FREE(pstGroupName);
757     return status;
758 }
759
760 int writeDoubleComplexMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, double *_pdblReal, double *_pdblImg)
761 {
762     hid_t space = 0;
763     hid_t dset = 0;
764     herr_t status = 0;
765     hid_t iCompress = 0;
766     hsize_t dims[1] = { 2 };
767     hobj_ref_t pRef[2] = { 0 };
768
769     hid_t group = 0;
770     char *pstGroupName = NULL;
771
772     pstGroupName = createGroupName(_pstDatasetName);
773     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
774     status = H5Gclose(group);
775
776     if (status < 0)
777     {
778         FREE(pstGroupName);
779         return -1;
780     }
781
782     pRef[0] = writeCommomDoubleMatrix(_iFile, pstGroupName, _pstDatasetName, 0, _iRows, _iCols, _pdblReal);
783     pRef[1] = writeCommomDoubleMatrix(_iFile, pstGroupName, _pstDatasetName, 1, _iRows, _iCols, _pdblImg);
784     FREE(pstGroupName);
785     if (pRef[0] == 0 || pRef[1] == 0)
786     {
787         return 1;
788     }
789
790     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
791     space = H5Screate_simple(1, dims, NULL);
792     if (space < 0)
793     {
794         return -1;
795     }
796
797     //Create the dataset and write the array data to it.
798     iCompress = enableCompression(9, 1, dims);
799     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
800     if (dset < 0)
801     {
802         printf("\nH5Dcreate\n");
803         return -1;
804     }
805     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pRef);
806     if (status < 0)
807     {
808         printf("\nH5Dwrite\n");
809         return -1;
810     }
811
812     //Add attribute SCILAB_Class = double to dataset
813     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
814     if (status < 0)
815     {
816         return -1;
817     }
818
819     //Add attribute SCILAB_Class_rows = double to dataset
820     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
821     if (status < 0)
822     {
823         return -1;
824     }
825
826     //Add attribute SCILAB_Class_cols = double to dataset
827     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
828     if (status < 0)
829     {
830         return -1;
831     }
832
833     status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
834     if (status < 0)
835     {
836         return -1;
837     }
838
839     //Close and release resources.
840     status = H5Dclose(dset);
841     if (status < 0)
842     {
843         return -1;
844     }
845
846     status = H5Sclose(space);
847     if (status < 0)
848     {
849         return -1;
850     }
851
852     return 0;
853 }
854
855 int writeBooleanMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int *_piData)
856 {
857     hsize_t piDims[1] = { _iRows * _iCols };
858     herr_t status;
859     hid_t iSpace;
860     hid_t iCompress;
861     hid_t iDataset;
862
863     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
864     iSpace = H5Screate_simple(1, piDims, NULL);
865     if (iSpace < 0)
866     {
867         return -1;
868     }
869
870     //Create the dataset and write the array data to it.
871     iCompress = enableCompression(9, 1, piDims);
872     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT, iSpace, iCompress);
873     if (iDataset < 0)
874     {
875         return -1;
876     }
877
878     status = H5Dwrite(iDataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
879     if (status < 0)
880     {
881         return -1;
882     }
883
884     //Add attribute SCILAB_Class = double to dataset
885     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_BOOLEAN);
886     if (status < 0)
887     {
888         return -1;
889     }
890
891     //Add attribute SCILAB_Class_rows = double to dataset
892     status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
893     if (status < 0)
894     {
895         return -1;
896     }
897
898     //Add attribute SCILAB_Class_cols = double to dataset
899     status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
900     if (status < 0)
901     {
902         return -1;
903     }
904
905     //Close and release resources.
906     status = H5Dclose(iDataset);
907     if (status < 0)
908     {
909         return -1;
910     }
911
912     status = H5Sclose(iSpace);
913     if (status < 0)
914     {
915         return -1;
916     }
917
918     return 0;
919 }
920
921 static int writeCommonPolyMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iComplex, int _iRows, int _iCols, int *_piNbCoef,
922                                  double **_pdblReal, double **_pdblImg)
923 {
924     int i = 0;
925     hsize_t dims[1] = { _iRows * _iCols };
926     herr_t status = 0;
927     hid_t space = 0;
928     hid_t dset = 0;
929     hid_t group = 0;
930     hid_t iCompress = 0;
931     hobj_ref_t *pData = 0;
932
933     char *pstPathName = NULL;
934     char *pstGroupName = NULL;
935
936     // Create ref matrix
937     pData = (hobj_ref_t *)MALLOC(dims[0] * sizeof(hobj_ref_t));
938
939     // Generate groupname #<dataSetName>#
940     pstGroupName = createGroupName(_pstDatasetName);
941
942     //First create a group to store all referenced objects.
943     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
944     status = H5Gclose(group);
945
946     //Now create each String as a dedicated DataSet.
947     for (i = 0 ; i < dims[0] ; i++)
948     {
949         pstPathName = createPathName(pstGroupName, i);
950
951         // Write the string to ref
952         if (_iComplex)
953         {
954             status = writeDoubleComplexMatrix(_iFile, pstPathName, 1, _piNbCoef[i], _pdblReal[i], _pdblImg[i]);
955         }
956         else
957         {
958             status = writeDoubleMatrix(_iFile, pstPathName, 1, _piNbCoef[i], _pdblReal[i]);
959         }
960
961         if (status < 0)
962         {
963             FREE(pstPathName);
964             FREE(pstGroupName);
965             FREE(pData);
966             return -1;
967         }
968
969         // create the ref
970         status = H5Rcreate(&pData[i], _iFile, pstPathName, H5R_OBJECT, -1);
971         if (status < 0)
972         {
973             FREE(pstPathName);
974             FREE(pstGroupName);
975             FREE(pData);
976             return -1;
977         }
978
979         FREE(pstPathName);
980     }
981
982     FREE(pstGroupName);
983     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
984     space = H5Screate_simple(1, dims, NULL);
985     if (status < 0)
986     {
987         FREE(pData);
988         return -1;
989     }
990
991     //Create the dataset and write the array data to it.
992     iCompress = enableCompression(9, 1, dims);
993     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
994     if (dset < 0)
995     {
996         FREE(pData);
997         return -1;
998     }
999
1000     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
1001     if (status < 0)
1002     {
1003         FREE(pData);
1004         return -1;
1005     }
1006
1007     FREE(pData);
1008     //Add attribute SCILAB_Class = poly to dataset
1009     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_POLY);
1010     if (status < 0)
1011     {
1012         return -1;
1013     }
1014
1015     //Add attribute Varname attribute to dataset
1016     status = addAttribute(dset, g_SCILAB_CLASS_VARNAME, _pstVarName);
1017     if (status < 0)
1018     {
1019         return -1;
1020     }
1021
1022     if (_iComplex)
1023     {
1024         //Add attribute Varname attribute to dataset
1025         status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
1026         if (status < 0)
1027         {
1028             return -1;
1029         }
1030     }
1031
1032     //Add attribute SCILAB_Class_rows = double to dataset
1033     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
1034     if (status < 0)
1035     {
1036         return -1;
1037     }
1038
1039     //Add attribute SCILAB_Class_cols = double to dataset
1040     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
1041     if (status < 0)
1042     {
1043         return -1;
1044     }
1045
1046     //Close and release resources.
1047     status = H5Dclose(dset);
1048     if (status < 0)
1049     {
1050         return -1;
1051     }
1052
1053     status = H5Sclose(space);
1054     if (status < 0)
1055     {
1056         return -1;
1057     }
1058
1059     return 0;
1060 }
1061
1062 int writePolyMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iRows, int _iCols, int *_piNbCoef, double **_pdblReal)
1063 {
1064     return writeCommonPolyMatrix(_iFile, _pstDatasetName, _pstVarName, 0, _iRows, _iCols, _piNbCoef, _pdblReal, NULL);
1065 }
1066
1067 int writePolyComplexMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iRows, int _iCols, int *_piNbCoef, double **_pdblReal,
1068                            double **_pdblImg)
1069 {
1070     return writeCommonPolyMatrix(_iFile, _pstDatasetName, _pstVarName, 1, _iRows, _iCols, _piNbCoef, _pdblReal, _pdblImg);
1071 }
1072
1073 int writeInteger8Matrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, char *_pcData)
1074 {
1075     hsize_t piDims[1] = { _iRows * _iCols };
1076     herr_t status = 0;
1077     hid_t iSpace = 0;
1078     hid_t iDataset = 0;
1079     hid_t iCompress = 0;
1080
1081     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1082     iSpace = H5Screate_simple(1, piDims, NULL);
1083     if (iSpace < 0)
1084     {
1085         return -1;
1086     }
1087     //Create the dataset and write the array data to it.
1088     iCompress = enableCompression(9, 1, piDims);
1089     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress);
1090     if (iDataset < 0)
1091     {
1092         return -1;
1093     }
1094
1095     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pcData);
1096     if (status < 0)
1097     {
1098         return -1;
1099     }
1100
1101     //Add attribute SCILAB_Class = double to dataset
1102     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1103     if (status < 0)
1104     {
1105         return -1;
1106     }
1107
1108     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "8");
1109     if (status < 0)
1110     {
1111         return -1;
1112     }
1113
1114     //Add attribute SCILAB_Class_rows to dataset
1115     status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
1116     if (status < 0)
1117     {
1118         return -1;
1119     }
1120
1121     //Add attribute SCILAB_Class_cols to dataset
1122     status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
1123     if (status < 0)
1124     {
1125         return -1;
1126     }
1127
1128     //Close and release resources.
1129     status = H5Dclose(iDataset);
1130     if (status < 0)
1131     {
1132         return -1;
1133     }
1134
1135     status = H5Sclose(iSpace);
1136     if (status < 0)
1137     {
1138         return -1;
1139     }
1140
1141     return 0;
1142 }
1143
1144 int writeInteger16Matrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, short *_psData)
1145 {
1146     hsize_t piDims[1] = { _iRows * _iCols };
1147     herr_t status = 0;
1148     hid_t iSpace = 0;
1149     hid_t iDataset = 0;
1150     hid_t iCompress = 0;
1151
1152     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1153     iSpace = H5Screate_simple(1, piDims, NULL);
1154     if (iSpace < 0)
1155     {
1156         return -1;
1157     }
1158     //Create the dataset and write the array data to it.
1159     iCompress = enableCompression(9, 1, piDims);
1160     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT16, iSpace, iCompress);
1161     if (iDataset < 0)
1162     {
1163         return -1;
1164     }
1165     status = H5Dwrite(iDataset, H5T_NATIVE_INT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _psData);
1166     if (status < 0)
1167     {
1168         return -1;
1169     }
1170
1171     //Add attribute SCILAB_Class = double to dataset
1172     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1173     if (status < 0)
1174     {
1175         return -1;
1176     }
1177
1178     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "16");
1179     if (status < 0)
1180     {
1181         return -1;
1182     }
1183
1184     //Add attribute SCILAB_Class_rows to dataset
1185     status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
1186     if (status < 0)
1187     {
1188         return -1;
1189     }
1190
1191     //Add attribute SCILAB_Class_cols to dataset
1192     status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
1193     if (status < 0)
1194     {
1195         return -1;
1196     }
1197
1198     //Close and release resources.
1199     status = H5Dclose(iDataset);
1200     if (status < 0)
1201     {
1202         return -1;
1203     }
1204
1205     status = H5Sclose(iSpace);
1206     if (status < 0)
1207     {
1208         return -1;
1209     }
1210
1211     return 0;
1212 }
1213
1214 int writeInteger32Matrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int *_piData)
1215 {
1216     hsize_t piDims[1] = { _iRows * _iCols };
1217     herr_t status = 0;
1218     hid_t iSpace = 0;
1219     hid_t iDataset = 0;
1220     hid_t iCompress = 0;
1221
1222     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1223     iSpace = H5Screate_simple(1, piDims, NULL);
1224     if (iSpace < 0)
1225     {
1226         return -1;
1227     }
1228
1229     //Create the dataset and write the array data to it.
1230     iCompress = enableCompression(9, 1, piDims);
1231     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT32, iSpace, iCompress);
1232     if (iDataset < 0)
1233     {
1234         return -1;
1235     }
1236
1237     status = H5Dwrite(iDataset, H5T_NATIVE_INT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
1238     if (status < 0)
1239     {
1240         return -1;
1241     }
1242
1243     //Add attribute SCILAB_Class = double to dataset
1244     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1245     if (status < 0)
1246     {
1247         return -1;
1248     }
1249
1250     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "32");
1251     if (status < 0)
1252     {
1253         return -1;
1254     }
1255
1256     //Add attribute SCILAB_Class_rows to dataset
1257     status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
1258     if (status < 0)
1259     {
1260         return -1;
1261     }
1262
1263     //Add attribute SCILAB_Class_cols to dataset
1264     status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
1265     if (status < 0)
1266     {
1267         return -1;
1268     }
1269
1270     //Close and release resources.
1271     status = H5Dclose(iDataset);
1272     if (status < 0)
1273     {
1274         return -1;
1275     }
1276
1277     status = H5Sclose(iSpace);
1278     if (status < 0)
1279     {
1280         return -1;
1281     }
1282
1283     return 0;
1284 }
1285
1286 int writeInteger64Matrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, long long *_pllData)
1287 {
1288     hsize_t piDims[1] = { _iRows * _iCols };
1289     herr_t status = 0;
1290     hid_t iSpace = 0;
1291     hid_t iDataset = 0;
1292     hid_t iCompress = 0;
1293
1294     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1295     iSpace = H5Screate_simple(1, piDims, NULL);
1296     if (iSpace < 0)
1297     {
1298         return -1;
1299     }
1300
1301     //Create the dataset and write the array data to it.
1302     iCompress = enableCompression(9, 1, piDims);
1303     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT64, iSpace, iCompress);
1304     if (iDataset < 0)
1305     {
1306         return -1;
1307     }
1308
1309     status = H5Dwrite(iDataset, H5T_NATIVE_INT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pllData);
1310     if (status < 0)
1311     {
1312         return -1;
1313     }
1314
1315     //Add attribute SCILAB_Class = double to dataset
1316     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1317     if (status < 0)
1318     {
1319         return -1;
1320     }
1321
1322     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "64");
1323     if (status < 0)
1324     {
1325         return -1;
1326     }
1327
1328     //Add attribute SCILAB_Class_rows to dataset
1329     status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
1330     if (status < 0)
1331     {
1332         return -1;
1333     }
1334
1335     //Add attribute SCILAB_Class_cols to dataset
1336     status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
1337     if (status < 0)
1338     {
1339         return -1;
1340     }
1341
1342     //Close and release resources.
1343     status = H5Dclose(iDataset);
1344     if (status < 0)
1345     {
1346         return -1;
1347     }
1348
1349     status = H5Sclose(iSpace);
1350     if (status < 0)
1351     {
1352         return -1;
1353     }
1354
1355     return 0;
1356 }
1357
1358 HDF5_SCILAB_IMPEXP int writeUnsignedInterger8Matrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, unsigned char *_pucData)
1359 {
1360     hsize_t piDims[1] = { _iRows * _iCols };
1361     herr_t status = 0;
1362     hid_t iSpace = 0;
1363     hid_t iDataset = 0;
1364     hid_t iCompress = 0;
1365
1366     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1367     iSpace = H5Screate_simple(1, piDims, NULL);
1368     if (iSpace < 0)
1369     {
1370         return -1;
1371     }
1372
1373     //Create the dataset and write the array data to it.
1374     iCompress = enableCompression(9, 1, piDims);
1375     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT8, iSpace, iCompress);
1376     if (iDataset < 0)
1377     {
1378         return -1;
1379     }
1380
1381     status = H5Dwrite(iDataset, H5T_NATIVE_UINT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pucData);
1382     if (status < 0)
1383     {
1384         return -1;
1385     }
1386
1387     //Add attribute SCILAB_Class = double to dataset
1388     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1389     if (status < 0)
1390     {
1391         return -1;
1392     }
1393
1394     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u8");
1395     if (status < 0)
1396     {
1397         return -1;
1398     }
1399
1400     //Add attribute SCILAB_Class_rows to dataset
1401     status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
1402     if (status < 0)
1403     {
1404         return -1;
1405     }
1406
1407     //Add attribute SCILAB_Class_cols to dataset
1408     status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
1409     if (status < 0)
1410     {
1411         return -1;
1412     }
1413
1414     //Close and release resources.
1415     status = H5Dclose(iDataset);
1416     if (status < 0)
1417     {
1418         return -1;
1419     }
1420
1421     status = H5Sclose(iSpace);
1422     if (status < 0)
1423     {
1424         return -1;
1425     }
1426
1427     return 0;
1428 }
1429
1430 HDF5_SCILAB_IMPEXP int writeUnsignedInterger16Matrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, unsigned short *_pusData)
1431 {
1432     hsize_t piDims[1] = { _iRows * _iCols };
1433     herr_t status = 0;
1434     hid_t iSpace = 0;
1435     hid_t iDataset = 0;
1436     hid_t iCompress = 0;
1437
1438     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1439     iSpace = H5Screate_simple(1, piDims, NULL);
1440     if (iSpace < 0)
1441     {
1442         return -1;
1443     }
1444
1445     //Create the dataset and write the array data to it.
1446     iCompress = enableCompression(9, 1, piDims);
1447     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT16, iSpace, iCompress);
1448     if (iDataset < 0)
1449     {
1450         return -1;
1451     }
1452
1453     status = H5Dwrite(iDataset, H5T_NATIVE_UINT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pusData);
1454     if (status < 0)
1455     {
1456         return -1;
1457     }
1458
1459     //Add attribute SCILAB_Class = double to dataset
1460     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1461     if (status < 0)
1462     {
1463         return -1;
1464     }
1465
1466     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u16");
1467     if (status < 0)
1468     {
1469         return -1;
1470     }
1471
1472     //Add attribute SCILAB_Class_rows to dataset
1473     status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
1474     if (status < 0)
1475     {
1476         return -1;
1477     }
1478
1479     //Add attribute SCILAB_Class_cols to dataset
1480     status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
1481     if (status < 0)
1482     {
1483         return -1;
1484     }
1485
1486     //Close and release resources.
1487     status = H5Dclose(iDataset);
1488     if (status < 0)
1489     {
1490         return -1;
1491     }
1492
1493     status = H5Sclose(iSpace);
1494     if (status < 0)
1495     {
1496         return -1;
1497     }
1498
1499     return 0;
1500 }
1501
1502 HDF5_SCILAB_IMPEXP int writeUnsignedInterger32Matrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, unsigned int *_puiData)
1503 {
1504     hsize_t piDims[1] = { _iRows * _iCols };
1505     herr_t status = 0;
1506     hid_t iSpace = 0;
1507     hid_t iDataset = 0;
1508     hid_t iCompress = 0;
1509
1510     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1511     iSpace = H5Screate_simple(1, piDims, NULL);
1512     if (iSpace < 0)
1513     {
1514         return -1;
1515     }
1516
1517     //Create the dataset and write the array data to it.
1518     iCompress = enableCompression(9, 1, piDims);
1519     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT32, iSpace, iCompress);
1520     if (iDataset < 0)
1521     {
1522         return -1;
1523     }
1524
1525     status = H5Dwrite(iDataset, H5T_NATIVE_UINT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _puiData);
1526     if (status < 0)
1527     {
1528         return -1;
1529     }
1530
1531     //Add attribute SCILAB_Class = double to dataset
1532     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1533     if (status < 0)
1534     {
1535         return -1;
1536     }
1537
1538     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u32");
1539     if (status < 0)
1540     {
1541         return -1;
1542     }
1543
1544     //Add attribute SCILAB_Class_rows to dataset
1545     status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
1546     if (status < 0)
1547     {
1548         return -1;
1549     }
1550
1551     //Add attribute SCILAB_Class_cols to dataset
1552     status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
1553     if (status < 0)
1554     {
1555         return -1;
1556     }
1557
1558     //Close and release resources.
1559     status = H5Dclose(iDataset);
1560     if (status < 0)
1561     {
1562         return -1;
1563     }
1564
1565     status = H5Sclose(iSpace);
1566     if (status < 0)
1567     {
1568         return -1;
1569     }
1570
1571     return 0;
1572 }
1573
1574 HDF5_SCILAB_IMPEXP int writeUnsignedInterger64Matrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, unsigned long long *_pullData)
1575 {
1576     hsize_t piDims[1] = { _iRows * _iCols };
1577     herr_t status = 0;
1578     hid_t iSpace = 0;
1579     hid_t iDataset = 0;
1580     hid_t iCompress = 0;
1581
1582     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1583     iSpace = H5Screate_simple(1, piDims, NULL);
1584     if (iSpace < 0)
1585     {
1586         return -1;
1587     }
1588
1589     //Create the dataset and write the array data to it.
1590     iCompress = enableCompression(9, 1, piDims);
1591     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT64, iSpace, iCompress);
1592     if (iDataset < 0)
1593     {
1594         return -1;
1595     }
1596
1597     status = H5Dwrite(iDataset, H5T_NATIVE_UINT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pullData);
1598     if (status < 0)
1599     {
1600         return -1;
1601     }
1602
1603     //Add attribute SCILAB_Class = double to dataset
1604     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1605     if (status < 0)
1606     {
1607         return -1;
1608     }
1609
1610     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u64");
1611     if (status < 0)
1612     {
1613         return -1;
1614     }
1615
1616     //Add attribute SCILAB_Class_rows to dataset
1617     status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
1618     if (status < 0)
1619     {
1620         return -1;
1621     }
1622
1623     //Add attribute SCILAB_Class_cols to dataset
1624     status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
1625     if (status < 0)
1626     {
1627         return -1;
1628     }
1629
1630     //Close and release resources.
1631     status = H5Dclose(iDataset);
1632     if (status < 0)
1633     {
1634         return -1;
1635     }
1636
1637     status = H5Sclose(iSpace);
1638     if (status < 0)
1639     {
1640         return -1;
1641     }
1642
1643     return 0;
1644 }
1645
1646 int writeCommonSparseComplexMatrix(int _iFile, char *_pstDatasetName, int _iComplex, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow,
1647                                    int *_piColPos, double *_pdblReal, double *_pdblImg)
1648 {
1649     hsize_t dims[1] = { 3 };
1650     herr_t status = 0;
1651     hid_t space = 0;
1652     hid_t dset = 0;
1653     hid_t group = 0;
1654     hid_t iCompress = 0;
1655     hobj_ref_t pDataRef[3] = {0};
1656
1657     char *pstRowPath = NULL;
1658     char *pstColPath = NULL;
1659     char *pstDataPath = NULL;
1660     char *pstGroupName = NULL;
1661
1662     // Generate groupname #<dataSetName>#
1663     pstGroupName = createGroupName(_pstDatasetName);
1664
1665     //First create a group to store all referenced objects.
1666     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
1667     status = H5Gclose(group);
1668     if (status < 0)
1669     {
1670         FREE(pstGroupName);
1671         return -1;
1672     }
1673
1674     //Create each sub dataset and insert data
1675     pstRowPath = createPathName(pstGroupName, 0);
1676     status = writeInteger32Matrix(_iFile, pstRowPath, 1, _iRows, _piNbItemRow);
1677     if (status < 0)
1678     {
1679         FREE(pstRowPath);
1680         FREE(pstGroupName);
1681         return -1;
1682     }
1683
1684     status = H5Rcreate(&pDataRef[0], _iFile, pstRowPath, H5R_OBJECT, -1);
1685     if (status < 0)
1686     {
1687         FREE(pstRowPath);
1688         FREE(pstGroupName);
1689         return -1;
1690     }
1691
1692     pstColPath = createPathName(pstGroupName, 1);
1693     status = writeInteger32Matrix(_iFile, pstColPath, 1, _iNbItem, _piColPos);
1694     if (status < 0)
1695     {
1696         FREE(pstRowPath);
1697         FREE(pstColPath);
1698         FREE(pstGroupName);
1699         return -1;
1700     }
1701
1702     status = H5Rcreate(&pDataRef[1], _iFile, pstColPath, H5R_OBJECT, -1);
1703     if (status < 0)
1704     {
1705         FREE(pstRowPath);
1706         FREE(pstColPath);
1707         FREE(pstGroupName);
1708         return -1;
1709     }
1710
1711     pstDataPath = createPathName(pstGroupName, 2);
1712     if (_iComplex)
1713     {
1714         status = writeDoubleComplexMatrix(_iFile, pstDataPath, 1, _iNbItem, _pdblReal, _pdblImg);
1715     }
1716     else
1717     {
1718         status = writeDoubleMatrix(_iFile, pstDataPath, 1, _iNbItem, _pdblReal);
1719     }
1720
1721     if (status < 0)
1722     {
1723         FREE(pstRowPath);
1724         FREE(pstColPath);
1725         FREE(pstDataPath);
1726         FREE(pstGroupName);
1727         return -1;
1728     }
1729
1730     status = H5Rcreate(&pDataRef[2], _iFile, pstDataPath, H5R_OBJECT, -1);
1731     if (status < 0)
1732     {
1733         FREE(pstRowPath);
1734         FREE(pstColPath);
1735         FREE(pstDataPath);
1736         FREE(pstGroupName);
1737         return -1;
1738     }
1739
1740     //FREE group names
1741     FREE(pstRowPath);
1742     FREE(pstColPath);
1743     FREE(pstDataPath);
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     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
1756     if (dset < 0)
1757     {
1758         return -1;
1759     }
1760
1761     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
1762     if (status < 0)
1763     {
1764         return -1;
1765     }
1766     //Add attribute SCILAB_Class = poly to dataset
1767     //sprintf(pstRow, "%d", _iRows);
1768     //sprintf(pstCol, "%d", _iCols);
1769     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_SPARSE);
1770     if (status < 0)
1771     {
1772         return -1;
1773     }
1774
1775     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
1776     if (status < 0)
1777     {
1778         return -1;
1779     }
1780
1781     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
1782     if (status < 0)
1783     {
1784         return -1;
1785     }
1786
1787     status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1788     if (status < 0)
1789     {
1790         return -1;
1791     }
1792     if (_iComplex)
1793     {
1794         //Add attribute Varname attribute to dataset
1795         status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
1796         if (status < 0)
1797         {
1798             return -1;
1799         }
1800     }
1801
1802     //Close and release resources.
1803     status = H5Dclose(dset);
1804     if (status < 0)
1805     {
1806         return -1;
1807     }
1808
1809     status = H5Sclose(space);
1810     if (status < 0)
1811     {
1812         return -1;
1813     }
1814
1815     return 0;
1816 }
1817
1818 int writeSparseMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos, double *_pdblReal)
1819 {
1820     return writeCommonSparseComplexMatrix(_iFile, _pstDatasetName, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
1821 }
1822
1823 int writeSparseComplexMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos,
1824                              double *_pdblReal, double *_pdblImg)
1825 {
1826     return writeCommonSparseComplexMatrix(_iFile, _pstDatasetName, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
1827 }
1828
1829 int writeBooleanSparseMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos)
1830 {
1831     hsize_t dims[1] = { 2 };
1832     herr_t status = 0;
1833     hid_t space = 0;
1834     hid_t dset = 0;
1835     hid_t group = 0;
1836     hid_t iCompress = 0;
1837     hobj_ref_t pDataRef[2] = {0};
1838
1839     char *pstRowPath = NULL;
1840     char *pstColPath = NULL;
1841     char *pstGroupName = NULL;
1842
1843     // Generate groupname #<dataSetName>#
1844     pstGroupName = createGroupName(_pstDatasetName);
1845
1846     //First create a group to store all referenced objects.
1847     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
1848     status = H5Gclose(group);
1849     if (status < 0)
1850     {
1851         FREE(pstGroupName);
1852         return -1;
1853     }
1854
1855     //Create each sub dataset and insert data
1856     pstRowPath = createPathName(pstGroupName, 0);
1857     status = writeInteger32Matrix(_iFile, pstRowPath, 1, _iRows, _piNbItemRow);
1858     if (status < 0)
1859     {
1860         FREE(pstRowPath);
1861         FREE(pstGroupName);
1862         return -1;
1863     }
1864
1865     status = H5Rcreate(&pDataRef[0], _iFile, pstRowPath, H5R_OBJECT, -1);
1866     if (status < 0)
1867     {
1868         FREE(pstRowPath);
1869         FREE(pstGroupName);
1870         return -1;
1871     }
1872
1873     pstColPath = createPathName(pstGroupName, 1);
1874     status = writeInteger32Matrix(_iFile, pstColPath, 1, _iNbItem, _piColPos);
1875     if (status < 0)
1876     {
1877         FREE(pstRowPath);
1878         FREE(pstColPath);
1879         FREE(pstGroupName);
1880         return -1;
1881     }
1882
1883     status = H5Rcreate(&pDataRef[1], _iFile, pstColPath, H5R_OBJECT, -1);
1884     if (status < 0)
1885     {
1886         FREE(pstRowPath);
1887         FREE(pstColPath);
1888         FREE(pstGroupName);
1889         return -1;
1890     }
1891
1892     //FREE group names
1893     FREE(pstRowPath);
1894     FREE(pstColPath);
1895     FREE(pstGroupName);
1896
1897     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1898     space = H5Screate_simple(1, dims, NULL);
1899     if (space < 0)
1900     {
1901         return -1;
1902     }
1903
1904     //Create the dataset and write the array data to it.
1905     iCompress = enableCompression(9, 1, dims);
1906     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
1907     if (dset < 0)
1908     {
1909         return -1;
1910     }
1911
1912     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
1913     if (status < 0)
1914     {
1915         return -1;
1916     }
1917
1918     //Add attribute SCILAB_Class = boolean sparse to dataset
1919     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_BSPARSE);
1920     if (status < 0)
1921     {
1922         return -1;
1923     }
1924
1925     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
1926     if (status < 0)
1927     {
1928         return -1;
1929     }
1930
1931     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
1932     if (status < 0)
1933     {
1934         return -1;
1935     }
1936
1937     status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1938     if (status < 0)
1939     {
1940         return -1;
1941     }
1942     //Close and release resources.
1943     status = H5Dclose(dset);
1944     if (status < 0)
1945     {
1946         return -1;
1947     }
1948
1949     status = H5Sclose(space);
1950     if (status < 0)
1951     {
1952         return -1;
1953     }
1954
1955     return 0;
1956 }
1957
1958 //create a group and create hobj_ref_t array
1959 void *openList(int _iFile, char *pstDatasetName, int _iNbItem)
1960 {
1961     herr_t status = 0;
1962     hid_t group = 0;
1963     hobj_ref_t *pobjArray = NULL;
1964
1965     //First create a group to store all referenced objects.
1966     group = H5Gcreate(_iFile, pstDatasetName, H5P_DEFAULT);
1967     status = H5Gclose(group);
1968     if (status < 0)
1969     {
1970         return NULL;
1971     }
1972
1973     if (_iNbItem)
1974     {
1975         pobjArray = MALLOC(sizeof(hobj_ref_t) * _iNbItem);
1976     }
1977
1978     return pobjArray;
1979 }
1980
1981 int addItemInList(int _iFile, void *_pvList, int _iPos, char *_pstItemName)
1982 {
1983     hobj_ref_t *pobjArray = (hobj_ref_t *) _pvList;
1984
1985     return H5Rcreate(&pobjArray[_iPos], _iFile, _pstItemName, H5R_OBJECT, -1);
1986 }
1987
1988 int closeList(int _iFile, void *_pvList, char *_pstListName, int _iNbItem, int _iVarType)
1989 {
1990     herr_t status = 0;
1991     hsize_t dims[1] = { _iNbItem };
1992     hid_t space = 0;
1993     hid_t dset = 0;
1994     hid_t iCompress = 0;
1995     const char *pcstClass = NULL;
1996
1997     switch (_iVarType)
1998     {
1999     case sci_list:
2000         pcstClass = g_SCILAB_CLASS_LIST;
2001         break;
2002     case sci_tlist:
2003         pcstClass = g_SCILAB_CLASS_TLIST;
2004         break;
2005     case sci_mlist:
2006         pcstClass = g_SCILAB_CLASS_MLIST;
2007         break;
2008     default:
2009         return 1;
2010     }
2011
2012     if (_iNbItem == 0)
2013     {
2014         //tips for empty list
2015         //insert a fake refence in the array, value = 0
2016
2017         hobj_ref_t pvList[1];
2018
2019         pvList[0] = 0;
2020         //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
2021
2022         dims[0] = 1;
2023         space = H5Screate_simple(1, dims, NULL);
2024         if (space < 0)
2025         {
2026             return -1;
2027         }
2028
2029         //Create the dataset and write the array data to it.
2030         iCompress = enableCompression(9, 1, dims);
2031         dset = H5Dcreate(_iFile, _pstListName, H5T_STD_REF_OBJ, space, iCompress);
2032         if (dset < 0)
2033         {
2034             return -1;
2035         }
2036
2037         status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, (hobj_ref_t *) pvList);
2038         if (status < 0)
2039         {
2040             return -1;
2041         }
2042
2043         //Add attribute SCILAB_Class = string to dataset
2044         status = addAttribute(dset, g_SCILAB_CLASS, pcstClass);
2045         if (status < 0)
2046         {
2047             return -1;
2048         }
2049
2050         status = addAttribute(dset, g_SCILAB_CLASS_EMPTY, "true");
2051         if (status < 0)
2052         {
2053             return -1;
2054         }
2055     }
2056     else
2057     {
2058         //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
2059         space = H5Screate_simple(1, dims, NULL);
2060         if (status < 0)
2061         {
2062             return -1;
2063         }
2064
2065         //Create the dataset and write the array data to it.
2066         iCompress = enableCompression(9, 1, dims);
2067         dset = H5Dcreate(_iFile, _pstListName, H5T_STD_REF_OBJ, space, iCompress);
2068         if (dset < 0)
2069         {
2070             return -1;
2071         }
2072
2073         status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, (hobj_ref_t *) _pvList);
2074         if (status < 0)
2075         {
2076             return -1;
2077         }
2078
2079         //Add attribute SCILAB_Class = string to dataset
2080         status = addAttribute(dset, g_SCILAB_CLASS, pcstClass);
2081         if (status < 0)
2082         {
2083             return -1;
2084         }
2085
2086         status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
2087         if (status < 0)
2088         {
2089             return -1;
2090         }
2091     }
2092
2093     //Close and release resources.
2094     status = H5Dclose(dset);
2095     if (status < 0)
2096     {
2097         return -1;
2098     }
2099
2100     status = H5Sclose(space);
2101     if (status < 0)
2102     {
2103         return -1;
2104     }
2105
2106     FREE(_pvList);
2107     return 0;
2108 }