hdf5: force some hdf5 lib functions, force no depreacated functions, convert code...
[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-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 }
30
31 #include "import_from_hdf5_v1.hxx"
32
33 static bool import_variable(int _iFile, char* _pstVarName);
34 static bool import_data(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
35 static bool import_double(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
36 static bool import_string(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
37 static bool import_boolean(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
38 static bool import_integer(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
39 static bool import_sparse(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
40 static bool import_boolean_sparse(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
41 static bool import_poly(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
42 static bool import_list(int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname);
43 static bool import_void(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
44 static bool import_undefined(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
45
46 int sci_import_from_hdf5(char *fname, unsigned long fname_len)
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, fname_len);
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(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(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 _iFile, char* _pstVarName)
187 {
188     int iDataSetId = getDataSetIdFromName(_iFile, _pstVarName);
189     if (iDataSetId <= 0)
190     {
191         return false;
192     }
193
194     return import_data(iDataSetId, 0, NULL, _pstVarName);
195 }
196
197 static bool import_data(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(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
209             break;
210         }
211         case sci_strings:
212         {
213             bRet = import_string(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
214             break;
215         }
216         case sci_list:
217         case sci_tlist:
218         case sci_mlist:
219         {
220             bRet = import_list(_iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
221             break;
222         }
223         case sci_boolean:
224         {
225             bRet = import_boolean(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
226             break;
227         }
228         case sci_poly:
229         {
230             bRet = import_poly(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
231             break;
232         }
233         case sci_ints:
234         {
235             bRet = import_integer(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
236             break;
237         }
238         case sci_sparse:
239         {
240             bRet = import_sparse(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
241             break;
242         }
243         case sci_boolean_sparse:
244         {
245             bRet = import_boolean_sparse(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
246             break;
247         }
248         case sci_void:             //void item only on list variable
249         {
250             bRet = import_void(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
251             break;
252         }
253         case sci_undefined:        //undefined item only on list variable
254         {
255             bRet = import_undefined(_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 _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
267 {
268     SciErr sciErr;
269
270     if (_piAddress)
271     {
272         sciErr = createVoidInNamedList(pvApiCtx, _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 _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
291 {
292     SciErr sciErr;
293
294     if (_piAddress)
295     {
296         sciErr = createUndefinedInNamedList(pvApiCtx, _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 _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                 return false;
353             }
354         }
355         else if (iDims > 2)
356         {
357             //hypermatrix
358             return false;
359         }
360     }
361     else
362     {
363         /*bug 7224 : to close dataset */
364         iRet = readEmptyMatrix(_iDatasetId);
365         if (iRet)
366         {
367             return false;
368         }
369
370         // Hack to sure that piDims will not be null at line 372.
371         iDims = 2;
372         piDims = (int*)MALLOC(sizeof(int) * iDims);
373         memset(piDims, 0, sizeof(int) * iDims);
374     }
375
376     if (_piAddress == NULL)
377     {
378         if (iComplex)
379         {
380             sciErr = createNamedComplexMatrixOfDouble(pvApiCtx, _pstVarname, piDims[0], piDims[1], pdblReal, pdblImg);
381         }
382         else
383         {
384             sciErr = createNamedMatrixOfDouble(pvApiCtx, _pstVarname, piDims[0], piDims[1], pdblReal);
385         }
386     }
387     else //if not null this variable is in a list
388     {
389         if (iComplex)
390         {
391             sciErr = createComplexMatrixOfDoubleInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal, pdblImg);
392         }
393         else
394         {
395             sciErr = createMatrixOfDoubleInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal);
396         }
397     }
398
399     if (sciErr.iErr)
400     {
401         printError(&sciErr, 0);
402         return false;
403     }
404
405     if (pdblReal)
406     {
407         FREE(pdblReal);
408     }
409
410     if (pdblImg)
411     {
412         FREE(pdblImg);
413     }
414
415     if (iRet)
416     {
417         return false;
418     }
419
420     return true;
421 }
422
423 static bool import_string(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
424 {
425     SciErr sciErr;
426     int iRet = 0;
427     char **pstData = NULL;
428     int iDims = 0;
429     int* piDims = NULL;
430     int iComplex = 0;
431     int iSize = 0;
432
433     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
434     if (iRet < 0)
435     {
436         return false;
437     }
438
439     piDims = (int*)MALLOC(sizeof(int) * iDims);
440     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
441
442     pstData = (char **)MALLOC(iSize * sizeof(char *));
443
444     iRet = readStringMatrix(_iDatasetId, pstData);
445     if (iRet)
446     {
447         return false;
448     }
449
450     if (_piAddress == NULL)
451     {
452         sciErr = createNamedMatrixOfString(pvApiCtx, _pstVarname, piDims[0], piDims[1], pstData);
453     }
454     else                        //if not null this variable is in a list
455     {
456         sciErr = createMatrixOfStringInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pstData);
457     }
458
459     if (sciErr.iErr)
460     {
461         printError(&sciErr, 0);
462         return false;
463     }
464
465     FREE(pstData);
466
467     return true;
468 }
469
470 static bool import_integer(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
471 {
472     int iRet = 0;
473     int iDims = 0;
474     int* piDims = NULL;
475     int iComplex = 0;
476     int iSize = 0;
477     int iPrec = 0;
478     SciErr sciErr;
479
480     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
481     if (iRet < 0)
482     {
483         return false;
484     }
485
486     piDims = (int*)MALLOC(sizeof(int) * iDims);
487     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
488
489     iRet = getDatasetPrecision(_iDatasetId, &iPrec);
490     if (iRet)
491     {
492         return false;
493     }
494
495     switch (iPrec)
496     {
497         case SCI_INT8:
498         {
499             char *pcData = NULL;
500
501             pcData = (char *)MALLOC(sizeof(char) * iSize);
502             iRet = readInteger8Matrix(_iDatasetId, pcData);
503             if (iRet)
504             {
505                 return false;
506             }
507
508             if (_piAddress == NULL)
509             {
510                 sciErr = createNamedMatrixOfInteger8(pvApiCtx, _pstVarname, piDims[0], piDims[1], pcData);
511             }
512             else
513             {
514                 sciErr = createMatrixOfInteger8InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pcData);
515             }
516         }
517         break;
518         case SCI_UINT8:
519         {
520             unsigned char *pucData = NULL;
521
522             pucData = (unsigned char *)MALLOC(sizeof(unsigned char) * iSize);
523             iRet = readUnsignedInteger8Matrix(_iDatasetId, pucData);
524             if (iRet)
525             {
526                 return false;
527             }
528
529             if (_piAddress == NULL)
530             {
531                 sciErr = createNamedMatrixOfUnsignedInteger8(pvApiCtx, _pstVarname, piDims[0], piDims[1], pucData);
532             }
533             else
534             {
535                 sciErr = createMatrixOfUnsignedInteger8InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pucData);
536             }
537         }
538         break;
539         case SCI_INT16:
540         {
541             short *psData = NULL;
542
543             psData = (short *)MALLOC(sizeof(short) * iSize);
544             iRet = readInteger16Matrix(_iDatasetId, psData);
545             if (iRet)
546             {
547                 return false;
548             }
549
550             if (_piAddress == NULL)
551             {
552                 sciErr = createNamedMatrixOfInteger16(pvApiCtx, _pstVarname, piDims[0], piDims[1], psData);
553             }
554             else
555             {
556                 sciErr = createMatrixOfInteger16InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], psData);
557             }
558         }
559         break;
560         case SCI_UINT16:
561         {
562             unsigned short *pusData = NULL;
563
564             pusData = (unsigned short *)MALLOC(sizeof(unsigned short) * iSize);
565             iRet = readUnsignedInteger16Matrix(_iDatasetId, pusData);
566             if (iRet)
567             {
568                 return false;
569             }
570
571             if (_piAddress == NULL)
572             {
573                 sciErr = createNamedMatrixOfUnsignedInteger16(pvApiCtx, _pstVarname, piDims[0], piDims[1], pusData);
574             }
575             else
576             {
577                 sciErr = createMatrixOfUnsignedInteger16InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pusData);
578             }
579         }
580         break;
581         case SCI_INT32:
582         {
583             int *piData = NULL;
584
585             piData = (int *)MALLOC(sizeof(int) * iSize);
586             iRet = readInteger32Matrix(_iDatasetId, piData);
587             if (iRet)
588             {
589                 return false;
590             }
591
592             if (_piAddress == NULL)
593             {
594                 sciErr = createNamedMatrixOfInteger32(pvApiCtx, _pstVarname, piDims[0], piDims[1], piData);
595             }
596             else
597             {
598                 sciErr = createMatrixOfInteger32InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData);
599             }
600         }
601         break;
602         case SCI_UINT32:
603         {
604             unsigned int *puiData = NULL;
605
606             puiData = (unsigned int *)MALLOC(sizeof(unsigned int) * iSize);
607             iRet = readUnsignedInteger32Matrix(_iDatasetId, puiData);
608             if (iRet)
609             {
610                 return false;
611             }
612
613             if (_piAddress == NULL)
614             {
615                 sciErr = createNamedMatrixOfUnsignedInteger32(pvApiCtx, _pstVarname, piDims[0], piDims[1], puiData);
616             }
617             else
618             {
619                 sciErr = createMatrixOfUnsignedInteger32InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], puiData);
620             }
621         }
622         break;
623         case SCI_INT64:
624         {
625 #ifdef __SCILAB_INT64__
626             long long *pllData = NULL;
627
628             pllData = (long long *)MALLOC(sizeof(long long) * iSize);
629             iRet = readInteger64Matrix(_iDatasetId, pllData);
630             if (iRet)
631             {
632                 return false;
633             }
634
635             if (_piAddress == NULL)
636             {
637                 sciErr = createNamedMatrixOfInteger64(_pstVarname, piDims[0], piDims[1], pllData);
638             }
639             else
640             {
641                 sciErr = createMatrixOfInteger64InNamedList(_pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pllData);
642             }
643 #else
644             return false;
645 #endif
646         }
647         break;
648         case SCI_UINT64:
649         {
650 #ifdef __SCILAB_INT64__
651             unsigned long long *pullData = NULL;
652
653             pullData = (unsigned long long *)MALLOC(sizeof(unsigned long long) * iSize);
654             iRet = readUnsignedInteger64Matrix(_iDatasetId, pullData);
655             if (iRet)
656             {
657                 return false;
658             }
659
660             if (_piAddress == NULL)
661             {
662                 sciErr = createNamedMatrixOfUnsignedInteger64(_pstVarname, piDims[0], piDims[1], pullData);
663             }
664             else
665             {
666                 sciErr = createMatrixOfUnsignedInteger64InNamedList(_pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pullData);
667             }
668 #else
669             return false;
670 #endif
671         }
672         break;
673         default:
674             return false;
675     }
676
677     if (sciErr.iErr)
678     {
679         printError(&sciErr, 0);
680         return false;
681     }
682
683     return true;
684 }
685
686 static bool import_boolean(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
687 {
688     int iRet = 0;
689     int *piData = NULL;
690     int iDims = 0;
691     int* piDims = NULL;
692     int iComplex = 0;
693     int iSize = 0;
694     SciErr sciErr;
695
696     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
697     if (iRet < 0)
698     {
699         return false;
700     }
701
702     piDims = (int*)MALLOC(sizeof(int) * iDims);
703     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
704
705     if (iSize != 0)
706     {
707         piData = (int *)MALLOC(iSize * sizeof(int));
708         iRet = readBooleanMatrix(_iDatasetId, piData);
709         if (iRet)
710         {
711             return false;
712         }
713     }
714
715     if (_piAddress == NULL)
716     {
717         sciErr = createNamedMatrixOfBoolean(pvApiCtx, _pstVarname, piDims[0], piDims[1], piData);
718     }
719     else                        //if not null this variable is in a list
720     {
721         sciErr = createMatrixOfBooleanInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData);
722     }
723
724     if (sciErr.iErr)
725     {
726         printError(&sciErr, 0);
727         return false;
728     }
729
730     if (piData)
731     {
732         FREE(piData);
733     }
734
735     if (iRet)
736     {
737         return false;
738     }
739
740     return true;
741 }
742
743 static bool import_poly(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
744 {
745     int iRet = 0;
746     int iComplex = 0;
747     char pstVarName[64] = { 0 };
748     double **pdblReal = NULL;
749     double **pdblImg = NULL;
750     int *piNbCoef = NULL;
751     int iDims = 0;
752     int* piDims = NULL;
753     int iSize = 0;
754     SciErr sciErr;
755
756     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
757     if (iRet < 0)
758     {
759         return false;
760     }
761
762     piDims = (int*)MALLOC(sizeof(int) * iDims);
763     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
764
765     if (iComplex)
766     {
767         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
768         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
769         pdblImg = (double **)MALLOC(iSize * sizeof(double *));
770         iRet = readPolyComplexMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal, pdblImg);
771     }
772     else
773     {
774         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
775         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
776         iRet = readPolyMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal);
777     }
778
779     if (iRet)
780     {
781         return false;
782     }
783
784     if (_piAddress == NULL)
785     {
786         if (iComplex)
787         {
788             sciErr = createNamedComplexMatrixOfPoly(pvApiCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal, pdblImg);
789         }
790         else
791         {
792             sciErr = createNamedMatrixOfPoly(pvApiCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
793         }
794     }
795     else                        //if not null this variable is in a list
796     {
797         if (iComplex)
798         {
799             sciErr =
800                 createComplexMatrixOfPolyInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal,
801                         pdblImg);
802         }
803         else
804         {
805             sciErr = createMatrixOfPolyInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
806         }
807     }
808
809     if (sciErr.iErr)
810     {
811         printError(&sciErr, 0);
812         return false;
813     }
814
815     for (int i = 0; i < iSize; i++)
816     {
817         FREE(pdblReal[i]);
818     }
819     FREE(pdblReal);
820
821
822     if (iComplex)
823     {
824         for (int i = 0; i < iSize; i++)
825         {
826             FREE(pdblImg[i]);
827         }
828         FREE(pdblImg);
829     }
830
831     FREE(piNbCoef);
832     return true;
833 }
834
835 static bool import_sparse(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
836 {
837     int iRet = 0;
838     int iRows = 0;
839     int iCols = 0;
840     int iComplex = 0;
841     double *pdblReal = NULL;
842     double *pdblImg = NULL;
843     int iNbItem = 0;
844     int *piNbItemRow = NULL;
845     int *piColPos = NULL;
846     SciErr sciErr;
847
848     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
849     if (iRet)
850     {
851         return false;
852     }
853
854     iComplex = isComplexData(_iDatasetId);
855
856     if (iComplex)
857     {
858         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
859         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
860         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
861         pdblImg = (double *)MALLOC(iNbItem * sizeof(double));
862         iRet = readSparseComplexMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
863     }
864     else
865     {
866         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
867         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
868         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
869         iRet = readSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
870     }
871
872     if (iRet)
873     {
874         return false;
875     }
876
877     if (_piAddress == NULL)
878     {
879         if (iComplex)
880         {
881             sciErr = createNamedComplexSparseMatrix(pvApiCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
882         }
883         else
884         {
885             sciErr = createNamedSparseMatrix(pvApiCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
886         }
887     }
888     else                        //if not null this variable is in a list
889     {
890         if (iComplex)
891         {
892             sciErr =
893                 createComplexSparseMatrixInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos,
894                         pdblReal, pdblImg);
895         }
896         else
897         {
898             sciErr =
899                 createSparseMatrixInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
900         }
901     }
902
903     if (sciErr.iErr)
904     {
905         printError(&sciErr, 0);
906         return false;
907     }
908
909     FREE(piNbItemRow);
910     FREE(piColPos);
911     FREE(pdblReal);
912     if (iComplex)
913     {
914         FREE(pdblImg);
915     }
916
917     if (iRet)
918     {
919         return false;
920     }
921
922     return true;
923 }
924
925 static bool import_boolean_sparse(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
926 {
927     int iRet = 0;
928     int iRows = 0;
929     int iCols = 0;
930     int iNbItem = 0;
931     int *piNbItemRow = NULL;
932     int *piColPos = NULL;
933     SciErr sciErr;
934
935     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
936     if (iRet)
937     {
938         return false;
939     }
940
941     piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
942     piColPos = (int *)MALLOC(iNbItem * sizeof(int));
943
944     iRet = readBooleanSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos);
945     if (iRet)
946     {
947         return false;
948     }
949
950     if (_piAddress == NULL)
951     {
952         sciErr = createNamedBooleanSparseMatrix(pvApiCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos);
953     }
954     else                        //if not null this variable is in a list
955     {
956         sciErr = createBooleanSparseMatrixInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos);
957     }
958
959     if (sciErr.iErr)
960     {
961         printError(&sciErr, 0);
962         return false;
963     }
964
965     FREE(piNbItemRow);
966     if (piColPos)
967     {
968         FREE(piColPos);
969     }
970
971     if (iRet)
972     {
973         return false;
974     }
975
976     return true;
977 }
978
979 static bool import_list(int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
980 {
981     int iRet = 0;
982     int i = 0;
983     int iItems = 0;
984     int *piListAddr = NULL;
985     hobj_ref_t *piItemRef = NULL;
986     SciErr sciErr;
987
988     iRet = getListDims(_iDatasetId, &iItems);
989     if (iRet)
990     {
991         return false;
992     }
993
994     if (iItems == 0)
995     {
996         //special case for empty list
997     }
998     else
999     {
1000         iRet = getListItemReferences(_iDatasetId, &piItemRef);
1001         if (iRet)
1002         {
1003             return false;
1004         }
1005     }
1006
1007     if (_piAddress == 0)
1008     {
1009         switch (_iVarType)
1010         {
1011             case sci_list:
1012                 sciErr = createNamedList(pvApiCtx, _pstVarname, iItems, &piListAddr);
1013                 break;
1014             case sci_tlist:
1015                 sciErr = createNamedTList(pvApiCtx, _pstVarname, iItems, &piListAddr);
1016                 break;
1017             case sci_mlist:
1018                 sciErr = createNamedMList(pvApiCtx, _pstVarname, iItems, &piListAddr);
1019                 break;
1020             default:
1021                 return false;
1022         }
1023     }
1024     else                        //if not null this variable is in a list
1025     {
1026         switch (_iVarType)
1027         {
1028             case sci_list:
1029                 sciErr = createListInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1030                 break;
1031             case sci_tlist:
1032                 sciErr = createTListInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1033                 break;
1034             case sci_mlist:
1035                 sciErr = createMListInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1036                 break;
1037             default:
1038                 return false;
1039         }
1040     }
1041
1042     if (sciErr.iErr)
1043     {
1044         printError(&sciErr, 0);
1045         return false;
1046     }
1047
1048     for (i = 0; i < iItems; i++)
1049     {
1050         int iItemDataset = 0;
1051
1052         iRet = getListItemDataset(_iDatasetId, piItemRef, i, &iItemDataset);
1053         if (iRet || iItemDataset == 0)
1054         {
1055             return false;
1056         }
1057
1058         bool bRet = import_data(iItemDataset, i + 1, piListAddr, _pstVarname);
1059
1060         if (bRet == false)
1061         {
1062             return false;
1063         }
1064     }
1065
1066     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1067     if (iRet)
1068     {
1069         return false;
1070     }
1071
1072     return true;
1073 }
1074
1075 /*--------------------------------------------------------------------------*/