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