43b5d1e92ad78bdac12b8b63156aba3c9bef60c8
[scilab.git] / scilab / modules / hdf5 / sci_gateway / cpp / sci_hdf5_load_v2.cpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2009 - DIGITEO - Antoine ELIAS
4 *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13 *
14 */
15
16 #include <hdf5.h>
17 #include "context.hxx"
18 #include "list.hxx"
19 #include "struct.hxx"
20 #include "cell.hxx"
21
22 extern "C"
23 {
24 #include <string.h>
25 #include "gw_hdf5.h"
26 #include "sci_malloc.h"
27 #include "Scierror.h"
28 #include "localization.h"
29 #include "sciprint.h"
30 #include "api_scilab.h"
31 #include "../../../call_scilab/includes/call_scilab.h"
32 #include "h5_fileManagement.h"
33 #include "h5_readDataFromFile.h"
34 #include "h5_attributeConstants.h"
35 #include "expandPathVariable.h"
36 #include "stdlib.h"
37 #include "freeArrayOfString.h"
38 }
39
40 #include "hdf5_load_v1.hxx"
41
42 static bool import_variable(int* pvCtx, int _iFile, char* _pstVarName);
43 static bool import_data(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
44 static bool import_double(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
45 static bool import_string(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
46 static bool import_boolean(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
47 static bool import_integer(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
48 static bool import_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
49 static bool import_boolean_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
50 static bool import_poly(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
51 static bool import_list(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname);
52 static bool import_hypermat(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname);
53 static bool import_struct(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname);
54 static bool import_cell(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname);
55 static bool import_void(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
56 static bool import_undefined(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
57
58 static const std::string fname("load");
59
60 int sci_hdf5_load_v2(char *fn, int* pvApiCtx)
61 {
62     SciErr sciErr;
63
64     int* piAddr = NULL;
65     char* pstFilename = NULL;
66     char* pstExpandedFilename = NULL;
67     bool bImport = true;
68     const int nbIn = nbInputArgument(pvApiCtx);
69     int iSelectedVar = nbIn - 1;
70
71     CheckInputArgumentAtLeast(pvApiCtx , 1);
72     CheckOutputArgument(pvApiCtx, 1, 1);
73
74     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
75     if (sciErr.iErr)
76     {
77         printError(&sciErr, 0);
78         return 1;
79     }
80
81     if (getAllocatedSingleString(pvApiCtx, piAddr, &pstFilename))
82     {
83         if (pstFilename)
84         {
85             freeAllocatedSingleString(pstFilename);
86         }
87
88         Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), 2);
89         return 1;
90     }
91
92     //open hdf5 file
93     pstExpandedFilename = expandPathVariable(pstFilename);
94     int iFile = openHDF5File(pstExpandedFilename, 0);
95     if (iFile < 0)
96     {
97         Scierror(999, _("%s: Unable to open file: %s\n"), fname.data(), pstFilename);
98         FREE(pstExpandedFilename);
99         FREE(pstFilename);
100         return 1;
101     }
102
103     FREE(pstExpandedFilename);
104     FREE(pstFilename);
105
106     //manage version information
107     int iVersion = getSODFormatAttribute(iFile);
108     if (iVersion != SOD_FILE_VERSION)
109     {
110         if (iVersion > SOD_FILE_VERSION)
111         {
112             //can't read file with version newer that me !
113             Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname.data(), SOD_FILE_VERSION, iVersion);
114             return 1;
115         }
116         else
117         {
118             //call older import functions and exit or ... EXIT !
119             if (iVersion == 1 || iVersion == -1)
120             {
121                 return sci_hdf5_load_v1(fn, pvApiCtx);
122             }
123         }
124     }
125
126     std::vector<wchar_t*> varList;
127     if (iSelectedVar)
128     {
129         //selected variable
130         char* pstVarName = NULL;
131         for (int i = 0 ; i < iSelectedVar ; i++)
132         {
133             sciErr = getVarAddressFromPosition(pvApiCtx, i + 2, &piAddr);
134             if (sciErr.iErr)
135             {
136                 printError(&sciErr, 0);
137                 return 1;
138             }
139
140             if (getAllocatedSingleString(pvApiCtx, piAddr, &pstVarName))
141             {
142                 if (pstVarName)
143                 {
144                     freeAllocatedSingleString(pstVarName);
145                 }
146
147                 Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), i + 1);
148                 return 1;
149             }
150
151             if (import_variable(pvApiCtx, iFile, pstVarName) == false)
152             {
153                 FREE(pstVarName);
154                 bImport = false;
155                 break;
156             }
157
158             varList.push_back(to_wide_string(pstVarName));
159             FREE(pstVarName);
160             pstVarName = NULL;
161         }
162     }
163     else
164     {
165         //all variables
166         int iNbItem = 0;
167         iNbItem = getVariableNames(iFile, NULL);
168         if (iNbItem != 0)
169         {
170             char **pstVarNameList = (char **)MALLOC(sizeof(char *) * iNbItem);
171
172             iNbItem = getVariableNames(iFile, pstVarNameList);
173
174             //import all data
175             for (int i = 0; i < iNbItem; i++)
176             {
177                 if (import_variable(pvApiCtx, iFile, pstVarNameList[i]) == false)
178                 {
179                     bImport = false;
180                     break;
181                 }
182
183                 varList.push_back(to_wide_string(pstVarNameList[i]));
184             }
185
186             freeArrayOfString(pstVarNameList, iNbItem);
187         }
188     }
189     //close the file
190     closeHDF5File(iFile);
191
192     if (bImport == true && varList.size() != 0)
193     {
194         createMatrixOfWideString(pvApiCtx, nbIn + 1, 1, static_cast<int>(varList.size()), varList.data());
195     }
196     else
197     {
198         createEmptyMatrix(pvApiCtx, nbIn + 1);
199     }
200
201     for (auto & i : varList)
202     {
203         FREE(i);
204     }
205
206     AssignOutputVariable(pvApiCtx, 1) = nbIn + 1;
207     ReturnArguments(pvApiCtx);
208
209     //  printf("End gateway !!!\n");
210     return 0;
211 }
212
213 static bool import_variable(int* pvCtx, int _iFile, char* _pstVarName)
214 {
215     int iDataSetId = getDataSetIdFromName(_iFile, _pstVarName);
216     if (iDataSetId <= 0)
217     {
218         return false;
219     }
220
221     return import_data(pvCtx, iDataSetId, 0, NULL, _pstVarName);
222 }
223
224 static bool import_data(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
225 {
226     bool bRet = false;
227
228     //get var type
229     int iVarType = getScilabTypeFromDataSet(_iDatasetId);
230
231     switch (iVarType)
232     {
233         case sci_matrix:
234         {
235             bRet = import_double(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
236             break;
237         }
238         case sci_strings:
239         {
240             bRet = import_string(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
241             break;
242         }
243         case sci_list:
244         case sci_tlist:
245         case sci_mlist:
246         {
247             bRet = import_hypermat(pvCtx, _iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
248             if (bRet == false)
249             {
250                 bRet = import_struct(pvCtx, _iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
251             }
252             if (bRet == false)
253             {
254                 bRet = import_cell(pvCtx, _iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
255             }
256             if (bRet == false)
257             {
258                 bRet = import_list(pvCtx, _iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
259             }
260             break;
261         }
262         case sci_boolean:
263         {
264             bRet = import_boolean(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
265             break;
266         }
267         case sci_poly:
268         {
269             bRet = import_poly(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
270             break;
271         }
272         case sci_ints:
273         {
274             bRet = import_integer(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
275             break;
276         }
277         case sci_sparse:
278         {
279             bRet = import_sparse(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
280             break;
281         }
282         case sci_boolean_sparse:
283         {
284             bRet = import_boolean_sparse(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
285             break;
286         }
287         case sci_void:             //void item only on list variable
288         {
289             bRet = import_void(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
290             break;
291         }
292         case sci_undefined:        //undefined item only on list variable
293         {
294             bRet = import_undefined(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
295             break;
296         }
297         default:
298         {
299             Scierror(999, _("%s: Invalid HDF5 Scilab format.\n"), fname.data());
300         }
301     }
302     return bRet;
303 }
304
305 static bool import_void(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
306 {
307     SciErr sciErr;
308
309     if (_piAddress)
310     {
311         sciErr = createVoidInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos);
312     }
313     else
314     {
315         return false;
316     }
317
318     if (sciErr.iErr)
319     {
320         printError(&sciErr, 0);
321         return false;
322     }
323
324     //close void dataset
325     closeDataSet(_iDatasetId);
326     return true;
327 }
328
329 static bool import_undefined(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
330 {
331     SciErr sciErr;
332
333     if (_piAddress)
334     {
335         sciErr = createUndefinedInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos);
336     }
337     else
338     {
339         return false;
340     }
341
342     if (sciErr.iErr)
343     {
344         printError(&sciErr, 0);
345         return false;
346     }
347
348     //close undefined dataset
349     closeDataSet(_iDatasetId);
350     return true;
351 }
352
353 static bool import_double(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
354 {
355     SciErr sciErr;
356     int iRet = 0;
357     double *pdblReal = NULL;
358     double *pdblImg = NULL;
359     int iDims = 0;
360     int* piDims = NULL;
361     int iComplex = 0;
362     int iSize = 0;
363
364     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
365     if (iRet < 0)
366     {
367         return false;
368     }
369
370     if (iDims)
371     {
372         if (iDims > 2)
373         {
374             //hypermatrix
375             return false;
376         }
377
378         piDims = (int*)MALLOC(sizeof(int) * iDims);
379         iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
380
381         if (iSize > 0)
382         {
383             pdblReal = (double *)MALLOC(iSize * sizeof(double));
384
385             if (iComplex)
386             {
387                 pdblImg = (double *)MALLOC(iSize * sizeof(double));
388                 iRet = readDoubleComplexMatrix(_iDatasetId, pdblReal, pdblImg);
389             }
390             else
391             {
392                 iRet = readDoubleMatrix(_iDatasetId, pdblReal);
393             }
394
395             //to be sure ti have 2 dims
396             if (iDims == 1)
397             {
398                 FREE(piDims);
399                 piDims = (int*)MALLOC(sizeof(int) * 2);
400                 piDims[0] = 1;
401                 piDims[1] = iSize;
402             }
403         }
404     }
405
406     if (iDims == 0 || iSize == 0) //empty matrix
407     {
408         if (piDims)
409         {
410             FREE(piDims);
411         }
412
413         /*bug 7224 : to close dataset */
414         iRet = readEmptyMatrix(_iDatasetId);
415         if (iRet)
416         {
417             return false;
418         }
419
420         // Hack to sure that piDims will not be null at line 372.
421         iDims = 2;
422         piDims = (int*)MALLOC(sizeof(int) * iDims);
423         memset(piDims, 0, sizeof(int) * iDims);
424         pdblReal = (double*)MALLOC(sizeof(double) * 1);
425         pdblReal[0] = 0;
426         iComplex = 0;
427     }
428
429     if (_piAddress == NULL)
430     {
431         if (iComplex)
432         {
433             sciErr = createNamedComplexMatrixOfDouble(pvCtx, _pstVarname, piDims[0], piDims[1], pdblReal, pdblImg);
434         }
435         else
436         {
437             sciErr = createNamedMatrixOfDouble(pvCtx, _pstVarname, piDims[0], piDims[1], pdblReal);
438         }
439     }
440     else //if not null this variable is in a list
441     {
442         if (iComplex)
443         {
444             sciErr = createComplexMatrixOfDoubleInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal, pdblImg);
445         }
446         else
447         {
448             sciErr = createMatrixOfDoubleInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal);
449         }
450     }
451
452     FREE(piDims);
453     FREE(pdblReal);
454     if (iComplex)
455     {
456         FREE(pdblImg);
457     }
458
459     if (sciErr.iErr)
460     {
461         printError(&sciErr, 0);
462         return false;
463     }
464
465     return true;
466 }
467
468 static bool import_string(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
469 {
470     SciErr sciErr;
471     int iRet = 0;
472     char **pstData = NULL;
473     int iDims = 0;
474     int* piDims = NULL;
475     int iComplex = 0;
476     int iSize = 0;
477
478     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
479     if (iRet < 0)
480     {
481         return false;
482     }
483
484     piDims = (int*)MALLOC(sizeof(int) * iDims);
485     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
486
487     pstData = (char **)MALLOC(iSize * sizeof(char *));
488
489     iRet = readStringMatrix(_iDatasetId, pstData);
490     if (iRet)
491     {
492         FREE(piDims);
493         return false;
494     }
495
496     if (_piAddress == NULL)
497     {
498         sciErr = createNamedMatrixOfString(pvCtx, _pstVarname, piDims[0], piDims[1], pstData);
499     }
500     else                        //if not null this variable is in a list
501     {
502         sciErr = createMatrixOfStringInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pstData);
503     }
504
505     if (sciErr.iErr)
506     {
507         printError(&sciErr, 0);
508         FREE(piDims);
509         freeStringMatrix(_iDatasetId, pstData);
510         FREE(pstData);
511         return false;
512     }
513
514     FREE(piDims);
515     freeStringMatrix(_iDatasetId, pstData);
516     FREE(pstData);
517
518     return true;
519 }
520
521 static bool import_integer(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
522 {
523     int iRet = 0;
524     int iDims = 0;
525     int* piDims = NULL;
526     int iComplex = 0;
527     int iSize = 0;
528     int iPrec = 0;
529     SciErr sciErr;
530
531     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
532     if (iRet < 0)
533     {
534         return false;
535     }
536
537     piDims = (int*)MALLOC(sizeof(int) * iDims);
538     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
539
540     iRet = getDatasetPrecision(_iDatasetId, &iPrec);
541     if (iRet)
542     {
543         FREE(piDims);
544         return false;
545     }
546
547     switch (iPrec)
548     {
549         case SCI_INT8:
550         {
551             char *pcData = NULL;
552
553             pcData = (char *)MALLOC(sizeof(char) * iSize);
554             iRet = readInteger8Matrix(_iDatasetId, pcData);
555             if (iRet)
556             {
557                 FREE(piDims);
558                 return false;
559             }
560
561             if (_piAddress == NULL)
562             {
563                 sciErr = createNamedMatrixOfInteger8(pvCtx, _pstVarname, piDims[0], piDims[1], pcData);
564             }
565             else
566             {
567                 sciErr = createMatrixOfInteger8InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pcData);
568             }
569
570             FREE(pcData);
571         }
572         break;
573         case SCI_UINT8:
574         {
575             unsigned char *pucData = NULL;
576
577             pucData = (unsigned char *)MALLOC(sizeof(unsigned char) * iSize);
578             iRet = readUnsignedInteger8Matrix(_iDatasetId, pucData);
579             if (iRet)
580             {
581                 FREE(piDims);
582                 return false;
583             }
584
585             if (_piAddress == NULL)
586             {
587                 sciErr = createNamedMatrixOfUnsignedInteger8(pvCtx, _pstVarname, piDims[0], piDims[1], pucData);
588             }
589             else
590             {
591                 sciErr = createMatrixOfUnsignedInteger8InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pucData);
592             }
593
594             FREE(pucData);
595         }
596         break;
597         case SCI_INT16:
598         {
599             short *psData = NULL;
600
601             psData = (short *)MALLOC(sizeof(short) * iSize);
602             iRet = readInteger16Matrix(_iDatasetId, psData);
603             if (iRet)
604             {
605                 FREE(piDims);
606                 return false;
607             }
608
609             if (_piAddress == NULL)
610             {
611                 sciErr = createNamedMatrixOfInteger16(pvCtx, _pstVarname, piDims[0], piDims[1], psData);
612             }
613             else
614             {
615                 sciErr = createMatrixOfInteger16InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], psData);
616             }
617
618             FREE(psData);
619         }
620         break;
621         case SCI_UINT16:
622         {
623             unsigned short *pusData = NULL;
624
625             pusData = (unsigned short *)MALLOC(sizeof(unsigned short) * iSize);
626             iRet = readUnsignedInteger16Matrix(_iDatasetId, pusData);
627             if (iRet)
628             {
629                 FREE(piDims);
630                 return false;
631             }
632
633             if (_piAddress == NULL)
634             {
635                 sciErr = createNamedMatrixOfUnsignedInteger16(pvCtx, _pstVarname, piDims[0], piDims[1], pusData);
636             }
637             else
638             {
639                 sciErr = createMatrixOfUnsignedInteger16InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pusData);
640             }
641
642             FREE(pusData);
643         }
644         break;
645         case SCI_INT32:
646         {
647             int *piData = NULL;
648
649             piData = (int *)MALLOC(sizeof(int) * iSize);
650             iRet = readInteger32Matrix(_iDatasetId, piData);
651             if (iRet)
652             {
653                 FREE(piDims);
654                 return false;
655             }
656
657             if (_piAddress == NULL)
658             {
659                 sciErr = createNamedMatrixOfInteger32(pvCtx, _pstVarname, piDims[0], piDims[1], piData);
660             }
661             else
662             {
663                 sciErr = createMatrixOfInteger32InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData);
664             }
665
666             FREE(piData);
667         }
668         break;
669         case SCI_UINT32:
670         {
671             unsigned int *puiData = NULL;
672
673             puiData = (unsigned int *)MALLOC(sizeof(unsigned int) * iSize);
674             iRet = readUnsignedInteger32Matrix(_iDatasetId, puiData);
675             if (iRet)
676             {
677                 FREE(piDims);
678                 return false;
679             }
680
681             if (_piAddress == NULL)
682             {
683                 sciErr = createNamedMatrixOfUnsignedInteger32(pvCtx, _pstVarname, piDims[0], piDims[1], puiData);
684             }
685             else
686             {
687                 sciErr = createMatrixOfUnsignedInteger32InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], puiData);
688             }
689
690             FREE(puiData);
691         }
692         break;
693         case SCI_INT64:
694         {
695 #ifdef __SCILAB_INT64__
696             long long *pllData = NULL;
697
698             pllData = (long long *)MALLOC(sizeof(long long) * iSize);
699             iRet = readInteger64Matrix(_iDatasetId, pllData);
700             if (iRet)
701             {
702                 FREE(piDims);
703                 return false;
704             }
705
706             if (_piAddress == NULL)
707             {
708                 sciErr = createNamedMatrixOfInteger64(pvCtx, _pstVarname, piDims[0], piDims[1], pllData);
709             }
710             else
711             {
712                 sciErr = createMatrixOfInteger64InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pllData);
713             }
714
715             FREE(pllData);
716 #else
717             FREE(piDims);
718             return false;
719 #endif
720         }
721         break;
722         case SCI_UINT64:
723         {
724 #ifdef __SCILAB_INT64__
725             unsigned long long *pullData = NULL;
726
727             pullData = (unsigned long long *)MALLOC(sizeof(unsigned long long) * iSize);
728             iRet = readUnsignedInteger64Matrix(_iDatasetId, pullData);
729             if (iRet)
730             {
731                 FREE(piDims);
732                 return false;
733             }
734
735             if (_piAddress == NULL)
736             {
737                 sciErr = createNamedMatrixOfUnsignedInteger64(pvCtx, _pstVarname, piDims[0], piDims[1], pullData);
738             }
739             else
740             {
741                 sciErr = createMatrixOfUnsignedInteger64InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pullData);
742             }
743
744             FREE(pullData);
745 #else
746             FREE(piDims);
747             return false;
748 #endif
749         }
750         break;
751         default:
752             return false;
753     }
754
755     FREE(piDims);
756
757     if (sciErr.iErr)
758     {
759         printError(&sciErr, 0);
760         return false;
761     }
762
763     return true;
764 }
765
766 static bool import_boolean(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
767 {
768     int iRet = 0;
769     int *piData = NULL;
770     int iDims = 0;
771     int* piDims = NULL;
772     int iComplex = 0;
773     int iSize = 0;
774     SciErr sciErr;
775
776     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
777     if (iRet < 0)
778     {
779         return false;
780     }
781
782     piDims = (int*)MALLOC(sizeof(int) * iDims);
783     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
784
785     if (iSize == 0)
786     {
787         FREE(piDims);
788         return false;
789     }
790
791     piData = (int *)MALLOC(iSize * sizeof(int));
792     iRet = readBooleanMatrix(_iDatasetId, piData);
793     if (iRet)
794     {
795         FREE(piData);
796         FREE(piDims);
797         return false;
798     }
799
800     if (_piAddress == NULL)
801     {
802         sciErr = createNamedMatrixOfBoolean(pvCtx, _pstVarname, piDims[0], piDims[1], piData);
803     }
804     else                        //if not null this variable is in a list
805     {
806         sciErr = createMatrixOfBooleanInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData);
807     }
808
809     FREE(piDims);
810     if (piData)
811     {
812         FREE(piData);
813     }
814
815     if (sciErr.iErr)
816     {
817         printError(&sciErr, 0);
818         return false;
819     }
820
821     return true;
822 }
823
824 static bool import_poly(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
825 {
826     int iRet = 0;
827     int iComplex = 0;
828     char pstVarName[64] = { 0 };
829     double **pdblReal = NULL;
830     double **pdblImg = NULL;
831     int *piNbCoef = NULL;
832     int iDims = 0;
833     int* piDims = NULL;
834     int iSize = 0;
835     SciErr sciErr;
836
837     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
838     if (iRet < 0)
839     {
840         return false;
841     }
842
843     piDims = (int*)MALLOC(sizeof(int) * iDims);
844     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
845
846     if (iComplex)
847     {
848         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
849         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
850         pdblImg = (double **)MALLOC(iSize * sizeof(double *));
851         iRet = readPolyComplexMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal, pdblImg);
852     }
853     else
854     {
855         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
856         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
857         iRet = readPolyMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal);
858     }
859
860     if (iRet)
861     {
862         FREE(piDims);
863         FREE(piNbCoef);
864         for (int i = 0; i < iSize; i++)
865         {
866             FREE(pdblReal[i]);
867         }
868         FREE(pdblReal);
869
870         if (iComplex)
871         {
872             for (int i = 0; i < iSize; i++)
873             {
874                 FREE(pdblImg[i]);
875             }
876             FREE(pdblImg);
877         }
878
879         return false;
880     }
881
882     if (_piAddress == NULL)
883     {
884         if (iComplex)
885         {
886             sciErr = createNamedComplexMatrixOfPoly(pvCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal, pdblImg);
887         }
888         else
889         {
890             sciErr = createNamedMatrixOfPoly(pvCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
891         }
892     }
893     else                        //if not null this variable is in a list
894     {
895         if (iComplex)
896         {
897             sciErr =
898                 createComplexMatrixOfPolyInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal,
899                         pdblImg);
900         }
901         else
902         {
903             sciErr = createMatrixOfPolyInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
904         }
905     }
906
907     FREE(piDims);
908     FREE(piNbCoef);
909     for (int i = 0; i < iSize; i++)
910     {
911         FREE(pdblReal[i]);
912     }
913
914     FREE(pdblReal);
915
916     if (iComplex)
917     {
918         for (int i = 0; i < iSize; i++)
919         {
920             FREE(pdblImg[i]);
921         }
922
923         FREE(pdblImg);
924     }
925
926     if (sciErr.iErr)
927     {
928         printError(&sciErr, 0);
929         return false;
930     }
931
932     return true;
933 }
934
935 static bool import_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
936 {
937     int iRet = 0;
938     int iRows = 0;
939     int iCols = 0;
940     int iComplex = 0;
941     double *pdblReal = NULL;
942     double *pdblImg = NULL;
943     int iNbItem = 0;
944     int *piNbItemRow = NULL;
945     int *piColPos = NULL;
946     SciErr sciErr;
947
948     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
949     if (iRet)
950     {
951         return false;
952     }
953
954     iComplex = isComplexData(_iDatasetId);
955
956     if (iComplex)
957     {
958         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
959         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
960         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
961         pdblImg = (double *)MALLOC(iNbItem * sizeof(double));
962         iRet = readSparseComplexMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
963     }
964     else
965     {
966         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
967         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
968         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
969         iRet = readSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
970     }
971
972     if (iRet)
973     {
974         FREE(piNbItemRow);
975         FREE(piColPos);
976         FREE(pdblReal);
977         if (iComplex)
978         {
979             FREE(pdblImg);
980         }
981
982         return false;
983     }
984
985     if (_piAddress == NULL)
986     {
987         if (iComplex)
988         {
989             sciErr = createNamedComplexSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
990         }
991         else
992         {
993             sciErr = createNamedSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
994         }
995     }
996     else //if not null this variable is in a list
997     {
998         if (iComplex)
999         {
1000             sciErr = createComplexSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
1001         }
1002         else
1003         {
1004             sciErr = createSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
1005         }
1006     }
1007
1008     FREE(piNbItemRow);
1009     FREE(piColPos);
1010     FREE(pdblReal);
1011     if (iComplex)
1012     {
1013         FREE(pdblImg);
1014     }
1015
1016     if (sciErr.iErr)
1017     {
1018         printError(&sciErr, 0);
1019         return false;
1020     }
1021
1022     return true;
1023 }
1024
1025 static bool import_boolean_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
1026 {
1027     int iRet = 0;
1028     int iRows = 0;
1029     int iCols = 0;
1030     int iNbItem = 0;
1031     int *piNbItemRow = NULL;
1032     int *piColPos = NULL;
1033     SciErr sciErr;
1034
1035     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
1036     if (iRet)
1037     {
1038         return false;
1039     }
1040
1041     piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
1042     piColPos = (int *)MALLOC(iNbItem * sizeof(int));
1043
1044     iRet = readBooleanSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1045     if (iRet)
1046     {
1047         FREE(piNbItemRow);
1048         return false;
1049     }
1050
1051     if (_piAddress == NULL)
1052     {
1053         sciErr = createNamedBooleanSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1054     }
1055     else                        //if not null this variable is in a list
1056     {
1057         sciErr = createBooleanSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1058     }
1059
1060     FREE(piNbItemRow);
1061     FREE(piColPos);
1062
1063     if (sciErr.iErr)
1064     {
1065         printError(&sciErr, 0);
1066         return false;
1067     }
1068
1069     return true;
1070 }
1071
1072 static bool import_list(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1073 {
1074     int iRet = 0;
1075     int i = 0;
1076     int iItems = 0;
1077     int *piListAddr = NULL;
1078     hobj_ref_t *piItemRef = NULL;
1079     SciErr sciErr;
1080
1081     iRet = getListDims(_iDatasetId, &iItems);
1082     if (iRet)
1083     {
1084         return false;
1085     }
1086
1087     if (iItems == 0)
1088     {
1089         //special case for empty list
1090     }
1091     else
1092     {
1093         iRet = getListItemReferences(_iDatasetId, &piItemRef);
1094         if (iRet)
1095         {
1096             return false;
1097         }
1098     }
1099
1100     if (_piAddress == 0)
1101     {
1102         switch (_iVarType)
1103         {
1104             case sci_list:
1105                 sciErr = createNamedList(pvCtx, _pstVarname, iItems, &piListAddr);
1106                 break;
1107             case sci_tlist:
1108                 sciErr = createNamedTList(pvCtx, _pstVarname, iItems, &piListAddr);
1109                 break;
1110             case sci_mlist:
1111                 sciErr = createNamedMList(pvCtx, _pstVarname, iItems, &piListAddr);
1112                 break;
1113             default:
1114                 return false;
1115         }
1116     }
1117     else                        //if not null this variable is in a list
1118     {
1119         switch (_iVarType)
1120         {
1121             case sci_list:
1122                 sciErr = createListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1123                 break;
1124             case sci_tlist:
1125                 sciErr = createTListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1126                 break;
1127             case sci_mlist:
1128                 sciErr = createMListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1129                 break;
1130             default:
1131                 return false;
1132         }
1133     }
1134
1135     if (sciErr.iErr)
1136     {
1137         printError(&sciErr, 0);
1138         return false;
1139     }
1140
1141     for (i = 0; i < iItems; i++)
1142     {
1143         int iItemDataset = 0;
1144
1145         iRet = getListItemDataset(_iDatasetId, piItemRef, i, &iItemDataset);
1146         if (iRet || iItemDataset == 0)
1147         {
1148             return false;
1149         }
1150
1151         bool bRet = import_data(pvCtx, iItemDataset, i + 1, piListAddr, _pstVarname);
1152
1153         if (bRet == false)
1154         {
1155             return false;
1156         }
1157     }
1158
1159     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1160     if (iRet)
1161     {
1162         return false;
1163     }
1164
1165     return true;
1166 }
1167
1168 static bool import_hypermat(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1169 {
1170     int iRet = 0;
1171     int iComplex = 0;
1172     int iDims = 0;
1173     int iItems = 0;
1174     hobj_ref_t *piItemRef = NULL;
1175
1176     // an hypermatrix is stored in an mlist
1177     if (_iVarType != sci_mlist)
1178     {
1179         return false;
1180     }
1181
1182     iRet = getListDims(_iDatasetId, &iItems);
1183     if (iRet)
1184     {
1185         return false;
1186     }
1187
1188     if (iItems != 3)
1189     {
1190         // hypermatrix have 3 elements
1191         return false;
1192     }
1193
1194     iRet = getListItemReferences(_iDatasetId, &piItemRef);
1195     if (iRet)
1196     {
1197         deleteListItemReferences(_iDatasetId, piItemRef);
1198         return false;
1199     }
1200
1201     // get first item
1202     int iItemDataset = 0;
1203     iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
1204     if (iRet || iItemDataset == 0)
1205     {
1206         deleteListItemReferences(_iDatasetId, piItemRef);
1207         return false;
1208     }
1209
1210     // get first item type
1211     int iItemType = getScilabTypeFromDataSet(iItemDataset);
1212     if (iItemType != sci_strings)
1213     {
1214         deleteListItemReferences(_iDatasetId, piItemRef);
1215         return false;
1216     }
1217
1218     // get size of first item
1219     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1220     if (iRet < 0 || iDims != 2)
1221     {
1222         deleteListItemReferences(_iDatasetId, piItemRef);
1223         return false;
1224     }
1225
1226     int* piDims = new int[2];
1227     int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1228     if (iSize != 3)
1229     {
1230         deleteListItemReferences(_iDatasetId, piItemRef);
1231         delete[] piDims;
1232         return false;
1233     }
1234
1235     delete[] piDims;
1236     piDims = NULL;
1237
1238     // get data of first item for check the type of mlist
1239     char** pstData = new char*[iSize];
1240     iRet = readStringMatrix(iItemDataset, pstData);
1241     if (iRet || strcmp(pstData[0], "hm") != 0)
1242     {
1243         // if not the good type, do not h5close (deleteListItemReferences)
1244         FREE(piItemRef);
1245         freeStringMatrix(iItemDataset, pstData);
1246         delete[] pstData;
1247         return false;
1248     }
1249
1250     freeStringMatrix(iItemDataset, pstData);
1251     delete[] pstData;
1252     pstData = NULL;
1253
1254     // get second item, the Size of hypermatrix
1255     iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
1256     if (iRet)
1257     {
1258         deleteListItemReferences(_iDatasetId, piItemRef);
1259         return false;
1260     }
1261
1262     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1263     if (iRet < 0 || iDims != 2)
1264     {
1265         deleteListItemReferences(_iDatasetId, piItemRef);
1266         return false;
1267     }
1268
1269     piDims = new int[2];
1270     iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1271     if (piDims[0] != 1)
1272     {
1273         deleteListItemReferences(_iDatasetId, piItemRef);
1274         delete[] piDims;
1275         return false;
1276     }
1277
1278     int* piDimsArray = new int[piDims[1]];
1279     iRet = readInteger32Matrix(iItemDataset, piDimsArray);
1280     if (iRet)
1281     {
1282         deleteListItemReferences(_iDatasetId, piItemRef);
1283         delete[] piDims;
1284         delete[] piDimsArray;
1285         return false;
1286     }
1287
1288     // get third item, the Data of hypermatrix
1289     // import data like a "type" (Double, Int, ...) instead of mlist
1290     iRet = getListItemDataset(_iDatasetId, piItemRef, 2, &iItemDataset);
1291     bool bRet = import_data(pvCtx, iItemDataset, _iItemPos, _piAddress, _pstVarname);
1292     if (bRet == false)
1293     {
1294         deleteListItemReferences(_iDatasetId, piItemRef);
1295         delete[] piDims;
1296         delete[] piDimsArray;
1297         return false;
1298     }
1299
1300     // get imported hypermatrix from List or Context
1301     types::GenericType* pGT = NULL;
1302     types::InternalType* pIT = NULL;
1303     if (_piAddress)
1304     {
1305         types::List* pL = (types::List*)_piAddress;
1306         pIT = pL->get(_iItemPos - 1);
1307     }
1308     else
1309     {
1310         wchar_t* pwcsName = to_wide_string(_pstVarname);
1311         pIT = symbol::Context::getInstance()->getCurrentLevel(symbol::Symbol(pwcsName));
1312         FREE(pwcsName);
1313     }
1314
1315     // reshape data with size of hypermatrix
1316     pGT = pIT->getAs<types::GenericType>();
1317     pGT->reshape(piDimsArray, piDims[1]);
1318
1319     delete[] piDims;
1320     delete[] piDimsArray;
1321
1322
1323     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1324     if (iRet)
1325     {
1326         return false;
1327     }
1328
1329     return true;
1330 }
1331 /*--------------------------------------------------------------------------*/
1332
1333 static bool import_struct(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1334 {
1335     int iRet = 0;
1336     int iComplex = 0;
1337     int iDims = 0;
1338     int iItems = 0;
1339     hobj_ref_t *piItemRef = NULL;
1340
1341     // an struct is stored in an mlist
1342     if (_iVarType != sci_mlist)
1343     {
1344         return false;
1345     }
1346
1347     iRet = getListDims(_iDatasetId, &iItems);
1348     if (iRet)
1349     {
1350         return false;
1351     }
1352
1353     if (iItems < 2)
1354     {
1355         // struct have 2 elements minimal
1356         return false;
1357     }
1358
1359     iRet = getListItemReferences(_iDatasetId, &piItemRef);
1360     if (iRet)
1361     {
1362         deleteListItemReferences(_iDatasetId, piItemRef);
1363         return false;
1364     }
1365
1366     // get first item
1367     int iItemDataset = 0;
1368     iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
1369     if (iRet || iItemDataset == 0)
1370     {
1371         deleteListItemReferences(_iDatasetId, piItemRef);
1372         return false;
1373     }
1374
1375     // get first item type
1376     int iItemType = getScilabTypeFromDataSet(iItemDataset);
1377     if (iItemType != sci_strings)
1378     {
1379         deleteListItemReferences(_iDatasetId, piItemRef);
1380         return false;
1381     }
1382
1383     // get size of first item
1384     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1385     if (iRet < 0 || iDims != 2)
1386     {
1387         deleteListItemReferences(_iDatasetId, piItemRef);
1388         return false;
1389     }
1390
1391     int* piDims = new int[2];
1392     int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1393     if (iSize != iItems)
1394     {
1395         deleteListItemReferences(_iDatasetId, piItemRef);
1396         delete[] piDims;
1397         return false;
1398     }
1399
1400     delete[] piDims;
1401     piDims = NULL;
1402
1403     // get data of first item for check the type of mlist
1404     char** pstData = new char*[iSize];
1405     char** pstDataSave = new char*[iSize - 2];
1406     iRet = readStringMatrix(iItemDataset, pstData);
1407     if (iRet || strcmp(pstData[0], "st") != 0)
1408     {
1409         // if not the good type, do not h5close (deleteListItemReferences)
1410         FREE(piItemRef);
1411         freeStringMatrix(iItemDataset, pstData);
1412         delete[] pstData;
1413         delete[] pstDataSave;
1414         return false;
1415     }
1416
1417     for (int i = 2; i < iSize; ++i)
1418     {
1419         pstDataSave[-2 + i] = new char[strlen(pstData[i]) + 1];
1420         strcpy(pstDataSave[-2 + i], pstData[i]);
1421     }
1422
1423     freeStringMatrix(iItemDataset, pstData);
1424     delete[] pstData;
1425     pstData = NULL;
1426
1427     // get second item, the Size of struct
1428     iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
1429     if (iRet)
1430     {
1431         deleteListItemReferences(_iDatasetId, piItemRef);
1432         for (int i = 0; i < (-2 + iItems); ++i)
1433         {
1434             delete pstDataSave[i];
1435         }
1436         delete[] pstDataSave;
1437         pstDataSave = NULL;
1438         return false;
1439     }
1440
1441     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1442     if (iRet < 0 || iDims != 2)
1443     {
1444         deleteListItemReferences(_iDatasetId, piItemRef);
1445         for (int i = 0; i < (-2 + iItems); ++i)
1446         {
1447             delete pstDataSave[i];
1448         }
1449         delete[] pstDataSave;
1450         pstDataSave = NULL;
1451         return false;
1452     }
1453
1454     piDims = new int[2];
1455     iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1456     if (piDims[0] != 1)
1457     {
1458         deleteListItemReferences(_iDatasetId, piItemRef);
1459         for (int i = 0; i < (-2 + iItems); ++i)
1460         {
1461             delete pstDataSave[i];
1462         }
1463         delete[] pstDataSave;
1464         pstDataSave = NULL;
1465         delete[] piDims;
1466         return false;
1467     }
1468
1469     int* piDimsArray = new int[piDims[1]];
1470     iRet = readInteger32Matrix(iItemDataset, piDimsArray);
1471     if (iRet)
1472     {
1473         deleteListItemReferences(_iDatasetId, piItemRef);
1474         for (int i = 0; i < (-2 + iItems); ++i)
1475         {
1476             delete pstDataSave[i];
1477         }
1478         delete[] pstDataSave;
1479         pstDataSave = NULL;
1480         delete[] piDims;
1481         delete[] piDimsArray;
1482         return false;
1483     }
1484
1485     types::Struct* pStruct = new types::Struct(piDims[1], piDimsArray);
1486
1487     wchar_t* pwstName = NULL;
1488     for (int i = 0; i < (-2 + iItems); ++i)
1489     {
1490         pwstName = to_wide_string(pstDataSave[i]);
1491         pStruct->addField(pwstName);
1492         delete pstDataSave[i];
1493         FREE(pwstName);
1494     }
1495
1496     delete[] pstDataSave;
1497     pstDataSave = NULL;
1498
1499     types::SingleStruct** ppSStruct =  pStruct->get();
1500     types::String* pStr = pStruct->getFieldNames();
1501
1502     types::List* pList = new types::List();
1503     // fill the list to avoid api_scilab error about the list size.
1504     pList->set(0, types::Double::Empty());
1505
1506     if (pStruct->getSize() == 1)
1507     {
1508         types::InternalType* pIT = NULL;
1509         for (int i = 0; i < pStr->getSize(); ++i)
1510         {
1511             int iItemDataset = 0;
1512             iRet = getListItemDataset(_iDatasetId, piItemRef, i + 2, &iItemDataset);
1513             if (iRet || iItemDataset == 0)
1514             {
1515                 deleteListItemReferences(_iDatasetId, piItemRef);
1516                 delete pList;
1517                 delete pStruct;
1518                 return false;
1519             }
1520
1521             wchar_t* pwcsName = pStr->get(i);
1522             char* pcName = wide_string_to_UTF8(pwcsName);
1523
1524             bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, pcName);
1525             if (bRet == false)
1526             {
1527                 deleteListItemReferences(_iDatasetId, piItemRef);
1528                 delete pList;
1529                 delete pStruct;
1530                 return false;
1531             }
1532
1533             pIT = pList->get(0);
1534             ppSStruct[0]->set(pwcsName, pIT);
1535             FREE(pcName);
1536         }
1537     }
1538     else if (pStruct->getSize() > 1)
1539     {
1540         for (int i = 0; i < pStr->getSize(); ++i)
1541         {
1542             int iItemDataset = 0;
1543             iRet = getListItemDataset(_iDatasetId, piItemRef, i + 2, &iItemDataset);
1544             if (iRet || iItemDataset == 0)
1545             {
1546                 deleteListItemReferences(_iDatasetId, piItemRef);
1547                 delete pList;
1548                 delete pStruct;
1549                 return false;
1550             }
1551
1552             wchar_t* pwcsName = pStr->get(i);
1553             char* pcName = wide_string_to_UTF8(pwcsName);
1554
1555             bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, pcName);
1556             if (bRet == false)
1557             {
1558                 deleteListItemReferences(_iDatasetId, piItemRef);
1559                 delete pList;
1560                 delete pStruct;
1561                 return false;
1562             }
1563
1564             types::List* pListData = pList->get(0)->getAs<types::List>();
1565             for (int iWriteData = 0; iWriteData < pStruct->getSize(); ++iWriteData)
1566             {
1567                 ppSStruct[iWriteData]->set(pwcsName, pListData->get(iWriteData));
1568             }
1569
1570             FREE(pcName);
1571         }
1572
1573     }
1574
1575     delete pList;
1576     if (_piAddress == NULL)
1577     {
1578         pwstName = to_wide_string(_pstVarname);
1579         symbol::Context::getInstance()->put(symbol::Symbol(pwstName), pStruct);
1580         FREE(pwstName);
1581     }
1582     else
1583     {
1584         types::List* pParentList = (types::List*)_piAddress;
1585         pParentList->set(_iItemPos - 1, pStruct);
1586     }
1587
1588     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1589     if (iRet)
1590     {
1591         return false;
1592     }
1593
1594     return true;
1595 }
1596 /*--------------------------------------------------------------------------*/
1597
1598
1599 static bool import_cell(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1600 {
1601     int iRet = 0;
1602     int iComplex = 0;
1603     int iDims = 0;
1604     int iItems = 0;
1605     hobj_ref_t *piItemRef = NULL;
1606
1607     // an hypermatrix is stored in an mlist
1608     if (_iVarType != sci_mlist)
1609     {
1610         return false;
1611     }
1612
1613     iRet = getListDims(_iDatasetId, &iItems);
1614     if (iRet)
1615     {
1616         return false;
1617     }
1618
1619     if (iItems != 3)
1620     {
1621         // cell have 3 elements
1622         return false;
1623     }
1624
1625     iRet = getListItemReferences(_iDatasetId, &piItemRef);
1626     if (iRet)
1627     {
1628         deleteListItemReferences(_iDatasetId, piItemRef);
1629         return false;
1630     }
1631
1632     // get first item
1633     int iItemDataset = 0;
1634     iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
1635     if (iRet || iItemDataset == 0)
1636     {
1637         deleteListItemReferences(_iDatasetId, piItemRef);
1638         return false;
1639     }
1640
1641     // get first item type
1642     int iItemType = getScilabTypeFromDataSet(iItemDataset);
1643     if (iItemType != sci_strings)
1644     {
1645         deleteListItemReferences(_iDatasetId, piItemRef);
1646         return false;
1647     }
1648
1649     // get size of first item
1650     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1651     if (iRet < 0 || iDims != 2)
1652     {
1653         deleteListItemReferences(_iDatasetId, piItemRef);
1654         return false;
1655     }
1656
1657     int* piDims = new int[2];
1658     int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1659     if (iSize != 3)
1660     {
1661         deleteListItemReferences(_iDatasetId, piItemRef);
1662         delete[] piDims;
1663         return false;
1664     }
1665
1666     delete[] piDims;
1667     piDims = NULL;
1668
1669     // get data of first item for check the type of mlist
1670     char** pstData = new char*[iSize];
1671     iRet = readStringMatrix(iItemDataset, pstData);
1672     if (iRet || strcmp(pstData[0], "ce") != 0)
1673     {
1674         // if not the good type, do not h5close (deleteListItemReferences)
1675         FREE(piItemRef);
1676         freeStringMatrix(iItemDataset, pstData);
1677         delete[] pstData;
1678         return false;
1679     }
1680
1681     freeStringMatrix(iItemDataset, pstData);
1682     delete[] pstData;
1683     pstData = NULL;
1684
1685     // get second item, the Size of cell
1686     iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
1687     if (iRet)
1688     {
1689         deleteListItemReferences(_iDatasetId, piItemRef);
1690         return false;
1691     }
1692
1693     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1694     if (iRet < 0 || iDims != 2)
1695     {
1696         deleteListItemReferences(_iDatasetId, piItemRef);
1697         return false;
1698     }
1699
1700     piDims = new int[2];
1701     iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1702     if (piDims[0] != 1)
1703     {
1704         deleteListItemReferences(_iDatasetId, piItemRef);
1705         delete[] piDims;
1706         return false;
1707     }
1708
1709     int* piDimsArray = new int[piDims[1]];
1710     iRet = readInteger32Matrix(iItemDataset, piDimsArray);
1711     if (iRet)
1712     {
1713         deleteListItemReferences(_iDatasetId, piItemRef);
1714         delete[] piDims;
1715         delete[] piDimsArray;
1716         return false;
1717     }
1718
1719     types::Cell* pCell = new types::Cell(piDims[1], piDimsArray);
1720     types::List* pList = new types::List();
1721     pList->set(0, types::Double::Empty());
1722
1723     iRet = getListItemDataset(_iDatasetId, piItemRef, 2, &iItemDataset);
1724     if (iRet || iItemDataset == 0)
1725     {
1726         deleteListItemReferences(_iDatasetId, piItemRef);
1727         delete pList;
1728         delete pCell;
1729         return false;
1730     }
1731
1732     bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, NULL);
1733     if (bRet == false)
1734     {
1735         deleteListItemReferences(_iDatasetId, piItemRef);
1736         delete pList;
1737         delete pCell;
1738         return false;
1739     }
1740
1741     types::List* pListData = pList->get(0)->getAs<types::List>();
1742     for (int iWriteData = 0; iWriteData < pCell->getSize(); ++iWriteData)
1743     {
1744         pCell->set(iWriteData, pListData->get(iWriteData));
1745     }
1746
1747     delete pList;
1748
1749     if (_piAddress == NULL)
1750     {
1751         wchar_t* pwstName = to_wide_string(_pstVarname);
1752         symbol::Context::getInstance()->put(symbol::Symbol(pwstName), pCell);
1753         FREE(pwstName);
1754     }
1755     else
1756     {
1757         types::List* pParentList = (types::List*)_piAddress;
1758         pParentList->set(_iItemPos - 1, pCell);
1759     }
1760
1761     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1762
1763     if (iRet)
1764     {
1765         return false;
1766     }
1767
1768     return true;
1769 }
1770 /*--------------------------------------------------------------------------*/
1771