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