import empty matrix failed.
[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         // Hack to sure that piDims will not be null at line 372.
359         iDims = 2;
360         piDims = (int*)MALLOC(sizeof(int) * iDims);
361         memset(piDims, 0, sizeof(int) * iDims);
362     }
363
364     if (_piAddress == NULL)
365     {
366         if (iComplex)
367         {
368             sciErr = createNamedComplexMatrixOfDouble(pvApiCtx, _pstVarname, piDims[0], piDims[1], pdblReal, pdblImg);
369         }
370         else
371         {
372             sciErr = createNamedMatrixOfDouble(pvApiCtx, _pstVarname, piDims[0], piDims[1], pdblReal);
373         }
374     }
375     else //if not null this variable is in a list
376     {
377         if (iComplex)
378         {
379             sciErr = createComplexMatrixOfDoubleInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal, pdblImg);
380         }
381         else
382         {
383             sciErr = createMatrixOfDoubleInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal);
384         }
385     }
386
387     if (sciErr.iErr)
388     {
389         printError(&sciErr, 0);
390         return false;
391     }
392
393     if (pdblReal)
394     {
395         FREE(pdblReal);
396     }
397
398     if (pdblImg)
399     {
400         FREE(pdblImg);
401     }
402
403     if (iRet)
404     {
405         return false;
406     }
407
408     return true;
409 }
410
411 static bool import_string(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
412 {
413     SciErr sciErr;
414     int iRet = 0;
415     char **pstData = NULL;
416     int iDims = 0;
417     int* piDims = NULL;
418     int iComplex = 0;
419     int iSize = 0;
420
421     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
422     if (iRet < 0)
423     {
424         return false;
425     }
426
427     piDims = (int*)MALLOC(sizeof(int) * iDims);
428     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
429
430     pstData = (char **)MALLOC(iSize * sizeof(char *));
431
432     iRet = readStringMatrix(_iDatasetId, pstData);
433     if (iRet)
434     {
435         return false;
436     }
437
438     if (_piAddress == NULL)
439     {
440         sciErr = createNamedMatrixOfString(pvApiCtx, _pstVarname, piDims[0], piDims[1], pstData);
441     }
442     else                        //if not null this variable is in a list
443     {
444         sciErr = createMatrixOfStringInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pstData);
445     }
446
447     if (sciErr.iErr)
448     {
449         printError(&sciErr, 0);
450         return false;
451     }
452
453     FREE(pstData);
454
455     return true;
456 }
457
458 static bool import_integer(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
459 {
460     int iRet = 0;
461     int iDims = 0;
462     int* piDims = NULL;
463     int iComplex = 0;
464     int iSize = 0;
465     int iPrec = 0;
466     SciErr sciErr;
467
468     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
469     if (iRet < 0)
470     {
471         return false;
472     }
473
474     piDims = (int*)MALLOC(sizeof(int) * iDims);
475     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
476
477     iRet = getDatasetPrecision(_iDatasetId, &iPrec);
478     if (iRet)
479     {
480         return false;
481     }
482
483     switch (iPrec)
484     {
485         case SCI_INT8:
486         {
487             char *pcData = NULL;
488
489             pcData = (char *)MALLOC(sizeof(char) * iSize);
490             iRet = readInteger8Matrix(_iDatasetId, pcData);
491             if (iRet)
492             {
493                 return false;
494             }
495
496             if (_piAddress == NULL)
497             {
498                 sciErr = createNamedMatrixOfInteger8(pvApiCtx, _pstVarname, piDims[0], piDims[1], pcData);
499             }
500             else
501             {
502                 sciErr = createMatrixOfInteger8InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pcData);
503             }
504         }
505         break;
506         case SCI_UINT8:
507         {
508             unsigned char *pucData = NULL;
509
510             pucData = (unsigned char *)MALLOC(sizeof(unsigned char) * iSize);
511             iRet = readUnsignedInteger8Matrix(_iDatasetId, pucData);
512             if (iRet)
513             {
514                 return false;
515             }
516
517             if (_piAddress == NULL)
518             {
519                 sciErr = createNamedMatrixOfUnsignedInteger8(pvApiCtx, _pstVarname, piDims[0], piDims[1], pucData);
520             }
521             else
522             {
523                 sciErr = createMatrixOfUnsignedInteger8InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pucData);
524             }
525         }
526         break;
527         case SCI_INT16:
528         {
529             short *psData = NULL;
530
531             psData = (short *)MALLOC(sizeof(short) * iSize);
532             iRet = readInteger16Matrix(_iDatasetId, psData);
533             if (iRet)
534             {
535                 return false;
536             }
537
538             if (_piAddress == NULL)
539             {
540                 sciErr = createNamedMatrixOfInteger16(pvApiCtx, _pstVarname, piDims[0], piDims[1], psData);
541             }
542             else
543             {
544                 sciErr = createMatrixOfInteger16InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], psData);
545             }
546         }
547         break;
548         case SCI_UINT16:
549         {
550             unsigned short *pusData = NULL;
551
552             pusData = (unsigned short *)MALLOC(sizeof(unsigned short) * iSize);
553             iRet = readUnsignedInteger16Matrix(_iDatasetId, pusData);
554             if (iRet)
555             {
556                 return false;
557             }
558
559             if (_piAddress == NULL)
560             {
561                 sciErr = createNamedMatrixOfUnsignedInteger16(pvApiCtx, _pstVarname, piDims[0], piDims[1], pusData);
562             }
563             else
564             {
565                 sciErr = createMatrixOfUnsignedInteger16InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pusData);
566             }
567         }
568         break;
569         case SCI_INT32:
570         {
571             int *piData = NULL;
572
573             piData = (int *)MALLOC(sizeof(int) * iSize);
574             iRet = readInteger32Matrix(_iDatasetId, piData);
575             if (iRet)
576             {
577                 return false;
578             }
579
580             if (_piAddress == NULL)
581             {
582                 sciErr = createNamedMatrixOfInteger32(pvApiCtx, _pstVarname, piDims[0], piDims[1], piData);
583             }
584             else
585             {
586                 sciErr = createMatrixOfInteger32InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData);
587             }
588         }
589         break;
590         case SCI_UINT32:
591         {
592             unsigned int *puiData = NULL;
593
594             puiData = (unsigned int *)MALLOC(sizeof(unsigned int) * iSize);
595             iRet = readUnsignedInteger32Matrix(_iDatasetId, puiData);
596             if (iRet)
597             {
598                 return false;
599             }
600
601             if (_piAddress == NULL)
602             {
603                 sciErr = createNamedMatrixOfUnsignedInteger32(pvApiCtx, _pstVarname, piDims[0], piDims[1], puiData);
604             }
605             else
606             {
607                 sciErr = createMatrixOfUnsignedInteger32InNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], puiData);
608             }
609         }
610         break;
611         case SCI_INT64:
612         {
613 #ifdef __SCILAB_INT64__
614             long long *pllData = NULL;
615
616             pllData = (long long *)MALLOC(sizeof(long long) * iSize);
617             iRet = readInteger64Matrix(_iDatasetId, pllData);
618             if (iRet)
619             {
620                 return false;
621             }
622
623             if (_piAddress == NULL)
624             {
625                 sciErr = createNamedMatrixOfInteger64(_pstVarname, piDims[0], piDims[1], pllData);
626             }
627             else
628             {
629                 sciErr = createMatrixOfInteger64InNamedList(_pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pllData);
630             }
631 #else
632             return false;
633 #endif
634         }
635         break;
636         case SCI_UINT64:
637         {
638 #ifdef __SCILAB_INT64__
639             unsigned long long *pullData = NULL;
640
641             pullData = (unsigned long long *)MALLOC(sizeof(unsigned long long) * iSize);
642             iRet = readUnsignedInteger64Matrix(_iDatasetId, pullData);
643             if (iRet)
644             {
645                 return false;
646             }
647
648             if (_piAddress == NULL)
649             {
650                 sciErr = createNamedMatrixOfUnsignedInteger64(_pstVarname, piDims[0], piDims[1], pullData);
651             }
652             else
653             {
654                 sciErr = createMatrixOfUnsignedInteger64InNamedList(_pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pullData);
655             }
656 #else
657             return false;
658 #endif
659         }
660         break;
661         default:
662             return false;
663     }
664
665     if (sciErr.iErr)
666     {
667         printError(&sciErr, 0);
668         return false;
669     }
670
671     return true;
672 }
673
674 static bool import_boolean(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
675 {
676     int iRet = 0;
677     int *piData = NULL;
678     int iDims = 0;
679     int* piDims = NULL;
680     int iComplex = 0;
681     int iSize = 0;
682     SciErr sciErr;
683
684     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
685     if (iRet < 0)
686     {
687         return false;
688     }
689
690     piDims = (int*)MALLOC(sizeof(int) * iDims);
691     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
692
693     if (iSize != 0)
694     {
695         piData = (int *)MALLOC(iSize * sizeof(int));
696         iRet = readBooleanMatrix(_iDatasetId, piData);
697         if (iRet)
698         {
699             return false;
700         }
701     }
702
703     if (_piAddress == NULL)
704     {
705         sciErr = createNamedMatrixOfBoolean(pvApiCtx, _pstVarname, piDims[0], piDims[1], piData);
706     }
707     else                        //if not null this variable is in a list
708     {
709         sciErr = createMatrixOfBooleanInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData);
710     }
711
712     if (sciErr.iErr)
713     {
714         printError(&sciErr, 0);
715         return false;
716     }
717
718     if (piData)
719     {
720         FREE(piData);
721     }
722
723     if (iRet)
724     {
725         return false;
726     }
727
728     return true;
729 }
730
731 static bool import_poly(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
732 {
733     int iRet = 0;
734     int iComplex = 0;
735     char pstVarName[64] = { 0 };
736     double **pdblReal = NULL;
737     double **pdblImg = NULL;
738     int *piNbCoef = NULL;
739     int iDims = 0;
740     int* piDims = NULL;
741     int iSize = 0;
742     SciErr sciErr;
743
744     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
745     if (iRet < 0)
746     {
747         return false;
748     }
749
750     piDims = (int*)MALLOC(sizeof(int) * iDims);
751     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
752
753     if (iComplex)
754     {
755         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
756         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
757         pdblImg = (double **)MALLOC(iSize * sizeof(double *));
758         iRet = readPolyComplexMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal, pdblImg);
759     }
760     else
761     {
762         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
763         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
764         iRet = readPolyMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal);
765     }
766
767     if (iRet)
768     {
769         return false;
770     }
771
772     if (_piAddress == NULL)
773     {
774         if (iComplex)
775         {
776             sciErr = createNamedComplexMatrixOfPoly(pvApiCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal, pdblImg);
777         }
778         else
779         {
780             sciErr = createNamedMatrixOfPoly(pvApiCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
781         }
782     }
783     else                        //if not null this variable is in a list
784     {
785         if (iComplex)
786         {
787             sciErr =
788                 createComplexMatrixOfPolyInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal,
789                         pdblImg);
790         }
791         else
792         {
793             sciErr = createMatrixOfPolyInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
794         }
795     }
796
797     if (sciErr.iErr)
798     {
799         printError(&sciErr, 0);
800         return false;
801     }
802
803     for (int i = 0; i < iSize; i++)
804     {
805         FREE(pdblReal[i]);
806     }
807     FREE(pdblReal);
808
809
810     if(iComplex)
811     {
812         for (int i = 0; i < iSize; i++)
813         {
814             FREE(pdblImg[i]);
815         }
816         FREE(pdblImg);
817     }
818
819     FREE(piNbCoef);
820     return true;
821 }
822
823 static bool import_sparse(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
824 {
825     int iRet = 0;
826     int iRows = 0;
827     int iCols = 0;
828     int iComplex = 0;
829     double *pdblReal = NULL;
830     double *pdblImg = NULL;
831     int iNbItem = 0;
832     int *piNbItemRow = NULL;
833     int *piColPos = NULL;
834     SciErr sciErr;
835
836     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
837     if (iRet)
838     {
839         return false;
840     }
841
842     iComplex = isComplexData(_iDatasetId);
843
844     if (iComplex)
845     {
846         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
847         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
848         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
849         pdblImg = (double *)MALLOC(iNbItem * sizeof(double));
850         iRet = readSparseComplexMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
851     }
852     else
853     {
854         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
855         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
856         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
857         iRet = readSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
858     }
859
860     if (iRet)
861     {
862         return false;
863     }
864
865     if (_piAddress == NULL)
866     {
867         if (iComplex)
868         {
869             sciErr = createNamedComplexSparseMatrix(pvApiCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
870         }
871         else
872         {
873             sciErr = createNamedSparseMatrix(pvApiCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
874         }
875     }
876     else                        //if not null this variable is in a list
877     {
878         if (iComplex)
879         {
880             sciErr =
881                 createComplexSparseMatrixInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos,
882                         pdblReal, pdblImg);
883         }
884         else
885         {
886             sciErr =
887                 createSparseMatrixInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
888         }
889     }
890
891     if (sciErr.iErr)
892     {
893         printError(&sciErr, 0);
894         return false;
895     }
896
897     FREE(piNbItemRow);
898     FREE(piColPos);
899     FREE(pdblReal);
900     if (iComplex)
901     {
902         FREE(pdblImg);
903     }
904
905     if (iRet)
906     {
907         return false;
908     }
909
910     return true;
911 }
912
913 static bool import_boolean_sparse(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
914 {
915     int iRet = 0;
916     int iRows = 0;
917     int iCols = 0;
918     int iNbItem = 0;
919     int *piNbItemRow = NULL;
920     int *piColPos = NULL;
921     SciErr sciErr;
922
923     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
924     if (iRet)
925     {
926         return false;
927     }
928
929     piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
930     piColPos = (int *)MALLOC(iNbItem * sizeof(int));
931     iRet = readBooleanSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos);
932     if (iRet)
933     {
934         return false;
935     }
936
937     if (_piAddress == NULL)
938     {
939         sciErr = createNamedBooleanSparseMatrix(pvApiCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos);
940     }
941     else                        //if not null this variable is in a list
942     {
943         sciErr = createBooleanSparseMatrixInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos);
944     }
945
946     if (sciErr.iErr)
947     {
948         printError(&sciErr, 0);
949         return false;
950     }
951
952     FREE(piNbItemRow);
953     FREE(piColPos);
954
955     if (iRet)
956     {
957         return false;
958     }
959
960     return true;
961 }
962
963 static bool import_list(int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
964 {
965     int iRet = 0;
966     int i = 0;
967     int iItems = 0;
968     int *piListAddr = NULL;
969     hobj_ref_t *piItemRef = NULL;
970     SciErr sciErr;
971
972     iRet = getListDims(_iDatasetId, &iItems);
973     if (iRet)
974     {
975         return false;
976     }
977
978     if (iItems == 0)
979     {
980         //special case for empty list
981     }
982     else
983     {
984         iRet = getListItemReferences(_iDatasetId, &piItemRef);
985         if (iRet)
986         {
987             return false;
988         }
989     }
990
991     if (_piAddress == 0)
992     {
993         switch (_iVarType)
994         {
995             case sci_list:
996                 sciErr = createNamedList(pvApiCtx, _pstVarname, iItems, &piListAddr);
997                 break;
998             case sci_tlist:
999                 sciErr = createNamedTList(pvApiCtx, _pstVarname, iItems, &piListAddr);
1000                 break;
1001             case sci_mlist:
1002                 sciErr = createNamedMList(pvApiCtx, _pstVarname, iItems, &piListAddr);
1003                 break;
1004             default:
1005                 return false;
1006         }
1007     }
1008     else                        //if not null this variable is in a list
1009     {
1010         switch (_iVarType)
1011         {
1012             case sci_list:
1013                 sciErr = createListInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1014                 break;
1015             case sci_tlist:
1016                 sciErr = createTListInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1017                 break;
1018             case sci_mlist:
1019                 sciErr = createMListInNamedList(pvApiCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1020                 break;
1021             default:
1022                 return false;
1023         }
1024     }
1025
1026     if (sciErr.iErr)
1027     {
1028         printError(&sciErr, 0);
1029         return false;
1030     }
1031
1032     for (i = 0; i < iItems; i++)
1033     {
1034         int iItemDataset = 0;
1035
1036         iRet = getListItemDataset(_iDatasetId, piItemRef, i, &iItemDataset);
1037         if (iRet || iItemDataset == 0)
1038         {
1039             return false;
1040         }
1041
1042         bool bRet = import_data(iItemDataset, i + 1, piListAddr, _pstVarname);
1043
1044         if (bRet == false)
1045         {
1046             return false;
1047         }
1048     }
1049
1050     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1051     if (iRet)
1052     {
1053         return false;
1054     }
1055
1056     return true;
1057 }
1058
1059 /*--------------------------------------------------------------------------*/