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