strindex should return [] when first input argument is an empty string.
[scilab.git] / scilab / modules / hdf5 / sci_gateway / cpp / sci_import_from_hdf5.cpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2009 - DIGITEO - Antoine ELIAS
4 *
5 * This file must be used under the terms of the CeCILL.
6 * This source file is licensed as described in the file COPYING, which
7 * you should have received as part of this distribution.  The terms
8 * are also available at
9 * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
10 *
11 */
12
13 #include <hdf5.h>
14 extern "C"
15 {
16 #include <string.h>
17 #include "gw_hdf5.h"
18 #include "MALLOC.h"
19 #include "Scierror.h"
20 #include "localization.h"
21 #include "sciprint.h"
22 #include "api_scilab.h"
23 #include "../../../call_scilab/includes/call_scilab.h"
24 #include "h5_fileManagement.h"
25 #include "h5_readDataFromFile.h"
26 #include "h5_attributeConstants.h"
27 #include "expandPathVariable.h"
28 #include "stdlib.h"
29 }
30
31 #include "import_from_hdf5_v1.hxx"
32
33 static bool import_variable(int* pvCtx, int _iFile, char* _pstVarName);
34 static bool import_data(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
35 static bool import_double(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
36 static bool import_string(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
37 static bool import_boolean(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
38 static bool import_integer(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
39 static bool import_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
40 static bool import_boolean_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
41 static bool import_poly(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
42 static bool import_list(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname);
43 static bool import_void(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
44 static bool import_undefined(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
45
46 int sci_import_from_hdf5(char *fname, int* pvApiCtx)
47 {
48     SciErr sciErr;
49
50     int* piAddr = NULL;
51     char* pstFilename = NULL;
52     char* pstExpandedFilename = NULL;
53     bool bImport = true;
54     const int nbIn = nbInputArgument(pvApiCtx);
55     int iSelectedVar = nbIn - 1;
56
57     CheckInputArgumentAtLeast(pvApiCtx , 1);
58     CheckOutputArgument(pvApiCtx, 1, 1);
59
60     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
61     if (sciErr.iErr)
62     {
63         printError(&sciErr, 0);
64         return 1;
65     }
66
67     if (getAllocatedSingleString(pvApiCtx, piAddr, &pstFilename))
68     {
69         Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
70         return 1;
71     }
72
73     //open hdf5 file
74     pstExpandedFilename = expandPathVariable(pstFilename);
75     int iFile = openHDF5File(pstExpandedFilename, 0);
76     if (iFile < 0)
77     {
78         Scierror(999, _("%s: Unable to open file: %s\n"), fname, pstFilename);
79         FREE(pstExpandedFilename);
80         FREE(pstFilename);
81         return 1;
82     }
83
84     FREE(pstExpandedFilename);
85     FREE(pstFilename);
86
87     //manage version information
88     int iVersion = getSODFormatAttribute(iFile);
89     if (iVersion != SOD_FILE_VERSION)
90     {
91         if (iVersion > SOD_FILE_VERSION)
92         {
93             //can't read file with version newer that me !
94             Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname, SOD_FILE_VERSION, iVersion);
95             return 1;
96         }
97         else
98         {
99             //call older import functions and exit or ... EXIT !
100             if (iVersion == 1 || iVersion == -1)
101             {
102                 //sciprint("old sci_import_from_hdf5_v1\n");
103                 return sci_import_from_hdf5_v1(fname, pvApiCtx);
104             }
105         }
106     }
107
108     if (iSelectedVar)
109     {
110         //selected variable
111         char* pstVarName = NULL;
112         for (int i = 0 ; i < iSelectedVar ; i++)
113         {
114             sciErr = getVarAddressFromPosition(pvApiCtx, i + 2, &piAddr);
115             if (sciErr.iErr)
116             {
117                 printError(&sciErr, 0);
118                 return 1;
119             }
120
121             if (getAllocatedSingleString(pvApiCtx, piAddr, &pstVarName))
122             {
123                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, i + 1);
124                 return 1;
125             }
126
127             if (import_variable(pvApiCtx, iFile, pstVarName) == false)
128             {
129                 bImport = false;
130                 break;
131             }
132
133             FREE(pstVarName);
134         }
135     }
136     else
137     {
138         //all variables
139         int iNbItem = 0;
140         iNbItem = getVariableNames(iFile, NULL);
141         if (iNbItem != 0)
142         {
143             char **pstVarNameList = (char **)MALLOC(sizeof(char *) * iNbItem);
144
145             iNbItem = getVariableNames(iFile, pstVarNameList);
146
147             //import all data
148             for (int i = 0; i < iNbItem; i++)
149             {
150                 if (import_variable(pvApiCtx, iFile, pstVarNameList[i]) == false)
151                 {
152                     bImport = false;
153                     break;
154                 }
155             }
156         }
157     }
158     //close the file
159     closeHDF5File(iFile);
160
161     int *piReturn = NULL;
162
163     sciErr = allocMatrixOfBoolean(pvApiCtx, nbIn + 1, 1, 1, &piReturn);
164     if (sciErr.iErr)
165     {
166         printError(&sciErr, 0);
167         return 1;
168     }
169
170     if (bImport == true)
171     {
172         piReturn[0] = 1;
173     }
174     else
175     {
176         piReturn[0] = 0;
177     }
178
179     AssignOutputVariable(pvApiCtx, 1) = nbIn + 1;
180     ReturnArguments(pvApiCtx);
181
182     //  printf("End gateway !!!\n");
183     return 0;
184 }
185
186 static bool import_variable(int* pvCtx, int _iFile, char* _pstVarName)
187 {
188     int iDataSetId = getDataSetIdFromName(_iFile, _pstVarName);
189     if (iDataSetId <= 0)
190     {
191         return false;
192     }
193
194     return import_data(pvCtx, iDataSetId, 0, NULL, _pstVarName);
195 }
196
197 static bool import_data(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
198 {
199     bool bRet = false;
200
201     //get var type
202     int iVarType = getScilabTypeFromDataSet(_iDatasetId);
203
204     switch (iVarType)
205     {
206         case sci_matrix:
207         {
208             bRet = import_double(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
209             break;
210         }
211         case sci_strings:
212         {
213             bRet = import_string(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
214             break;
215         }
216         case sci_list:
217         case sci_tlist:
218         case sci_mlist:
219         {
220             bRet = import_list(pvCtx, _iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
221             break;
222         }
223         case sci_boolean:
224         {
225             bRet = import_boolean(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
226             break;
227         }
228         case sci_poly:
229         {
230             bRet = import_poly(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
231             break;
232         }
233         case sci_ints:
234         {
235             bRet = import_integer(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
236             break;
237         }
238         case sci_sparse:
239         {
240             bRet = import_sparse(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
241             break;
242         }
243         case sci_boolean_sparse:
244         {
245             bRet = import_boolean_sparse(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
246             break;
247         }
248         case sci_void:             //void item only on list variable
249         {
250             bRet = import_void(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
251             break;
252         }
253         case sci_undefined:        //undefined item only on list variable
254         {
255             bRet = import_undefined(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
256             break;
257         }
258         default:
259         {
260             Scierror(999, _("%s: Invalid HDF5 Scilab format.\n"), "import_from_hdf5");
261         }
262     }
263     return bRet;
264 }
265
266 static bool import_void(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
267 {
268     SciErr sciErr;
269
270     if (_piAddress)
271     {
272         sciErr = createVoidInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos);
273     }
274     else
275     {
276         return false;
277     }
278
279     if (sciErr.iErr)
280     {
281         printError(&sciErr, 0);
282         return false;
283     }
284
285     //close void dataset
286     closeDataSet(_iDatasetId);
287     return true;
288 }
289
290 static bool import_undefined(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
291 {
292     SciErr sciErr;
293
294     if (_piAddress)
295     {
296         sciErr = createUndefinedInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos);
297     }
298     else
299     {
300         return false;
301     }
302
303     if (sciErr.iErr)
304     {
305         printError(&sciErr, 0);
306         return false;
307     }
308
309     //close undefined dataset
310     closeDataSet(_iDatasetId);
311     return true;
312 }
313
314 static bool import_double(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
315 {
316     SciErr sciErr;
317     int iRet = 0;
318     double *pdblReal = NULL;
319     double *pdblImg = NULL;
320     int iDims = 0;
321     int* piDims = NULL;
322     int iComplex = 0;
323     int iSize = 0;
324
325     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
326     if (iRet < 0)
327     {
328         return false;
329     }
330
331     if (iDims != 0)
332     {
333         piDims = (int*)MALLOC(sizeof(int) * iDims);
334         iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
335
336         if (iDims == 2 && piDims[0] * piDims[1] != 0)
337         {
338             if (iComplex)
339             {
340                 pdblReal = (double *)MALLOC(iSize * sizeof(double));
341                 pdblImg = (double *)MALLOC(iSize * sizeof(double));
342                 iRet = readDoubleComplexMatrix(_iDatasetId, pdblReal, pdblImg);
343             }
344             else
345             {
346                 pdblReal = (double *)MALLOC(iSize * sizeof(double));
347                 iRet = readDoubleMatrix(_iDatasetId, pdblReal);
348             }
349
350             if (iRet)
351             {
352                 FREE(piDims);
353                 return false;
354             }
355         }
356         else if (iDims > 2)
357         {
358             //hypermatrix
359             FREE(piDims);
360             return false;
361         }
362     }
363     else
364     {
365         /*bug 7224 : to close dataset */
366         iRet = readEmptyMatrix(_iDatasetId);
367         if (iRet)
368         {
369             return false;
370         }
371
372         // Hack to sure that piDims will not be null at line 372.
373         iDims = 2;
374         piDims = (int*)MALLOC(sizeof(int) * iDims);
375         memset(piDims, 0, sizeof(int) * iDims);
376     }
377
378     if (_piAddress == NULL)
379     {
380         if (iComplex)
381         {
382             sciErr = createNamedComplexMatrixOfDouble(pvCtx, _pstVarname, piDims[0], piDims[1], pdblReal, pdblImg);
383         }
384         else
385         {
386             sciErr = createNamedMatrixOfDouble(pvCtx, _pstVarname, piDims[0], piDims[1], pdblReal);
387         }
388     }
389     else //if not null this variable is in a list
390     {
391         if (iComplex)
392         {
393             sciErr = createComplexMatrixOfDoubleInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal, pdblImg);
394         }
395         else
396         {
397             sciErr = createMatrixOfDoubleInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal);
398         }
399     }
400
401     if (sciErr.iErr)
402     {
403         printError(&sciErr, 0);
404         return false;
405     }
406
407     FREE(piDims);
408     if (pdblReal)
409     {
410         FREE(pdblReal);
411     }
412
413     if (pdblImg)
414     {
415         FREE(pdblImg);
416     }
417
418     if (iRet)
419     {
420         return false;
421     }
422
423     return true;
424 }
425
426 static bool import_string(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
427 {
428     SciErr sciErr;
429     int iRet = 0;
430     char **pstData = NULL;
431     int iDims = 0;
432     int* piDims = NULL;
433     int iComplex = 0;
434     int iSize = 0;
435
436     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
437     if (iRet < 0)
438     {
439         return false;
440     }
441
442     piDims = (int*)MALLOC(sizeof(int) * iDims);
443     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
444
445     pstData = (char **)MALLOC(iSize * sizeof(char *));
446
447     iRet = readStringMatrix(_iDatasetId, pstData);
448     if (iRet)
449     {
450         FREE(piDims);
451         return false;
452     }
453
454     if (_piAddress == NULL)
455     {
456         sciErr = createNamedMatrixOfString(pvCtx, _pstVarname, piDims[0], piDims[1], pstData);
457     }
458     else                        //if not null this variable is in a list
459     {
460         sciErr = createMatrixOfStringInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pstData);
461     }
462
463     if (sciErr.iErr)
464     {
465         printError(&sciErr, 0);
466         FREE(piDims);
467         freeStringMatrix(_iDatasetId, pstData);
468         FREE(pstData);
469         return false;
470     }
471
472     FREE(piDims);
473     freeStringMatrix(_iDatasetId, pstData);
474     FREE(pstData);
475
476     return true;
477 }
478
479 static bool import_integer(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
480 {
481     int iRet = 0;
482     int iDims = 0;
483     int* piDims = NULL;
484     int iComplex = 0;
485     int iSize = 0;
486     int iPrec = 0;
487     SciErr sciErr;
488
489     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
490     if (iRet < 0)
491     {
492         return false;
493     }
494
495     piDims = (int*)MALLOC(sizeof(int) * iDims);
496     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
497
498     iRet = getDatasetPrecision(_iDatasetId, &iPrec);
499     if (iRet)
500     {
501         return false;
502     }
503
504     switch (iPrec)
505     {
506         case SCI_INT8:
507         {
508             char *pcData = NULL;
509
510             pcData = (char *)MALLOC(sizeof(char) * iSize);
511             iRet = readInteger8Matrix(_iDatasetId, pcData);
512             if (iRet)
513             {
514                 return false;
515             }
516
517             if (_piAddress == NULL)
518             {
519                 sciErr = createNamedMatrixOfInteger8(pvCtx, _pstVarname, piDims[0], piDims[1], pcData);
520             }
521             else
522             {
523                 sciErr = createMatrixOfInteger8InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pcData);
524             }
525         }
526         break;
527         case SCI_UINT8:
528         {
529             unsigned char *pucData = NULL;
530
531             pucData = (unsigned char *)MALLOC(sizeof(unsigned char) * iSize);
532             iRet = readUnsignedInteger8Matrix(_iDatasetId, pucData);
533             if (iRet)
534             {
535                 return false;
536             }
537
538             if (_piAddress == NULL)
539             {
540                 sciErr = createNamedMatrixOfUnsignedInteger8(pvCtx, _pstVarname, piDims[0], piDims[1], pucData);
541             }
542             else
543             {
544                 sciErr = createMatrixOfUnsignedInteger8InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pucData);
545             }
546         }
547         break;
548         case SCI_INT16:
549         {
550             short *psData = NULL;
551
552             psData = (short *)MALLOC(sizeof(short) * iSize);
553             iRet = readInteger16Matrix(_iDatasetId, psData);
554             if (iRet)
555             {
556                 return false;
557             }
558
559             if (_piAddress == NULL)
560             {
561                 sciErr = createNamedMatrixOfInteger16(pvCtx, _pstVarname, piDims[0], piDims[1], psData);
562             }
563             else
564             {
565                 sciErr = createMatrixOfInteger16InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], psData);
566             }
567         }
568         break;
569         case SCI_UINT16:
570         {
571             unsigned short *pusData = NULL;
572
573             pusData = (unsigned short *)MALLOC(sizeof(unsigned short) * iSize);
574             iRet = readUnsignedInteger16Matrix(_iDatasetId, pusData);
575             if (iRet)
576             {
577                 return false;
578             }
579
580             if (_piAddress == NULL)
581             {
582                 sciErr = createNamedMatrixOfUnsignedInteger16(pvCtx, _pstVarname, piDims[0], piDims[1], pusData);
583             }
584             else
585             {
586                 sciErr = createMatrixOfUnsignedInteger16InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pusData);
587             }
588         }
589         break;
590         case SCI_INT32:
591         {
592             int *piData = NULL;
593
594             piData = (int *)MALLOC(sizeof(int) * iSize);
595             iRet = readInteger32Matrix(_iDatasetId, piData);
596             if (iRet)
597             {
598                 return false;
599             }
600
601             if (_piAddress == NULL)
602             {
603                 sciErr = createNamedMatrixOfInteger32(pvCtx, _pstVarname, piDims[0], piDims[1], piData);
604             }
605             else
606             {
607                 sciErr = createMatrixOfInteger32InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData);
608             }
609         }
610         break;
611         case SCI_UINT32:
612         {
613             unsigned int *puiData = NULL;
614
615             puiData = (unsigned int *)MALLOC(sizeof(unsigned int) * iSize);
616             iRet = readUnsignedInteger32Matrix(_iDatasetId, puiData);
617             if (iRet)
618             {
619                 return false;
620             }
621
622             if (_piAddress == NULL)
623             {
624                 sciErr = createNamedMatrixOfUnsignedInteger32(pvCtx, _pstVarname, piDims[0], piDims[1], puiData);
625             }
626             else
627             {
628                 sciErr = createMatrixOfUnsignedInteger32InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], puiData);
629             }
630         }
631         break;
632         case SCI_INT64:
633         {
634 #ifdef __SCILAB_INT64__
635             long long *pllData = NULL;
636
637             pllData = (long long *)MALLOC(sizeof(long long) * iSize);
638             iRet = readInteger64Matrix(_iDatasetId, pllData);
639             if (iRet)
640             {
641                 return false;
642             }
643
644             if (_piAddress == NULL)
645             {
646                 sciErr = createNamedMatrixOfInteger64(pvCtx, _pstVarname, piDims[0], piDims[1], pllData);
647             }
648             else
649             {
650                 sciErr = createMatrixOfInteger64InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pllData);
651             }
652 #else
653             return false;
654 #endif
655         }
656         break;
657         case SCI_UINT64:
658         {
659 #ifdef __SCILAB_INT64__
660             unsigned long long *pullData = NULL;
661
662             pullData = (unsigned long long *)MALLOC(sizeof(unsigned long long) * iSize);
663             iRet = readUnsignedInteger64Matrix(_iDatasetId, pullData);
664             if (iRet)
665             {
666                 return false;
667             }
668
669             if (_piAddress == NULL)
670             {
671                 sciErr = createNamedMatrixOfUnsignedInteger64(pvCtx, _pstVarname, piDims[0], piDims[1], pullData);
672             }
673             else
674             {
675                 sciErr = createMatrixOfUnsignedInteger64InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pullData);
676             }
677 #else
678             return false;
679 #endif
680         }
681         break;
682         default:
683             return false;
684     }
685
686     if (sciErr.iErr)
687     {
688         printError(&sciErr, 0);
689         return false;
690     }
691
692     return true;
693 }
694
695 static bool import_boolean(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
696 {
697     int iRet = 0;
698     int *piData = NULL;
699     int iDims = 0;
700     int* piDims = NULL;
701     int iComplex = 0;
702     int iSize = 0;
703     SciErr sciErr;
704
705     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
706     if (iRet < 0)
707     {
708         return false;
709     }
710
711     piDims = (int*)MALLOC(sizeof(int) * iDims);
712     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
713
714     if (iSize != 0)
715     {
716         piData = (int *)MALLOC(iSize * sizeof(int));
717         iRet = readBooleanMatrix(_iDatasetId, piData);
718         if (iRet)
719         {
720             FREE(piData);
721             FREE(piDims);
722             return false;
723         }
724     }
725
726     if (_piAddress == NULL)
727     {
728         sciErr = createNamedMatrixOfBoolean(pvCtx, _pstVarname, piDims[0], piDims[1], piData);
729     }
730     else                        //if not null this variable is in a list
731     {
732         sciErr = createMatrixOfBooleanInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData);
733     }
734
735     if (sciErr.iErr)
736     {
737         printError(&sciErr, 0);
738         FREE(piDims);
739         if (piData)
740         {
741             FREE(piData);
742         }
743         return false;
744     }
745
746     FREE(piDims);
747     if (piData)
748     {
749         FREE(piData);
750     }
751
752     if (iRet)
753     {
754         return false;
755     }
756
757     return true;
758 }
759
760 static bool import_poly(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
761 {
762     int iRet = 0;
763     int iComplex = 0;
764     char pstVarName[64] = { 0 };
765     double **pdblReal = NULL;
766     double **pdblImg = NULL;
767     int *piNbCoef = NULL;
768     int iDims = 0;
769     int* piDims = NULL;
770     int iSize = 0;
771     SciErr sciErr;
772
773     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
774     if (iRet < 0)
775     {
776         return false;
777     }
778
779     piDims = (int*)MALLOC(sizeof(int) * iDims);
780     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
781
782     if (iComplex)
783     {
784         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
785         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
786         pdblImg = (double **)MALLOC(iSize * sizeof(double *));
787         iRet = readPolyComplexMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal, pdblImg);
788     }
789     else
790     {
791         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
792         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
793         iRet = readPolyMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal);
794     }
795
796     if (iRet)
797     {
798         return false;
799     }
800
801     if (_piAddress == NULL)
802     {
803         if (iComplex)
804         {
805             sciErr = createNamedComplexMatrixOfPoly(pvCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal, pdblImg);
806         }
807         else
808         {
809             sciErr = createNamedMatrixOfPoly(pvCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
810         }
811     }
812     else                        //if not null this variable is in a list
813     {
814         if (iComplex)
815         {
816             sciErr =
817                 createComplexMatrixOfPolyInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal,
818                         pdblImg);
819         }
820         else
821         {
822             sciErr = createMatrixOfPolyInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
823         }
824     }
825
826     if (sciErr.iErr)
827     {
828         printError(&sciErr, 0);
829         return false;
830     }
831
832     for (int i = 0; i < iSize; i++)
833     {
834         FREE(pdblReal[i]);
835     }
836     FREE(pdblReal);
837
838
839     if (iComplex)
840     {
841         for (int i = 0; i < iSize; i++)
842         {
843             FREE(pdblImg[i]);
844         }
845         FREE(pdblImg);
846     }
847
848     FREE(piNbCoef);
849     return true;
850 }
851
852 static bool import_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
853 {
854     int iRet = 0;
855     int iRows = 0;
856     int iCols = 0;
857     int iComplex = 0;
858     double *pdblReal = NULL;
859     double *pdblImg = NULL;
860     int iNbItem = 0;
861     int *piNbItemRow = NULL;
862     int *piColPos = NULL;
863     SciErr sciErr;
864
865     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
866     if (iRet)
867     {
868         return false;
869     }
870
871     iComplex = isComplexData(_iDatasetId);
872
873     if (iComplex)
874     {
875         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
876         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
877         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
878         pdblImg = (double *)MALLOC(iNbItem * sizeof(double));
879         iRet = readSparseComplexMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
880     }
881     else
882     {
883         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
884         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
885         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
886         iRet = readSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
887     }
888
889     if (iRet)
890     {
891         return false;
892     }
893
894     if (_piAddress == NULL)
895     {
896         if (iComplex)
897         {
898             sciErr = createNamedComplexSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
899         }
900         else
901         {
902             sciErr = createNamedSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
903         }
904     }
905     else                        //if not null this variable is in a list
906     {
907         if (iComplex)
908         {
909             sciErr =
910                 createComplexSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos,
911                         pdblReal, pdblImg);
912         }
913         else
914         {
915             sciErr =
916                 createSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
917         }
918     }
919
920     if (sciErr.iErr)
921     {
922         printError(&sciErr, 0);
923         return false;
924     }
925
926     FREE(piNbItemRow);
927     FREE(piColPos);
928     FREE(pdblReal);
929     if (iComplex)
930     {
931         FREE(pdblImg);
932     }
933
934     if (iRet)
935     {
936         return false;
937     }
938
939     return true;
940 }
941
942 static bool import_boolean_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
943 {
944     int iRet = 0;
945     int iRows = 0;
946     int iCols = 0;
947     int iNbItem = 0;
948     int *piNbItemRow = NULL;
949     int *piColPos = NULL;
950     SciErr sciErr;
951
952     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
953     if (iRet)
954     {
955         return false;
956     }
957
958     piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
959     piColPos = (int *)MALLOC(iNbItem * sizeof(int));
960
961     iRet = readBooleanSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos);
962     if (iRet)
963     {
964         return false;
965     }
966
967     if (_piAddress == NULL)
968     {
969         sciErr = createNamedBooleanSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos);
970     }
971     else                        //if not null this variable is in a list
972     {
973         sciErr = createBooleanSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos);
974     }
975
976     if (sciErr.iErr)
977     {
978         printError(&sciErr, 0);
979         return false;
980     }
981
982     FREE(piNbItemRow);
983     if (piColPos)
984     {
985         FREE(piColPos);
986     }
987
988     if (iRet)
989     {
990         return false;
991     }
992
993     return true;
994 }
995
996 static bool import_list(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
997 {
998     int iRet = 0;
999     int i = 0;
1000     int iItems = 0;
1001     int *piListAddr = NULL;
1002     hobj_ref_t *piItemRef = NULL;
1003     SciErr sciErr;
1004
1005     iRet = getListDims(_iDatasetId, &iItems);
1006     if (iRet)
1007     {
1008         return false;
1009     }
1010
1011     if (iItems == 0)
1012     {
1013         //special case for empty list
1014     }
1015     else
1016     {
1017         iRet = getListItemReferences(_iDatasetId, &piItemRef);
1018         if (iRet)
1019         {
1020             return false;
1021         }
1022     }
1023
1024     if (_piAddress == 0)
1025     {
1026         switch (_iVarType)
1027         {
1028             case sci_list:
1029                 sciErr = createNamedList(pvCtx, _pstVarname, iItems, &piListAddr);
1030                 break;
1031             case sci_tlist:
1032                 sciErr = createNamedTList(pvCtx, _pstVarname, iItems, &piListAddr);
1033                 break;
1034             case sci_mlist:
1035                 sciErr = createNamedMList(pvCtx, _pstVarname, iItems, &piListAddr);
1036                 break;
1037             default:
1038                 return false;
1039         }
1040     }
1041     else                        //if not null this variable is in a list
1042     {
1043         switch (_iVarType)
1044         {
1045             case sci_list:
1046                 sciErr = createListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1047                 break;
1048             case sci_tlist:
1049                 sciErr = createTListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1050                 break;
1051             case sci_mlist:
1052                 sciErr = createMListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1053                 break;
1054             default:
1055                 return false;
1056         }
1057     }
1058
1059     if (sciErr.iErr)
1060     {
1061         printError(&sciErr, 0);
1062         return false;
1063     }
1064
1065     for (i = 0; i < iItems; i++)
1066     {
1067         int iItemDataset = 0;
1068
1069         iRet = getListItemDataset(_iDatasetId, piItemRef, i, &iItemDataset);
1070         if (iRet || iItemDataset == 0)
1071         {
1072             return false;
1073         }
1074
1075         bool bRet = import_data(pvCtx, iItemDataset, i + 1, piListAddr, _pstVarname);
1076
1077         if (bRet == false)
1078         {
1079             return false;
1080         }
1081     }
1082
1083     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1084     if (iRet)
1085     {
1086         return false;
1087     }
1088
1089     return true;
1090 }
1091
1092 /*--------------------------------------------------------------------------*/