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