Coverity: hdf5 module resource leaks fixed
[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             FREE(piDims);
753             return false;
754     }
755
756     FREE(piDims);
757
758     if (sciErr.iErr)
759     {
760         printError(&sciErr, 0);
761         return false;
762     }
763
764     return true;
765 }
766
767 static bool import_boolean(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
768 {
769     int iRet = 0;
770     int *piData = NULL;
771     int iDims = 0;
772     int* piDims = NULL;
773     int iComplex = 0;
774     int iSize = 0;
775     SciErr sciErr;
776
777     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
778     if (iRet < 0)
779     {
780         return false;
781     }
782
783     piDims = (int*)MALLOC(sizeof(int) * iDims);
784     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
785
786     if (iSize == 0)
787     {
788         FREE(piDims);
789         return false;
790     }
791
792     piData = (int *)MALLOC(iSize * sizeof(int));
793     iRet = readBooleanMatrix(_iDatasetId, piData);
794     if (iRet)
795     {
796         FREE(piData);
797         FREE(piDims);
798         return false;
799     }
800
801     if (_piAddress == NULL)
802     {
803         sciErr = createNamedMatrixOfBoolean(pvCtx, _pstVarname, piDims[0], piDims[1], piData);
804     }
805     else                        //if not null this variable is in a list
806     {
807         sciErr = createMatrixOfBooleanInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData);
808     }
809
810     FREE(piDims);
811     if (piData)
812     {
813         FREE(piData);
814     }
815
816     if (sciErr.iErr)
817     {
818         printError(&sciErr, 0);
819         return false;
820     }
821
822     return true;
823 }
824
825 static bool import_poly(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
826 {
827     int iRet = 0;
828     int iComplex = 0;
829     char pstVarName[64] = { 0 };
830     double **pdblReal = NULL;
831     double **pdblImg = NULL;
832     int *piNbCoef = NULL;
833     int iDims = 0;
834     int* piDims = NULL;
835     int iSize = 0;
836     SciErr sciErr;
837
838     iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
839     if (iRet < 0)
840     {
841         return false;
842     }
843
844     piDims = (int*)MALLOC(sizeof(int) * iDims);
845     iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
846
847     if (iComplex)
848     {
849         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
850         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
851         pdblImg = (double **)MALLOC(iSize * sizeof(double *));
852         iRet = readPolyComplexMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal, pdblImg);
853     }
854     else
855     {
856         piNbCoef = (int *)MALLOC(iSize * sizeof(int));
857         pdblReal = (double **)MALLOC(iSize * sizeof(double *));
858         iRet = readPolyMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal);
859     }
860
861     if (iRet)
862     {
863         FREE(piDims);
864         FREE(piNbCoef);
865         for (int i = 0; i < iSize; i++)
866         {
867             FREE(pdblReal[i]);
868         }
869         FREE(pdblReal);
870
871         if (iComplex)
872         {
873             for (int i = 0; i < iSize; i++)
874             {
875                 FREE(pdblImg[i]);
876             }
877             FREE(pdblImg);
878         }
879
880         return false;
881     }
882
883     if (_piAddress == NULL)
884     {
885         if (iComplex)
886         {
887             sciErr = createNamedComplexMatrixOfPoly(pvCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal, pdblImg);
888         }
889         else
890         {
891             sciErr = createNamedMatrixOfPoly(pvCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
892         }
893     }
894     else                        //if not null this variable is in a list
895     {
896         if (iComplex)
897         {
898             sciErr =
899                 createComplexMatrixOfPolyInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal,
900                         pdblImg);
901         }
902         else
903         {
904             sciErr = createMatrixOfPolyInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal);
905         }
906     }
907
908     FREE(piDims);
909     FREE(piNbCoef);
910     for (int i = 0; i < iSize; i++)
911     {
912         FREE(pdblReal[i]);
913     }
914
915     FREE(pdblReal);
916
917     if (iComplex)
918     {
919         for (int i = 0; i < iSize; i++)
920         {
921             FREE(pdblImg[i]);
922         }
923
924         FREE(pdblImg);
925     }
926
927     if (sciErr.iErr)
928     {
929         printError(&sciErr, 0);
930         return false;
931     }
932
933     return true;
934 }
935
936 static bool import_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
937 {
938     int iRet = 0;
939     int iRows = 0;
940     int iCols = 0;
941     int iComplex = 0;
942     double *pdblReal = NULL;
943     double *pdblImg = NULL;
944     int iNbItem = 0;
945     int *piNbItemRow = NULL;
946     int *piColPos = NULL;
947     SciErr sciErr;
948
949     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
950     if (iRet)
951     {
952         return false;
953     }
954
955     iComplex = isComplexData(_iDatasetId);
956
957     if (iComplex)
958     {
959         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
960         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
961         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
962         pdblImg = (double *)MALLOC(iNbItem * sizeof(double));
963         iRet = readSparseComplexMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
964     }
965     else
966     {
967         piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
968         piColPos = (int *)MALLOC(iNbItem * sizeof(int));
969         pdblReal = (double *)MALLOC(iNbItem * sizeof(double));
970         iRet = readSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
971     }
972
973     if (iRet)
974     {
975         FREE(piNbItemRow);
976         FREE(piColPos);
977         FREE(pdblReal);
978         if (iComplex)
979         {
980             FREE(pdblImg);
981         }
982
983         return false;
984     }
985
986     if (_piAddress == NULL)
987     {
988         if (iComplex)
989         {
990             sciErr = createNamedComplexSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
991         }
992         else
993         {
994             sciErr = createNamedSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
995         }
996     }
997     else //if not null this variable is in a list
998     {
999         if (iComplex)
1000         {
1001             sciErr = createComplexSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
1002         }
1003         else
1004         {
1005             sciErr = createSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
1006         }
1007     }
1008
1009     FREE(piNbItemRow);
1010     FREE(piColPos);
1011     FREE(pdblReal);
1012     if (iComplex)
1013     {
1014         FREE(pdblImg);
1015     }
1016
1017     if (sciErr.iErr)
1018     {
1019         printError(&sciErr, 0);
1020         return false;
1021     }
1022
1023     return true;
1024 }
1025
1026 static bool import_boolean_sparse(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
1027 {
1028     int iRet = 0;
1029     int iRows = 0;
1030     int iCols = 0;
1031     int iNbItem = 0;
1032     int *piNbItemRow = NULL;
1033     int *piColPos = NULL;
1034     SciErr sciErr;
1035
1036     iRet = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
1037     if (iRet)
1038     {
1039         return false;
1040     }
1041
1042     piNbItemRow = (int *)MALLOC(iRows * sizeof(int));
1043     piColPos = (int *)MALLOC(iNbItem * sizeof(int));
1044
1045     iRet = readBooleanSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1046     if (iRet)
1047     {
1048         FREE(piNbItemRow);
1049         return false;
1050     }
1051
1052     if (_piAddress == NULL)
1053     {
1054         sciErr = createNamedBooleanSparseMatrix(pvCtx, _pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1055     }
1056     else                        //if not null this variable is in a list
1057     {
1058         sciErr = createBooleanSparseMatrixInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos);
1059     }
1060
1061     FREE(piNbItemRow);
1062     FREE(piColPos);
1063
1064     if (sciErr.iErr)
1065     {
1066         printError(&sciErr, 0);
1067         return false;
1068     }
1069
1070     return true;
1071 }
1072
1073 static bool import_list(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1074 {
1075     int iRet = 0;
1076     int i = 0;
1077     int iItems = 0;
1078     int *piListAddr = NULL;
1079     hobj_ref_t *piItemRef = NULL;
1080     SciErr sciErr;
1081
1082     iRet = getListDims(_iDatasetId, &iItems);
1083     if (iRet)
1084     {
1085         return false;
1086     }
1087
1088     if (iItems == 0)
1089     {
1090         //special case for empty list
1091     }
1092     else
1093     {
1094         iRet = getListItemReferences(_iDatasetId, &piItemRef);
1095         if (iRet)
1096         {
1097             return false;
1098         }
1099     }
1100
1101     if (_piAddress == 0)
1102     {
1103         switch (_iVarType)
1104         {
1105             case sci_list:
1106                 sciErr = createNamedList(pvCtx, _pstVarname, iItems, &piListAddr);
1107                 break;
1108             case sci_tlist:
1109                 sciErr = createNamedTList(pvCtx, _pstVarname, iItems, &piListAddr);
1110                 break;
1111             case sci_mlist:
1112                 sciErr = createNamedMList(pvCtx, _pstVarname, iItems, &piListAddr);
1113                 break;
1114             default:
1115                 return false;
1116         }
1117     }
1118     else                        //if not null this variable is in a list
1119     {
1120         switch (_iVarType)
1121         {
1122             case sci_list:
1123                 sciErr = createListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1124                 break;
1125             case sci_tlist:
1126                 sciErr = createTListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1127                 break;
1128             case sci_mlist:
1129                 sciErr = createMListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
1130                 break;
1131             default:
1132                 return false;
1133         }
1134     }
1135
1136     if (sciErr.iErr)
1137     {
1138         printError(&sciErr, 0);
1139         return false;
1140     }
1141
1142     for (i = 0; i < iItems; i++)
1143     {
1144         int iItemDataset = 0;
1145
1146         iRet = getListItemDataset(_iDatasetId, piItemRef, i, &iItemDataset);
1147         if (iRet || iItemDataset == 0)
1148         {
1149             return false;
1150         }
1151
1152         bool bRet = import_data(pvCtx, iItemDataset, i + 1, piListAddr, _pstVarname);
1153
1154         if (bRet == false)
1155         {
1156             return false;
1157         }
1158     }
1159
1160     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1161     if (iRet)
1162     {
1163         return false;
1164     }
1165
1166     return true;
1167 }
1168
1169 static bool import_hypermat(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1170 {
1171     int iRet = 0;
1172     int iComplex = 0;
1173     int iDims = 0;
1174     int iItems = 0;
1175     hobj_ref_t *piItemRef = NULL;
1176
1177     // an hypermatrix is stored in an mlist
1178     if (_iVarType != sci_mlist)
1179     {
1180         return false;
1181     }
1182
1183     iRet = getListDims(_iDatasetId, &iItems);
1184     if (iRet)
1185     {
1186         return false;
1187     }
1188
1189     if (iItems != 3)
1190     {
1191         // hypermatrix have 3 elements
1192         return false;
1193     }
1194
1195     iRet = getListItemReferences(_iDatasetId, &piItemRef);
1196     if (iRet)
1197     {
1198         deleteListItemReferences(_iDatasetId, piItemRef);
1199         return false;
1200     }
1201
1202     // get first item
1203     int iItemDataset = 0;
1204     iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
1205     if (iRet || iItemDataset == 0)
1206     {
1207         deleteListItemReferences(_iDatasetId, piItemRef);
1208         return false;
1209     }
1210
1211     // get first item type
1212     int iItemType = getScilabTypeFromDataSet(iItemDataset);
1213     if (iItemType != sci_strings)
1214     {
1215         deleteListItemReferences(_iDatasetId, piItemRef);
1216         return false;
1217     }
1218
1219     // get size of first item
1220     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1221     if (iRet < 0 || iDims != 2)
1222     {
1223         deleteListItemReferences(_iDatasetId, piItemRef);
1224         return false;
1225     }
1226
1227     int* piDims = new int[2];
1228     int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1229     if (iSize != 3)
1230     {
1231         deleteListItemReferences(_iDatasetId, piItemRef);
1232         delete[] piDims;
1233         return false;
1234     }
1235
1236     delete[] piDims;
1237     piDims = NULL;
1238
1239     // get data of first item for check the type of mlist
1240     char** pstData = new char*[iSize];
1241     iRet = readStringMatrix(iItemDataset, pstData);
1242     if (iRet || strcmp(pstData[0], "hm") != 0)
1243     {
1244         // if not the good type, do not h5close (deleteListItemReferences)
1245         FREE(piItemRef);
1246         freeStringMatrix(iItemDataset, pstData);
1247         delete[] pstData;
1248         return false;
1249     }
1250
1251     freeStringMatrix(iItemDataset, pstData);
1252     delete[] pstData;
1253     pstData = NULL;
1254
1255     // get second item, the Size of hypermatrix
1256     iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
1257     if (iRet)
1258     {
1259         deleteListItemReferences(_iDatasetId, piItemRef);
1260         return false;
1261     }
1262
1263     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1264     if (iRet < 0 || iDims != 2)
1265     {
1266         deleteListItemReferences(_iDatasetId, piItemRef);
1267         return false;
1268     }
1269
1270     piDims = new int[2];
1271     iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1272     if (piDims[0] != 1)
1273     {
1274         deleteListItemReferences(_iDatasetId, piItemRef);
1275         delete[] piDims;
1276         return false;
1277     }
1278
1279     int* piDimsArray = new int[piDims[1]];
1280     iRet = readInteger32Matrix(iItemDataset, piDimsArray);
1281     if (iRet)
1282     {
1283         deleteListItemReferences(_iDatasetId, piItemRef);
1284         delete[] piDims;
1285         delete[] piDimsArray;
1286         return false;
1287     }
1288
1289     // get third item, the Data of hypermatrix
1290     // import data like a "type" (Double, Int, ...) instead of mlist
1291     iRet = getListItemDataset(_iDatasetId, piItemRef, 2, &iItemDataset);
1292     bool bRet = import_data(pvCtx, iItemDataset, _iItemPos, _piAddress, _pstVarname);
1293     if (bRet == false)
1294     {
1295         deleteListItemReferences(_iDatasetId, piItemRef);
1296         delete[] piDims;
1297         delete[] piDimsArray;
1298         return false;
1299     }
1300
1301     // get imported hypermatrix from List or Context
1302     types::GenericType* pGT = NULL;
1303     types::InternalType* pIT = NULL;
1304     if (_piAddress)
1305     {
1306         types::List* pL = (types::List*)_piAddress;
1307         pIT = pL->get(_iItemPos - 1);
1308     }
1309     else
1310     {
1311         wchar_t* pwcsName = to_wide_string(_pstVarname);
1312         pIT = symbol::Context::getInstance()->getCurrentLevel(symbol::Symbol(pwcsName));
1313         FREE(pwcsName);
1314     }
1315
1316     // reshape data with size of hypermatrix
1317     pGT = pIT->getAs<types::GenericType>();
1318     pGT->reshape(piDimsArray, piDims[1]);
1319
1320     delete[] piDims;
1321     delete[] piDimsArray;
1322
1323
1324     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1325     if (iRet)
1326     {
1327         return false;
1328     }
1329
1330     return true;
1331 }
1332 /*--------------------------------------------------------------------------*/
1333
1334 static bool import_struct(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1335 {
1336     int iRet = 0;
1337     int iComplex = 0;
1338     int iDims = 0;
1339     int iItems = 0;
1340     hobj_ref_t *piItemRef = NULL;
1341
1342     // an struct is stored in an mlist
1343     if (_iVarType != sci_mlist)
1344     {
1345         return false;
1346     }
1347
1348     iRet = getListDims(_iDatasetId, &iItems);
1349     if (iRet)
1350     {
1351         return false;
1352     }
1353
1354     if (iItems < 2)
1355     {
1356         // struct have 2 elements minimal
1357         return false;
1358     }
1359
1360     iRet = getListItemReferences(_iDatasetId, &piItemRef);
1361     if (iRet)
1362     {
1363         deleteListItemReferences(_iDatasetId, piItemRef);
1364         return false;
1365     }
1366
1367     // get first item
1368     int iItemDataset = 0;
1369     iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
1370     if (iRet || iItemDataset == 0)
1371     {
1372         deleteListItemReferences(_iDatasetId, piItemRef);
1373         return false;
1374     }
1375
1376     // get first item type
1377     int iItemType = getScilabTypeFromDataSet(iItemDataset);
1378     if (iItemType != sci_strings)
1379     {
1380         deleteListItemReferences(_iDatasetId, piItemRef);
1381         return false;
1382     }
1383
1384     // get size of first item
1385     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1386     if (iRet < 0 || iDims != 2)
1387     {
1388         deleteListItemReferences(_iDatasetId, piItemRef);
1389         return false;
1390     }
1391
1392     int* piDims = new int[2];
1393     int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1394     if (iSize != iItems)
1395     {
1396         deleteListItemReferences(_iDatasetId, piItemRef);
1397         delete[] piDims;
1398         return false;
1399     }
1400
1401     delete[] piDims;
1402     piDims = NULL;
1403
1404     // get data of first item for check the type of mlist
1405     char** pstData = new char*[iSize];
1406     char** pstDataSave = new char*[iSize - 2];
1407     iRet = readStringMatrix(iItemDataset, pstData);
1408     if (iRet || strcmp(pstData[0], "st") != 0)
1409     {
1410         // if not the good type, do not h5close (deleteListItemReferences)
1411         FREE(piItemRef);
1412         freeStringMatrix(iItemDataset, pstData);
1413         delete[] pstData;
1414         delete[] pstDataSave;
1415         return false;
1416     }
1417
1418     for (int i = 2; i < iSize; ++i)
1419     {
1420         pstDataSave[-2 + i] = new char[strlen(pstData[i]) + 1];
1421         strcpy(pstDataSave[-2 + i], pstData[i]);
1422     }
1423
1424     freeStringMatrix(iItemDataset, pstData);
1425     delete[] pstData;
1426     pstData = NULL;
1427
1428     // get second item, the Size of struct
1429     iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
1430     if (iRet)
1431     {
1432         deleteListItemReferences(_iDatasetId, piItemRef);
1433         for (int i = 0; i < (-2 + iItems); ++i)
1434         {
1435             delete pstDataSave[i];
1436         }
1437         delete[] pstDataSave;
1438         pstDataSave = NULL;
1439         return false;
1440     }
1441
1442     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1443     if (iRet < 0 || iDims != 2)
1444     {
1445         deleteListItemReferences(_iDatasetId, piItemRef);
1446         for (int i = 0; i < (-2 + iItems); ++i)
1447         {
1448             delete pstDataSave[i];
1449         }
1450         delete[] pstDataSave;
1451         pstDataSave = NULL;
1452         return false;
1453     }
1454
1455     piDims = new int[2];
1456     iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1457     if (piDims[0] != 1)
1458     {
1459         deleteListItemReferences(_iDatasetId, piItemRef);
1460         for (int i = 0; i < (-2 + iItems); ++i)
1461         {
1462             delete pstDataSave[i];
1463         }
1464         delete[] pstDataSave;
1465         pstDataSave = NULL;
1466         delete[] piDims;
1467         return false;
1468     }
1469
1470     int* piDimsArray = new int[piDims[1]];
1471     iRet = readInteger32Matrix(iItemDataset, piDimsArray);
1472     if (iRet)
1473     {
1474         deleteListItemReferences(_iDatasetId, piItemRef);
1475         for (int i = 0; i < (-2 + iItems); ++i)
1476         {
1477             delete pstDataSave[i];
1478         }
1479         delete[] pstDataSave;
1480         pstDataSave = NULL;
1481         delete[] piDims;
1482         delete[] piDimsArray;
1483         return false;
1484     }
1485
1486     types::Struct* pStruct = new types::Struct(piDims[1], piDimsArray);
1487     delete[] piDims;
1488     delete[] piDimsArray;
1489
1490     wchar_t* pwstName = NULL;
1491     for (int i = 0; i < (-2 + iItems); ++i)
1492     {
1493         pwstName = to_wide_string(pstDataSave[i]);
1494         pStruct->addField(pwstName);
1495         delete pstDataSave[i];
1496         FREE(pwstName);
1497     }
1498
1499     delete[] pstDataSave;
1500     pstDataSave = NULL;
1501
1502     types::SingleStruct** ppSStruct =  pStruct->get();
1503     types::String* pStr = pStruct->getFieldNames();
1504
1505     types::List* pList = new types::List();
1506     // fill the list to avoid api_scilab error about the list size.
1507     pList->set(0, types::Double::Empty());
1508
1509     if (pStruct->getSize() == 1)
1510     {
1511         types::InternalType* pIT = NULL;
1512         for (int i = 0; i < pStr->getSize(); ++i)
1513         {
1514             int iItemDataset = 0;
1515             iRet = getListItemDataset(_iDatasetId, piItemRef, i + 2, &iItemDataset);
1516             if (iRet || iItemDataset == 0)
1517             {
1518                 deleteListItemReferences(_iDatasetId, piItemRef);
1519                 delete pList;
1520                 delete pStruct;
1521                 return false;
1522             }
1523
1524             wchar_t* pwcsName = pStr->get(i);
1525             char* pcName = wide_string_to_UTF8(pwcsName);
1526
1527             bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, pcName);
1528             if (bRet == false)
1529             {
1530                 deleteListItemReferences(_iDatasetId, piItemRef);
1531                 delete pList;
1532                 delete pStruct;
1533                 return false;
1534             }
1535
1536             pIT = pList->get(0);
1537             ppSStruct[0]->set(pwcsName, pIT);
1538             FREE(pcName);
1539         }
1540     }
1541     else if (pStruct->getSize() > 1)
1542     {
1543         for (int i = 0; i < pStr->getSize(); ++i)
1544         {
1545             int iItemDataset = 0;
1546             iRet = getListItemDataset(_iDatasetId, piItemRef, i + 2, &iItemDataset);
1547             if (iRet || iItemDataset == 0)
1548             {
1549                 deleteListItemReferences(_iDatasetId, piItemRef);
1550                 delete pList;
1551                 delete pStruct;
1552                 return false;
1553             }
1554
1555             wchar_t* pwcsName = pStr->get(i);
1556             char* pcName = wide_string_to_UTF8(pwcsName);
1557
1558             bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, pcName);
1559             if (bRet == false)
1560             {
1561                 deleteListItemReferences(_iDatasetId, piItemRef);
1562                 delete pList;
1563                 delete pStruct;
1564                 return false;
1565             }
1566
1567             types::List* pListData = pList->get(0)->getAs<types::List>();
1568             for (int iWriteData = 0; iWriteData < pStruct->getSize(); ++iWriteData)
1569             {
1570                 ppSStruct[iWriteData]->set(pwcsName, pListData->get(iWriteData));
1571             }
1572
1573             FREE(pcName);
1574         }
1575
1576     }
1577
1578     delete pList;
1579     if (_piAddress == NULL)
1580     {
1581         pwstName = to_wide_string(_pstVarname);
1582         symbol::Context::getInstance()->put(symbol::Symbol(pwstName), pStruct);
1583         FREE(pwstName);
1584     }
1585     else
1586     {
1587         types::List* pParentList = (types::List*)_piAddress;
1588         pParentList->set(_iItemPos - 1, pStruct);
1589     }
1590
1591     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1592     if (iRet)
1593     {
1594         return false;
1595     }
1596
1597     return true;
1598 }
1599 /*--------------------------------------------------------------------------*/
1600
1601
1602 static bool import_cell(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
1603 {
1604     int iRet = 0;
1605     int iComplex = 0;
1606     int iDims = 0;
1607     int iItems = 0;
1608     hobj_ref_t *piItemRef = NULL;
1609
1610     // an hypermatrix is stored in an mlist
1611     if (_iVarType != sci_mlist)
1612     {
1613         return false;
1614     }
1615
1616     iRet = getListDims(_iDatasetId, &iItems);
1617     if (iRet)
1618     {
1619         return false;
1620     }
1621
1622     if (iItems != 3)
1623     {
1624         // cell have 3 elements
1625         return false;
1626     }
1627
1628     iRet = getListItemReferences(_iDatasetId, &piItemRef);
1629     if (iRet)
1630     {
1631         deleteListItemReferences(_iDatasetId, piItemRef);
1632         return false;
1633     }
1634
1635     // get first item
1636     int iItemDataset = 0;
1637     iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
1638     if (iRet || iItemDataset == 0)
1639     {
1640         deleteListItemReferences(_iDatasetId, piItemRef);
1641         return false;
1642     }
1643
1644     // get first item type
1645     int iItemType = getScilabTypeFromDataSet(iItemDataset);
1646     if (iItemType != sci_strings)
1647     {
1648         deleteListItemReferences(_iDatasetId, piItemRef);
1649         return false;
1650     }
1651
1652     // get size of first item
1653     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1654     if (iRet < 0 || iDims != 2)
1655     {
1656         deleteListItemReferences(_iDatasetId, piItemRef);
1657         return false;
1658     }
1659
1660     int* piDims = new int[2];
1661     int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1662     if (iSize != 3)
1663     {
1664         deleteListItemReferences(_iDatasetId, piItemRef);
1665         delete[] piDims;
1666         return false;
1667     }
1668
1669     delete[] piDims;
1670     piDims = NULL;
1671
1672     // get data of first item for check the type of mlist
1673     char** pstData = new char*[iSize];
1674     iRet = readStringMatrix(iItemDataset, pstData);
1675     if (iRet || strcmp(pstData[0], "ce") != 0)
1676     {
1677         // if not the good type, do not h5close (deleteListItemReferences)
1678         FREE(piItemRef);
1679         freeStringMatrix(iItemDataset, pstData);
1680         delete[] pstData;
1681         return false;
1682     }
1683
1684     freeStringMatrix(iItemDataset, pstData);
1685     delete[] pstData;
1686     pstData = NULL;
1687
1688     // get second item, the Size of cell
1689     iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
1690     if (iRet)
1691     {
1692         deleteListItemReferences(_iDatasetId, piItemRef);
1693         return false;
1694     }
1695
1696     iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
1697     if (iRet < 0 || iDims != 2)
1698     {
1699         deleteListItemReferences(_iDatasetId, piItemRef);
1700         return false;
1701     }
1702
1703     piDims = new int[2];
1704     iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
1705     if (piDims[0] != 1)
1706     {
1707         deleteListItemReferences(_iDatasetId, piItemRef);
1708         delete[] piDims;
1709         return false;
1710     }
1711
1712     int* piDimsArray = new int[piDims[1]];
1713     iRet = readInteger32Matrix(iItemDataset, piDimsArray);
1714     if (iRet)
1715     {
1716         deleteListItemReferences(_iDatasetId, piItemRef);
1717         delete[] piDims;
1718         delete[] piDimsArray;
1719         return false;
1720     }
1721
1722     types::Cell* pCell = new types::Cell(piDims[1], piDimsArray);
1723     delete[] piDims;
1724     delete[] piDimsArray;
1725     types::List* pList = new types::List();
1726     pList->set(0, types::Double::Empty());
1727
1728     iRet = getListItemDataset(_iDatasetId, piItemRef, 2, &iItemDataset);
1729     if (iRet || iItemDataset == 0)
1730     {
1731         deleteListItemReferences(_iDatasetId, piItemRef);
1732         delete pList;
1733         delete pCell;
1734         return false;
1735     }
1736
1737     bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, NULL);
1738     if (bRet == false)
1739     {
1740         deleteListItemReferences(_iDatasetId, piItemRef);
1741         delete pList;
1742         delete pCell;
1743         return false;
1744     }
1745
1746     types::List* pListData = pList->get(0)->getAs<types::List>();
1747     for (int iWriteData = 0; iWriteData < pCell->getSize(); ++iWriteData)
1748     {
1749         pCell->set(iWriteData, pListData->get(iWriteData));
1750     }
1751
1752     delete pList;
1753
1754     if (_piAddress == NULL)
1755     {
1756         wchar_t* pwstName = to_wide_string(_pstVarname);
1757         symbol::Context::getInstance()->put(symbol::Symbol(pwstName), pCell);
1758         FREE(pwstName);
1759     }
1760     else
1761     {
1762         types::List* pParentList = (types::List*)_piAddress;
1763         pParentList->set(_iItemPos - 1, pCell);
1764     }
1765
1766     iRet = deleteListItemReferences(_iDatasetId, piItemRef);
1767
1768     if (iRet)
1769     {
1770         return false;
1771     }
1772
1773     return true;
1774 }
1775 /*--------------------------------------------------------------------------*/
1776