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