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