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