Revert "Bug HDF5: Correct the write of emptymatrix test_run('optimization','bug_7093')"
[scilab.git] / scilab / modules / hdf5 / src / c / h5_readDataFromFile.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 #ifndef _MSC_VER
16 #include <sys/time.h>
17 #else
18 #include <windows.h>
19 //#include <winbase.h>
20 #endif
21
22 #include <string.h>
23 #include <hdf5.h>
24 #include <stdlib.h>
25 #include "MALLOC.h"
26 #include "sci_types.h"
27 #include "stack3.h"
28 #include "h5_attributeConstants.h"
29 #include "h5_readDataFromFile.h"
30
31 //#define TIME_DEBUG
32
33 static herr_t find_attr_by_name(hid_t loc_id, const char *name, void *data)
34 {
35     return !strcmp(name, (const char *)data);
36 }
37
38 /************************************************************
39
40 Operator function.  Prints the name and type of the object
41 being examined.
42
43 ************************************************************/
44 static herr_t op_func(hid_t loc_id, const char *name, void *operator_data)
45 {
46     H5G_stat_t statbuf;
47     herr_t status = 0;
48     int *pDataSetId = (int*)operator_data;
49
50     /*
51      * Get type of the object and return only datasetId
52      * through operator_data.
53      */
54     status = H5Gget_objinfo(loc_id, name, 0, &statbuf);
55     if (status < 0)
56     {
57         return -1;
58     }
59
60     switch (statbuf.type)
61     {
62         case H5G_GROUP:
63             break;
64         case H5G_DATASET:
65             *pDataSetId = H5Dopen(loc_id, name);
66             break;
67         case H5G_TYPE:
68             break;
69         default:
70             break;
71     }
72
73     return 0;
74 }
75
76 static int readIntAttribute(int _iDatasetId, const char *_pstName)
77 {
78     hid_t iAttributeId;
79     herr_t status;
80     int iVal = -1;
81
82     if (H5Aiterate(_iDatasetId, NULL, find_attr_by_name, (void *)_pstName))
83     {
84         iAttributeId = H5Aopen_name(_iDatasetId, _pstName);
85         if (iAttributeId < 0)
86         {
87             return -1;
88         }
89
90         status = H5Aread(iAttributeId, H5T_NATIVE_INT, &iVal);
91         if (status < 0)
92         {
93             return -1;
94         }
95
96         status = H5Aclose(iAttributeId);
97         if (status < 0)
98         {
99             return -1;
100         }
101     }
102     return iVal;
103 }
104
105 /*
106 ** WARNING : this function returns an allocated value that must be freed.
107 */
108 static char* readAttribute(int _iDatasetId, const char *_pstName)
109 {
110     hid_t iAttributeId;
111     hid_t iFileType, memtype, iSpace;
112     herr_t status;
113     hsize_t dims[1];
114     size_t iDim;
115
116     char *pstValue = NULL;
117
118     if (H5Aiterate(_iDatasetId, NULL, find_attr_by_name, (void *)_pstName))
119     {
120         iAttributeId = H5Aopen_name(_iDatasetId, _pstName);
121         if (iAttributeId < 0)
122         {
123             return NULL;
124         }
125         /*
126          * Get the datatype and its size.
127          */
128         iFileType = H5Aget_type(iAttributeId);
129         iDim = H5Tget_size(iFileType);
130         iDim++;                 /* Make room for null terminator */
131
132         /*
133          * Get dataspace and allocate memory for read buffer.  This is a
134          * two dimensional attribute so the dynamic allocation must be done
135          * in steps.
136          */
137         iSpace = H5Aget_space(iAttributeId);
138         if (iSpace < 0)
139         {
140             return NULL;
141         }
142
143         status = H5Sget_simple_extent_dims(iSpace, dims, NULL);
144         if (status < 0)
145         {
146             return NULL;
147         }
148
149         /*
150          * Allocate space for string data.
151          */
152         pstValue = (char *)MALLOC((size_t) ((dims[0] * iDim + 1) * sizeof(char)));
153
154         /*
155          * Create the memory datatype.
156          */
157         memtype = H5Tcopy(H5T_C_S1);
158         status = H5Tset_size(memtype, iDim);
159         if (status < 0)
160         {
161             return NULL;
162         }
163
164         /*
165          * Read the data.
166          */
167         status = H5Aread(iAttributeId, memtype, pstValue);
168         if (status < 0)
169         {
170             FREE(pstValue);
171             return NULL;
172         }
173
174         status = H5Tclose(memtype);
175         if (status < 0)
176         {
177             FREE(pstValue);
178             return NULL;
179         }
180
181         status = H5Sclose(iSpace);
182         if (status < 0)
183         {
184             FREE(pstValue);
185             return NULL;
186         }
187
188         status = H5Tclose(iFileType);
189         if (status < 0)
190         {
191             FREE(pstValue);
192             return NULL;
193         }
194
195         status = H5Aclose(iAttributeId);
196         if (status < 0)
197         {
198             FREE(pstValue);
199             return NULL;
200         }
201     }
202     return pstValue;
203
204 }
205
206 static int checkAttribute(int _iDatasetId, char *_pstAttribute, char *_pstValue)
207 {
208     int iRet = 0;
209     char *pstScilabClass = NULL;
210
211     //status = H5Giterate (_iFile, "/", NULL, op_func, &iDatasetId);
212     pstScilabClass = readAttribute(_iDatasetId, _pstAttribute);
213     if (pstScilabClass != NULL && strcmp(pstScilabClass, _pstValue) == 0)
214     {
215         iRet = 1;
216     }
217     if (pstScilabClass)
218     {
219         FREE(pstScilabClass);
220     }
221     return iRet;
222 }
223
224 /*
225 ** WARNING : this function returns an allocated value that must be freed.
226 */
227 char* getScilabVersionAttribute(int _iFile)
228 {
229     return readAttribute(_iFile, g_SCILAB_CLASS_SCI_VERSION);
230 }
231
232 int getSODFormatAttribute(int _iFile)
233 {
234     return readIntAttribute(_iFile, g_SCILAB_CLASS_SOD_VERSION);
235 }
236
237 int getDatasetInfo(int _iDatasetId, int* _iComplex, int* _iDims, int* _piDims)
238 {
239     int iSize = 1;
240     hid_t data_type;
241     H5T_class_t data_class;
242     hid_t space = H5Dget_space(_iDatasetId);
243     if(space < 0)
244     {
245         return -1;
246     }
247
248     data_type = H5Dget_type(_iDatasetId);
249     data_class = H5Tget_class(data_type);
250     if(data_class == H5T_COMPOUND) 
251     {
252         *_iComplex = 1;
253     }
254     else if(data_class == H5T_REFERENCE)
255     {
256         *_iComplex = isComplexData(_iDatasetId);
257     }
258     else
259     {
260         *_iComplex = 0;
261     }
262
263     *_iDims = H5Sget_simple_extent_ndims(space);
264     if(*_iDims < 0)
265     {
266         H5Sclose(space);
267         return -1;
268     }
269
270     if(_piDims != 0)
271     {
272         int i = 0;
273         hsize_t* dims = (hsize_t*)MALLOC(sizeof(hsize_t) * *_iDims);
274         if(H5Sget_simple_extent_dims(space, dims, NULL) < 0)
275         {
276             return -1;
277         }
278
279         //reverse dimensions
280         for(i = 0 ; i < *_iDims ; i++)
281         {//reverse dimensions to improve rendering in external tools
282             _piDims[i] = (int)dims[*_iDims - 1 - i];
283             iSize *= _piDims[i];
284         }
285
286     }
287
288     H5Sclose(space);
289     return iSize;
290 }
291
292 int getSparseDimension(int _iDatasetId, int *_piRows, int *_piCols, int *_piNbItem)
293 {
294     int iRet = 0;
295     int iDummy = 0;
296
297     //get number of item in the sparse matrix
298     getDatasetDims(_iDatasetId, _piRows, _piCols);
299     *_piNbItem = readIntAttribute(_iDatasetId, g_SCILAB_CLASS_ITEMS);
300
301     return iRet;
302 }
303
304 static int isEmptyDataset(int _iDatasetId)
305 {
306     return checkAttribute(_iDatasetId, (char *)g_SCILAB_CLASS_EMPTY, "true");
307 }
308
309 int isComplexData(int _iDatasetId)
310 {
311     return checkAttribute(_iDatasetId, (char *)g_SCILAB_CLASS_COMPLEX, "true");
312 }
313
314 int getDatasetPrecision(int _iDatasetId, int *_piPrec)
315 {
316     int iRet = 0;
317     char *pstScilabClass = readAttribute(_iDatasetId, g_SCILAB_CLASS_PREC);
318
319     if (pstScilabClass == NULL)
320     {
321         return -1;
322     }
323     else if (strcmp(pstScilabClass, "8") == 0)
324     {
325         *_piPrec = SCI_INT8;
326     }
327     else if (strcmp(pstScilabClass, "u8") == 0)
328     {
329         *_piPrec = SCI_UINT8;
330     }
331     else if (strcmp(pstScilabClass, "16") == 0)
332     {
333         *_piPrec = SCI_INT16;
334     }
335     else if (strcmp(pstScilabClass, "u16") == 0)
336     {
337         *_piPrec = SCI_UINT16;
338     }
339     else if (strcmp(pstScilabClass, "32") == 0)
340     {
341         *_piPrec = SCI_INT32;
342     }
343     else if (strcmp(pstScilabClass, "u32") == 0)
344     {
345         *_piPrec = SCI_UINT32;
346     }
347     else if (strcmp(pstScilabClass, "64") == 0)
348     {
349         *_piPrec = SCI_INT64;
350     }
351     else if (strcmp(pstScilabClass, "u64") == 0)
352     {
353         *_piPrec = SCI_UINT64;
354     }
355     else
356     {
357         iRet = 1;
358     }
359
360     FREE(pstScilabClass);
361     return iRet;
362 }
363
364 int getVariableNames(int _iFile, char **pstNameList)
365 {
366     hsize_t i = 0;
367     hsize_t iCount = 0;
368     herr_t status = 0;
369     int iNbItem = 0;
370
371     status = H5Gget_num_objs(_iFile, &iCount);
372     if (status != 0)
373     {
374         return 0;
375     }
376
377     for (i = 0; i < iCount; i++)
378     {
379         if (H5Gget_objtype_by_idx(_iFile, i) == H5G_DATASET)
380         {
381             if (pstNameList != NULL)
382             {
383                 int iLen = 0;
384
385                 iLen = (int)H5Gget_objname_by_idx(_iFile, i, NULL, iLen);
386                 pstNameList[iNbItem] = (char *)MALLOC(sizeof(char) * (iLen + 1));   //null terminated
387                 H5Gget_objname_by_idx(_iFile, i, pstNameList[iNbItem], iLen + 1);
388             }
389             iNbItem++;
390         }
391     }
392     return iNbItem;
393 }
394
395 int getDataSetIdFromName(int _iFile, char *_pstName)
396 {
397     return H5Dopen(_iFile, _pstName);
398 }
399
400 int getDataSetId(int _iFile)
401 {
402     herr_t status = 0;
403     int iDatasetId = 0;
404
405     /*
406      * Begin iteration.
407      */
408     status = H5Giterate(_iFile, "/", NULL, op_func, &iDatasetId);
409     if (status < 0)
410     {
411         return -1;
412     }
413
414     return iDatasetId;
415 }
416
417 int getListDims(int _iDatasetId, int *_piItems)
418 {
419     /*
420      * Get dataspace and dimensions of the dataset. This is a
421      * two dimensional dataset.
422      */
423     if (isEmptyDataset(_iDatasetId))
424     {
425         *_piItems = 0;
426     }
427     else
428     {
429         *_piItems = readIntAttribute(_iDatasetId, g_SCILAB_CLASS_ITEMS);
430     }
431     return 0;
432 }
433
434 int getDatasetDims(int _iDatasetId, int *_piRows, int *_piCols)
435 {
436     /*
437      * Get dataspace and dimensions of the dataset. This is a
438      * two dimensional dataset.
439      */
440     if (isEmptyDataset(_iDatasetId))
441     {
442         *_piCols = 0;
443         *_piRows = 0;
444     }
445     else
446     {
447         *_piRows = readIntAttribute(_iDatasetId, g_SCILAB_CLASS_ROWS);
448         *_piCols = readIntAttribute(_iDatasetId, g_SCILAB_CLASS_COLS);
449     }
450     return 0;
451 }
452
453 int readDoubleMatrix(int _iDatasetId, double *_pdblData)
454 {
455     herr_t status;
456
457     //Read the data.
458     status = H5Dread(_iDatasetId, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pdblData);
459     if (status < 0)
460     {
461         return -1;
462     }
463
464     status = H5Dclose(_iDatasetId);
465     if (status < 0)
466     {
467         return -1;
468     }
469
470     return 0;
471 }
472
473 int readDoubleComplexMatrix(int _iDatasetId, double *_pdblReal, double *_pdblImg)
474 {
475     hid_t compoundId;
476     herr_t status;
477     int iDims = 0;
478     int* piDims = NULL;
479     int iComplex = 0;
480     int iSize = 1;
481     doublecomplex* pData = NULL;
482     int i = 0;
483
484     /*define compound dataset*/
485     compoundId = H5Tcreate(H5T_COMPOUND, sizeof(doublecomplex));
486     H5Tinsert(compoundId, "real", HOFFSET(doublecomplex, r), H5T_NATIVE_DOUBLE);
487     H5Tinsert(compoundId, "imag", HOFFSET(doublecomplex, i), H5T_NATIVE_DOUBLE);
488
489     //get dimension from dataset
490     getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
491     piDims = (int*)MALLOC(sizeof(int) * iDims);
492     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
493
494     FREE(piDims);
495     //alloc temp array
496     pData = (doublecomplex*)MALLOC(sizeof(doublecomplex) * iSize);
497     //Read the data.
498     status = H5Dread(_iDatasetId, compoundId, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
499     if (status < 0)
500     {
501         return -1;
502     }
503
504     
505     vGetPointerFromDoubleComplex(pData, iSize, _pdblReal, _pdblImg);
506     FREE(pData);
507     status = H5Dclose(_iDatasetId);
508     if (status < 0)
509     {
510         return -1;
511     }
512
513     return 0;
514 }
515
516 int readEmptyMatrix(int _iDatasetId)
517 {
518     //close dataset
519     herr_t status;
520
521     status = H5Dclose(_iDatasetId);
522     if (status < 0)
523     {
524         return -1;
525     }
526
527     return 0;
528 }
529
530 int readBooleanMatrix(int _iDatasetId, int *_piData)
531 {
532     herr_t status = 0;
533
534     /*
535      * Read the data.
536      */
537     status = H5Dread(_iDatasetId, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
538     if (status < 0)
539     {
540         return -1;
541     }
542
543     status = H5Dclose(_iDatasetId);
544     if (status < 0)
545     {
546         return -1;
547     }
548
549     return 0;
550 }
551
552 int readStringMatrix(int _iDatasetId, char **_pstData)
553 {
554     herr_t status;
555     hid_t typeId;
556
557     typeId = H5Tcopy(H5T_C_S1);
558     status = H5Tset_size(typeId, H5T_VARIABLE);
559     if (status < 0)
560     {
561         return -1;
562     }
563
564     //Read the data.
565     status = H5Dread(_iDatasetId, typeId, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pstData);
566     if (status < 0)
567     {
568         return -1;
569     }
570
571     status = H5Tclose(typeId);
572     if (status < 0)
573     {
574         return -1;
575     }
576
577     status = H5Dclose(_iDatasetId);
578     if (status < 0)
579     {
580         return -1;
581     }
582
583     return 0;
584 }
585
586 static int readComplexPoly(int _iDatasetId, int *_piNbCoef, double **_pdblReal, double **_pdblImg)
587 {
588     int iComplex = 0;
589     int iSize = 0;
590     int iDims = 0;
591     //Get the datatype and its size.
592
593     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, _piNbCoef);
594
595     //Allocate space for string data.
596     *_pdblReal = (double *)MALLOC(*_piNbCoef * sizeof(double));
597     *_pdblImg = (double *)MALLOC(*_piNbCoef * sizeof(double));
598
599     //Read the data and return result.
600     return readDoubleComplexMatrix(_iDatasetId, *_pdblReal, *_pdblImg);
601 }
602
603 static int readPoly(int _iDatasetId, int *_piNbCoef, double **_pdblData)
604 {
605     int iComplex = 0;
606     int iSize = 0;
607     int iDims = 0;
608     //Get the datatype and its size.
609     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, _piNbCoef);
610
611     *_pdblData = (double *)MALLOC(*_piNbCoef * sizeof(double));
612
613     //Read the data and return result.
614     return readDoubleMatrix(_iDatasetId, *_pdblData);
615 }
616
617 int readCommonPolyMatrix(int _iDatasetId, char *_pstVarname, int _iComplex, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal, double **_pdblImg)
618 {
619     int i = 0;
620     hid_t obj = 0;
621     char *pstVarName = 0;
622     hsize_t* piDims = NULL;
623     hobj_ref_t *pData = NULL;
624     herr_t status;
625     int iSize = 1;
626
627     for(i = 0 ; i < _iDims ; i++)
628     {
629         iSize *= _piDims[i];
630     }
631
632     pData = (hobj_ref_t *) MALLOC(iSize * sizeof(hobj_ref_t));
633
634     /*
635      * Read the data.
636      */
637     status = H5Dread(_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
638     if (status < 0)
639     {
640         FREE(pData);
641         return -1;
642     }
643
644     for (i = 0; i < iSize; i++)
645     {
646         /*
647          * Open the referenced object, get its name and type.
648          */
649         obj = H5Rdereference(_iDatasetId, H5R_OBJECT, &pData[i]);
650         if (_iComplex)
651         {
652             status = readComplexPoly(obj, &_piNbCoef[i], &_pdblReal[i], &_pdblImg[i]);
653         }
654         else
655         {
656             status = readPoly(obj, &_piNbCoef[i], &_pdblReal[i]);
657         }
658
659         if (status < 0)
660         {
661             FREE(pData);
662             return -1;
663         }
664     }
665
666     pstVarName = readAttribute(_iDatasetId, g_SCILAB_CLASS_VARNAME);
667     strcpy(_pstVarname, pstVarName);
668     FREE(pstVarName);
669     status = H5Dclose(_iDatasetId);
670     if (status < 0)
671     {
672         FREE(pData);
673         return -1;
674     }
675
676     FREE(pData);
677
678     return 0;
679 }
680
681 int readPolyMatrix(int _iDatasetId, char *_pstVarname, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblData)
682 {
683     return readCommonPolyMatrix(_iDatasetId, _pstVarname, 0, _iDims, _piDims, _piNbCoef, _pdblData, NULL);
684 }
685
686 int readPolyComplexMatrix(int _iDatasetId, char *_pstVarname, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal, double **_pdblImg)
687 {
688     return readCommonPolyMatrix(_iDatasetId, _pstVarname, 1, _iDims, _piDims, _piNbCoef, _pdblReal, _pdblImg);
689 }
690
691 int readInteger8Matrix(int _iDatasetId, char *_pcData)
692 {
693     herr_t status = 0;
694
695     /*
696      * Read the data.
697      */
698     status = H5Dread(_iDatasetId, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pcData);
699     if (status < 0)
700     {
701         return -1;
702     }
703
704     status = H5Dclose(_iDatasetId);
705     if (status < 0)
706     {
707         return -1;
708     }
709
710     return 0;
711 }
712
713 int readInteger16Matrix(int _iDatasetId, short *_psData)
714 {
715     herr_t status = 0;
716
717     /*
718      * Read the data.
719      */
720     status = H5Dread(_iDatasetId, H5T_NATIVE_INT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _psData);
721     if (status < 0)
722     {
723         return -1;
724     }
725
726     status = H5Dclose(_iDatasetId);
727     if (status < 0)
728     {
729         return -1;
730     }
731
732     return 0;
733 }
734
735 int readInteger32Matrix(int _iDatasetId, int *_piData)
736 {
737     herr_t status = 0;
738
739     /*
740      * Read the data.
741      */
742     status = H5Dread(_iDatasetId, H5T_NATIVE_INT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
743     if (status < 0)
744     {
745         return -1;
746     }
747
748     status = H5Dclose(_iDatasetId);
749     if (status < 0)
750     {
751         return -1;
752     }
753
754     return 0;
755 }
756
757 int readInteger64Matrix(int _iDatasetId, long long *_pllData)
758 {
759     herr_t status = 0;
760
761     /*
762      * Read the data.
763      */
764     status = H5Dread(_iDatasetId, H5T_NATIVE_INT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pllData);
765     if (status < 0)
766     {
767         return -1;
768     }
769
770     status = H5Dclose(_iDatasetId);
771     if (status < 0)
772     {
773         return -1;
774     }
775
776     return 0;
777 }
778
779 int readUnsignedInteger8Matrix(int _iDatasetId, unsigned char *_pucData)
780 {
781     herr_t status = 0;
782
783     /*
784      * Read the data.
785      */
786     status = H5Dread(_iDatasetId, H5T_NATIVE_UINT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pucData);
787     if (status < 0)
788     {
789         return -1;
790     }
791
792     status = H5Dclose(_iDatasetId);
793     if (status < 0)
794     {
795         return -1;
796     }
797
798     return 0;
799 }
800
801 int readUnsignedInteger16Matrix(int _iDatasetId, unsigned short *_pusData)
802 {
803     herr_t status = 0;
804
805     /*
806      * Read the data.
807      */
808     status = H5Dread(_iDatasetId, H5T_NATIVE_UINT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pusData);
809     if (status < 0)
810     {
811         return -1;
812     }
813
814     status = H5Dclose(_iDatasetId);
815     if (status < 0)
816     {
817         return -1;
818     }
819
820     return 0;
821 }
822
823 int readUnsignedInteger32Matrix(int _iDatasetId, unsigned int *_puiData)
824 {
825     herr_t status = 0;
826
827     /*
828      * Read the data.
829      */
830     status = H5Dread(_iDatasetId, H5T_NATIVE_UINT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _puiData);
831     if (status < 0)
832     {
833         return -1;
834     }
835
836     status = H5Dclose(_iDatasetId);
837     if (status < 0)
838     {
839         return -1;
840     }
841
842     return 0;
843 }
844
845 int readUnsignedInteger64Matrix(int _iDatasetId, unsigned long long *_pullData)
846 {
847     herr_t status = 0;
848
849     /*
850      * Read the data.
851      */
852     status = H5Dread(_iDatasetId, H5T_NATIVE_UINT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pullData);
853     if (status < 0)
854     {
855         return -1;
856     }
857
858     status = H5Dclose(_iDatasetId);
859     if (status < 0)
860     {
861         return -1;
862     }
863
864     return 0;
865 }
866
867 int readCommonSparseComplexMatrix(int _iDatasetId, int _iComplex, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos, double *_pdblReal, double *_pdblImg)
868 {
869     hid_t obj = 0;
870     hobj_ref_t pRef[3] = {0};
871     herr_t status;
872
873     /*
874      * Read the data.
875      */
876     status = H5Dread(_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pRef);
877     if (status < 0)
878     {
879         return -1;
880     }
881
882     //read Row data
883     obj = H5Rdereference(_iDatasetId, H5R_OBJECT, &pRef[0]);
884     status = readInteger32Matrix(obj, _piNbItemRow);
885     if (status < 0)
886     {
887         return -1;
888     }
889
890     //read cols data
891     obj = H5Rdereference(_iDatasetId, H5R_OBJECT, &pRef[1]);
892     status = readInteger32Matrix(obj, _piColPos);
893     if (status < 0)
894     {
895         return -1;
896     }
897
898     //read sparse data
899     obj = H5Rdereference(_iDatasetId, H5R_OBJECT, &pRef[2]);
900
901     if (_iComplex)
902     {
903         status = readDoubleComplexMatrix(obj, _pdblReal, _pdblImg);
904     }
905     else
906     {
907         status = readDoubleMatrix(obj, _pdblReal);
908     }
909
910     if (status < 0)
911     {
912         return -1;
913     }
914
915     return 0;
916 }
917
918 int readSparseMatrix(int _iDatasetId, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos, double *_pdblReal)
919 {
920     return readCommonSparseComplexMatrix(_iDatasetId, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
921 }
922
923 int readSparseComplexMatrix(int _iDatasetId, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos, double *_pdblReal, double *_pdblImg)
924 {
925     return readCommonSparseComplexMatrix(_iDatasetId, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
926 }
927
928 int readBooleanSparseMatrix(int _iDatasetId, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos)
929 {
930     hid_t obj = 0;
931     hobj_ref_t pRef[2] = {0};
932     herr_t status;
933
934     /*
935      * Read the data.
936      */
937     status = H5Dread(_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pRef);
938     if (status < 0)
939     {
940         return -1;
941     }
942
943     //read Row data
944     obj = H5Rdereference(_iDatasetId, H5R_OBJECT, &pRef[0]);
945     status = readInteger32Matrix(obj, _piNbItemRow);
946     if (status < 0)
947     {
948         return -1;
949     }
950
951     //read cols data
952     obj = H5Rdereference(_iDatasetId, H5R_OBJECT, &pRef[1]);
953     status = readInteger32Matrix(obj, _piColPos);
954     if (status < 0)
955     {
956         return -1;
957     }
958
959     return 0;
960 }
961
962 int getScilabTypeFromDataSet(int _iDatasetId)
963 {
964     int iVarType = 0;
965     char *pstScilabClass = readAttribute(_iDatasetId, g_SCILAB_CLASS);
966
967     if (pstScilabClass == NULL)
968     {
969         return unknow_type;
970     }
971     /* HDF5 Float type + SCILAB_Class = double <=> double */
972     if (strcmp(pstScilabClass, g_SCILAB_CLASS_DOUBLE) == 0)
973     {
974         iVarType = sci_matrix;
975     }
976     else if (strcmp(pstScilabClass, g_SCILAB_CLASS_STRING) == 0)
977     {
978         iVarType = sci_strings;
979     }
980     else if (strcmp(pstScilabClass, g_SCILAB_CLASS_BOOLEAN) == 0)
981     {
982         iVarType = sci_boolean;
983     }
984     else if (strcmp(pstScilabClass, g_SCILAB_CLASS_BOOLEAN) == 0)
985     {
986         iVarType = sci_boolean;
987     }
988     else if (strcmp(pstScilabClass, g_SCILAB_CLASS_POLY) == 0)
989     {
990         iVarType = sci_poly;
991     }
992     else if (strcmp(pstScilabClass, g_SCILAB_CLASS_INT) == 0)
993     {
994         iVarType = sci_ints;
995     }
996     else if (strcmp(pstScilabClass, g_SCILAB_CLASS_SPARSE) == 0)
997     {
998         iVarType = sci_sparse;
999     }
1000     else if (strcmp(pstScilabClass, g_SCILAB_CLASS_BSPARSE) == 0)
1001     {
1002         iVarType = sci_boolean_sparse;
1003     }
1004     else if (strcmp(pstScilabClass, g_SCILAB_CLASS_LIST) == 0)
1005     {
1006         iVarType = sci_list;
1007     }
1008     else if (strcmp(pstScilabClass, g_SCILAB_CLASS_TLIST) == 0)
1009     {
1010         iVarType = sci_tlist;
1011     }
1012     else if (strcmp(pstScilabClass, g_SCILAB_CLASS_MLIST) == 0)
1013     {
1014         iVarType = sci_mlist;
1015     }
1016     else if (strcmp(pstScilabClass, g_SCILAB_CLASS_VOID) == 0)
1017     {
1018         iVarType = sci_void;
1019     }
1020     else if (strcmp(pstScilabClass, g_SCILAB_CLASS_UNDEFINED) == 0)
1021     {
1022         iVarType = sci_undefined;
1023     }
1024
1025     FREE(pstScilabClass);
1026     return iVarType;
1027 }
1028
1029 int getListItemReferences(int _iDatasetId, hobj_ref_t ** _piItemRef)
1030 {
1031     int iItem = 0;
1032     herr_t status = 0;
1033
1034     getListDims(_iDatasetId, &iItem);
1035
1036     *_piItemRef = (hobj_ref_t *) MALLOC(iItem * sizeof(hobj_ref_t));
1037
1038     status = H5Dread(_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, *_piItemRef);
1039     if (status < 0)
1040     {
1041         return -1;
1042     }
1043
1044     return 0;
1045 }
1046
1047 int getListItemDataset(int _iDatasetId, void *_piItemRef, int _iItemPos, int *_piItemDataset)
1048 {
1049     hobj_ref_t poRef = ((hobj_ref_t *) _piItemRef)[_iItemPos];
1050
1051     *_piItemDataset = H5Rdereference(_iDatasetId, H5R_OBJECT, &poRef);
1052
1053     if (*_piItemDataset == 0)
1054     {
1055         return -1;
1056     }
1057
1058     return 0;
1059 }
1060
1061 int deleteListItemReferences(int _iDatasetId, void *_piItemRef)
1062 {
1063     herr_t status;
1064
1065     if (_piItemRef)
1066     {
1067         hobj_ref_t *poRef = (hobj_ref_t *) _piItemRef;
1068
1069         FREE(poRef);
1070     }
1071
1072     status = H5Dclose(_iDatasetId);
1073     if (status < 0)
1074     {
1075         return -1;
1076     }
1077
1078     return 0;
1079 }