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