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