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