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