Merge remote-tracking branch 'origin/master' into YaSp
[scilab.git] / scilab / modules / hdf5 / sci_gateway / cpp / sci_export_to_hdf5.cpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2009 - DIGITEO - Antoine ELIAS
4 *
5 * This file must be used under the terms of the CeCILL.
6 * This source file is licensed as described in the file COPYING, which
7 * you should have received as part of this distribution.  The terms
8 * are also available at
9 * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
10 *
11 */
12
13 #include <hdf5.h>
14 extern "C"
15 {
16 #include <string.h>
17 #include <stdio.h>
18 #include "gw_hdf5.h"
19 #include "MALLOC.h"
20 #include "Scierror.h"
21 #include "localization.h"
22 #include "sciprint.h"
23 #include "api_scilab.h"
24 #include "deleteafile.h"
25 #include "expandPathVariable.h"
26 #include "h5_fileManagement.h"
27 #include "h5_writeDataToFile.h"
28 #include "h5_readDataFromFile.h"
29 #include "h5_attributeConstants.h"
30 #include "freeArrayOfString.h"
31 #include "os_strdup.h"
32 #include "sci_mode.h"
33 #include "splitpath.h"
34 #include "scicurdir.h"
35 }
36
37 //#define PRINT_DEBUG
38 int iLevel = 0;
39 static bool isVarExist(int* pvCtx, int _iFile, char* _pstVarName);
40
41 static bool export_data(int* pvCtx, int _iH5File, int *_piVar, char* _pstName);
42 static bool export_list(int* pvCtx, int _iH5File, int *_piVar, char* _pstName, int _iVarType);
43 static bool export_double(int* pvCtx, int _iH5File, int *_piVar, char* _pstName);
44 static bool export_poly(int* pvCtx, int _iH5File, int *_piVar, char* _pstName);
45 static bool export_boolean(int* pvCtx, int _iH5File, int *_piVar, char* _pstName);
46 static bool export_sparse(int* pvCtx, int _iH5File, int *_piVar, char* _pstName);
47 static bool export_boolean_sparse(int* pvCtx, int _iH5File, int *_piVar, char* _pstName);
48 static bool export_matlab_sparse(int* pvCtx, int *_piVar, char* _pstName);
49 static bool export_ints(int* pvCtx, int _iH5File, int *_piVar, char* _pstName);
50 static bool export_handles(int* pvCtx, int *_piVar, char* _pstName);
51 static bool export_strings(int* pvCtx, int _iH5File, int *_piVar, char* _pstName);
52 static bool export_u_function(int* pvCtx, int *_piVar, char* _pstName);
53 static bool export_c_function(int* pvCtx, int *_piVar, char* _pstName);
54 static bool export_lib(int* pvCtx, int *_piVar, char* _pstName);
55 static bool export_lufact_pointer(int* pvCtx, int *_piVar, char* _pstName);
56 static bool export_void(int* pvCtx, int _iH5File, int *_piVar, char* _pstName);
57
58 void print_type(char* _pstType);
59 int extractVarNameList(int* pvCtx, int _iStart, int _iEnd, char** _pstNameList);
60
61
62 /*--------------------------------------------------------------------------*/
63 int sci_export_to_hdf5(char *fname, int* pvApiCtx)
64 {
65     int iNbVar          = 0;
66     int** piAddrList    = NULL;
67     char** pstNameList  = NULL;
68     char *pstFileName   = NULL;
69     bool bExport        = true;
70     bool bAppendMode    = false;
71     int iRhs            = nbInputArgument(pvApiCtx);
72
73     SciErr sciErr;
74
75     CheckInputArgumentAtLeast(pvApiCtx, 1);
76     CheckOutputArgument(pvApiCtx, 0, 1);
77
78     pstNameList = (char**)MALLOC(sizeof(char*) * nbInputArgument(pvApiCtx));
79     iNbVar = extractVarNameList(pvApiCtx, 1, nbInputArgument(pvApiCtx), pstNameList);
80     if (iNbVar == 0)
81     {
82         FREE(pstNameList);
83         return 1;
84     }
85
86     piAddrList = (int**)MALLOC(sizeof(int*) * (iNbVar));
87     for (int i = 1 ; i < nbInputArgument(pvApiCtx) ; i++)
88     {
89         if (strcmp(pstNameList[i], "-append") == 0)
90         {
91             bAppendMode = true;
92         }
93         else
94         {
95             sciErr = getVarAddressFromName(pvApiCtx, pstNameList[i], &piAddrList[i]);
96             if (sciErr.iErr)
97             {
98                 freeArrayOfString(pstNameList, iRhs);
99                 FREE(piAddrList);
100                 Scierror(999, _("%s: Wrong value for input argument #%d: Defined variable expected.\n"), fname, i + 1);
101                 printError(&sciErr, 0);
102                 return 1;
103             }
104         }
105     }
106
107     //check append option
108
109     iLevel = 0;
110     // open hdf5 file
111     pstFileName = expandPathVariable(pstNameList[0]);
112     int iH5File = 0;
113     if (bAppendMode)
114     {
115         iH5File = openHDF5File(pstFileName, bAppendMode);
116         if (iH5File < 0)
117         {
118             iH5File = createHDF5File(pstFileName);
119         }
120     }
121     else
122     {
123         iH5File = createHDF5File(pstFileName);
124     }
125
126
127     if (iH5File < 0)
128     {
129         if (iH5File == -2)
130         {
131             Scierror(999, _("%s: Wrong value for input argument #%d: \"%s\" is a directory"), fname, 1, pstNameList[0]);
132         }
133         else
134         {
135             Scierror(999, _("%s: Cannot open file %s.\n"), fname, pstNameList[0]);
136         }
137
138         FREE(piAddrList);
139         freeArrayOfString(pstNameList, iRhs);
140         FREE(pstFileName);
141         return 1;
142     }
143
144     if (bAppendMode)
145     {
146         int iVersion = getSODFormatAttribute(iH5File);
147         if (iVersion != -1 && iVersion != SOD_FILE_VERSION)
148         {
149             //to update version must be the same
150             closeHDF5File(iH5File);
151             Scierror(999, _("%s: Wrong SOD file format version. Expected: %d Found: %d\n"), fname, SOD_FILE_VERSION, iVersion);
152             FREE(piAddrList);
153             freeArrayOfString(pstNameList, iRhs);
154             FREE(pstFileName);
155             return 1;
156         }
157     }
158
159     // export data
160     for (int i = 1 ; i < nbInputArgument(pvApiCtx) ; i++)
161     {
162         if (strcmp(pstNameList[i], "-append") == 0)
163         {
164             continue;
165         }
166
167         if (isVarExist(pvApiCtx, iH5File, pstNameList[i]))
168         {
169             if (bAppendMode)
170             {
171                 if (deleteHDF5Var(iH5File, pstNameList[i]))
172                 {
173                     closeHDF5File(iH5File);
174                     Scierror(999, _("%s: Unable to delete existing variable \"%s\"."), fname, pstNameList[i]);
175                     FREE(piAddrList);
176                     freeArrayOfString(pstNameList, iRhs);
177                     FREE(pstFileName);
178                     return 1;
179                 }
180             }
181             else
182             {
183                 closeHDF5File(iH5File);
184                 Scierror(999, _("%s: Variable \'%s\' already exists in file \'%s\'\nUse -append option to replace existing variable\n."), fname, pstNameList[i], pstNameList[0]);
185                 FREE(piAddrList);
186                 freeArrayOfString(pstNameList, iRhs);
187                 FREE(pstFileName);
188                 return 1;
189             }
190         }
191
192         bExport = export_data(pvApiCtx, iH5File, piAddrList[i], pstNameList[i]);
193         if (bExport == false)
194         {
195             break;
196         }
197     }
198
199     if (bExport && nbInputArgument(pvApiCtx) != 1)
200     {
201         //add or update scilab version and file version in hdf5 file
202         if (updateScilabVersion(iH5File) < 0)
203         {
204             closeHDF5File(iH5File);
205             Scierror(999, _("%s: Unable to update Scilab version in \"%s\"."), fname, pstNameList[0]);
206             FREE(piAddrList);
207             freeArrayOfString(pstNameList, iRhs);
208             FREE(pstFileName);
209             return 1;
210         }
211
212         if (updateFileVersion(iH5File) < 0)
213         {
214             closeHDF5File(iH5File);
215             Scierror(999, _("%s: Unable to update HDF5 format version in \"%s\"."), fname, pstNameList[0]);
216             FREE(piAddrList);
217             freeArrayOfString(pstNameList, iRhs);
218             FREE(pstFileName);
219             return 1;
220         }
221     }
222
223     //close hdf5 file
224     closeHDF5File(iH5File);
225     if (bExport == false && nbInputArgument(pvApiCtx) != 1)
226     {
227         //remove file
228         deleteafile(pstFileName);
229     }
230
231     FREE(pstFileName);
232     freeArrayOfString(pstNameList, iRhs);
233     FREE(piAddrList);
234
235     //create boolean return value
236     int *piReturn = NULL;
237     sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 1, &piReturn);
238     if (sciErr.iErr)
239     {
240         printError(&sciErr, 0);
241         return 1;
242     }
243
244     if (bExport == true || nbInputArgument(pvApiCtx) == 1)
245     {
246         piReturn[0] = 1;
247     }
248     else
249     {
250         piReturn[0] = 0;
251     }
252
253     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
254     ReturnArguments(pvApiCtx);
255     return 0;
256 }
257
258 static bool export_data(int* pvCtx, int _iH5File, int* _piVar, char* _pstName)
259 {
260     bool bReturn = false;
261     int iType = 0;
262
263     SciErr sciErr = getVarType(pvCtx, _piVar, &iType);
264     if (sciErr.iErr)
265     {
266         printError(&sciErr, 0);
267         return false;
268     }
269
270     switch (iType)
271     {
272         case sci_matrix :
273         {
274             bReturn = export_double(pvCtx, _iH5File, _piVar, _pstName);
275             break;
276         }
277         case sci_poly :
278         {
279             bReturn = export_poly(pvCtx, _iH5File, _piVar, _pstName);
280             break;
281         }
282         case sci_boolean :
283         {
284             bReturn = export_boolean(pvCtx, _iH5File, _piVar, _pstName);
285             break;
286         }
287         case sci_sparse :
288         {
289             bReturn = export_sparse(pvCtx, _iH5File, _piVar, _pstName);
290             break;
291         }
292         case sci_boolean_sparse :
293         {
294             bReturn = export_boolean_sparse(pvCtx, _iH5File, _piVar, _pstName);
295             break;
296         }
297         case sci_matlab_sparse :
298         {
299             bReturn = export_matlab_sparse(pvCtx, _piVar, _pstName);
300             break;
301         }
302         case sci_ints :
303         {
304             bReturn = export_ints(pvCtx, _iH5File, _piVar, _pstName);
305             break;
306         }
307         case sci_handles :
308         {
309             bReturn = export_handles(pvCtx, _piVar, _pstName);
310             break;
311         }
312         case sci_strings :
313         {
314             bReturn = export_strings(pvCtx, _iH5File, _piVar, _pstName);
315             break;
316         }
317         case sci_u_function :
318         {
319             bReturn = export_u_function(pvCtx, _piVar, _pstName);
320             break;
321         }
322         case sci_c_function :
323         {
324             bReturn = export_c_function(pvCtx, _piVar, _pstName);
325             break;
326         }
327         case sci_lib :
328         {
329             bReturn = export_lib(pvCtx, _piVar, _pstName);
330             break;
331         }
332         case sci_list :
333         case sci_tlist :
334         case sci_mlist :
335         {
336             bReturn = export_list(pvCtx, _iH5File, _piVar, _pstName, iType);
337             break;
338         }
339         case sci_lufact_pointer :
340         {
341             bReturn = export_lufact_pointer(pvCtx, _piVar, _pstName);
342             break;
343         }
344         case 0 : //void case to "null" items in list
345         {
346             bReturn = export_void(pvCtx, _iH5File, _piVar, _pstName);
347             break;
348         }
349         default :
350         {
351             bReturn = false;
352             break;
353         }
354     }
355     return bReturn;
356 }
357
358 static bool export_void(int* pvCtx, int _iH5File, int *_piVar, char* _pstName)
359 {
360     int iRet = writeVoid(_iH5File, _pstName);
361     if (iRet)
362     {
363         return false;
364     }
365
366     //char pstMsg[] = "void";
367     //print_type(pstMsg);
368     return true;
369 }
370
371 static bool export_undefined(int* pvCtx, int _iH5File, int *_piVar, char* _pstName)
372 {
373     int iRet = writeUndefined(_iH5File, _pstName);
374     if (iRet)
375     {
376         return false;
377     }
378
379     //char pstMsg[] = "void";
380     //print_type(pstMsg);
381     return true;
382 }
383
384 static bool export_list(int* pvCtx, int _iH5File, int *_piVar, char* _pstName, int _iVarType)
385 {
386     int iRet        = 0;
387     bool bReturn    = false;
388     int iItemNumber = 0;
389     SciErr sciErr   = getListItemNumber(pvCtx, _piVar, &iItemNumber);
390     if (sciErr.iErr)
391     {
392         printError(&sciErr, 0);
393         return false;
394     }
395
396
397     //create groupe name
398     char* pstGroupName  = createGroupName(_pstName);
399
400     //char pstMsg[256];
401     //sprintf(pstMsg, "list (%d)", iItemNumber);
402     //print_type(pstMsg);
403
404     iLevel++;
405     //open list
406     void *pvList = openList(_iH5File, pstGroupName, iItemNumber);
407     for (int i = 0 ; i < iItemNumber ; i++)
408     {
409         int *piNewVar = NULL;
410         getListItemAddress(pvCtx, _piVar, i + 1, &piNewVar);//1 indexed
411         char* pstPathName   = createPathName(pstGroupName, i);
412
413         if (piNewVar == NULL)
414         {
415             //undefined item
416             bReturn = export_undefined(pvCtx, _iH5File, piNewVar, pstPathName);
417         }
418         else
419         {
420             bReturn = export_data(pvCtx, _iH5File, piNewVar, pstPathName);
421         }
422
423         iRet = addItemInList(_iH5File, pvList, i, pstPathName);
424         FREE(pstPathName);
425         if (bReturn == false || iRet)
426         {
427             return false;
428         }
429     }
430     iLevel--;
431     closeList(_iH5File, pvList, _pstName, iItemNumber, _iVarType);
432     FREE(pstGroupName);
433     //close list
434     return true;
435 }
436
437 static bool export_double(int* pvCtx, int _iH5File, int *_piVar, char* _pstName)
438 {
439     int iRet            = 0;
440     int iComplex        = isVarComplex(pvCtx, _piVar);
441     int piDims[2];
442     int iType = 0;
443     double *pdblReal    = NULL;
444     double *pdblImg             = NULL;
445
446     SciErr sciErr = getVarType(pvCtx, _piVar, &iType);
447     if (sciErr.iErr)
448     {
449         printError(&sciErr, 0);
450         return false;
451     }
452
453     if (iType != sci_matrix)
454     {
455         return false;
456     }
457
458     if (iComplex)
459     {
460         sciErr = getComplexMatrixOfDouble(pvCtx, _piVar, &piDims[0], &piDims[1], &pdblReal, &pdblImg);
461         if (sciErr.iErr)
462         {
463             printError(&sciErr, 0);
464             return false;
465         }
466
467         iRet = writeDoubleComplexMatrix(_iH5File, _pstName, 2, piDims, pdblReal, pdblImg);
468     }
469     else
470     {
471         sciErr = getMatrixOfDouble(pvCtx, _piVar, &piDims[0], &piDims[1], &pdblReal);
472         if (sciErr.iErr)
473         {
474             printError(&sciErr, 0);
475             return false;
476         }
477
478         iRet = writeDoubleMatrix(_iH5File, _pstName, 2, piDims, pdblReal);
479     }
480
481     if (iRet)
482     {
483         return false;
484     }
485
486     //char pstMsg[512];
487     //sprintf(pstMsg, "double (%d x %d)", piDims[0], piDims[1]);
488     //print_type(pstMsg);
489     return true;
490 }
491
492 static bool export_poly(int* pvCtx, int _iH5File, int *_piVar, char* _pstName)
493 {
494     int iRet = 0;
495     int* piNbCoef = NULL;
496     double** pdblReal = NULL;
497     double** pdblImg = NULL;
498     char pstVarName[64] = {0};
499     int iVarNameLen = 0;
500     int piDims[2];
501
502     SciErr sciErr = getPolyVariableName(pvCtx, _piVar, pstVarName, &iVarNameLen);
503     if (sciErr.iErr)
504     {
505         printError(&sciErr, 0);
506         return false;
507     }
508
509     if (isVarComplex(pvCtx, _piVar))
510     {
511         if (getAllocatedMatrixOfComplexPoly(pvCtx, _piVar, &piDims[0], &piDims[1], &piNbCoef, &pdblReal, &pdblImg))
512         {
513             freeAllocatedMatrixOfComplexPoly(piDims[0], piDims[1], piNbCoef, pdblReal, pdblImg);
514             return false;
515         }
516
517         iRet = writePolyComplexMatrix(_iH5File, _pstName, pstVarName, 2, piDims, piNbCoef, pdblReal, pdblImg);
518         freeAllocatedMatrixOfComplexPoly(piDims[0], piDims[1], piNbCoef, pdblReal, pdblImg);
519     }
520     else
521     {
522         if (getAllocatedMatrixOfPoly(pvCtx, _piVar, &piDims[0], &piDims[1], &piNbCoef, &pdblReal))
523         {
524             freeAllocatedMatrixOfPoly(piDims[0], piDims[1], piNbCoef, pdblReal);
525             return false;
526         }
527
528         iRet = writePolyMatrix(_iH5File, _pstName, pstVarName, 2, piDims, piNbCoef, pdblReal);
529         freeAllocatedMatrixOfPoly(piDims[0], piDims[1], piNbCoef, pdblReal);
530     }
531
532     if (iRet)
533     {
534         return false;
535     }
536
537     //char pstMsg[512];
538     //sprintf(pstMsg, "poly (%d x %d)", piDims[0], piDims[1]);
539     //print_type(pstMsg);
540     return true;
541 }
542
543 static bool export_boolean(int* pvCtx, int _iH5File, int *_piVar, char* _pstName)
544 {
545     int *piData = NULL;
546     int piDims[2];
547
548     //for error management
549     SciErr sciErr = getMatrixOfBoolean(pvCtx, _piVar, &piDims[0], &piDims[1], &piData);
550     if (sciErr.iErr)
551     {
552         printError(&sciErr, 0);
553         return 0;
554     }
555
556     int iRet = writeBooleanMatrix(_iH5File, _pstName, 2, piDims, piData);
557     if (iRet)
558     {
559         //Msg ??
560         return false;
561     }
562
563     //char pstMsg[512];
564     //sprintf(pstMsg, "bool (%d x %d)", piDims[0], piDims[1]);
565     //print_type(pstMsg);
566     return true;
567 }
568
569 static bool export_boolean_sparse(int* pvCtx, int _iH5File, int *_piVar, char* _pstName)
570 {
571     int iRet = 0;
572     int iNbItem = 0;
573     int* piNbItemRow = NULL;
574     int* piColPos = NULL;
575     int piDims[2];
576
577     SciErr sciErr = getBooleanSparseMatrix(pvCtx, _piVar, &piDims[0], &piDims[1], &iNbItem, &piNbItemRow, &piColPos);
578     if (sciErr.iErr)
579     {
580         printError(&sciErr, 0);
581         return false;
582     }
583
584     iRet = writeBooleanSparseMatrix(_iH5File, _pstName, piDims[0], piDims[1], iNbItem, piNbItemRow, piColPos);
585     if (iRet)
586     {
587         //Msg ??
588         return false;
589     }
590
591     //char pstMsg[512];
592     //sprintf(pstMsg, "boolean sparse (%d x %d)", piDims[0], piDims[1]);
593     //print_type(pstMsg);
594     return true;
595 }
596
597 static bool export_sparse(int* pvCtx, int _iH5File, int *_piVar, char* _pstName)
598 {
599     int iRet = 0;
600     int iNbItem = 0;
601     int* piNbItemRow = NULL;
602     int* piColPos = NULL;
603     double* pdblReal = NULL;
604     double* pdblImg = NULL;
605     int piDims[2];
606     SciErr sciErr;
607
608     if (isVarComplex(pvCtx, _piVar))
609     {
610         sciErr = getComplexSparseMatrix(pvCtx, _piVar, &piDims[0], &piDims[1], &iNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
611         if (sciErr.iErr)
612         {
613             printError(&sciErr, 0);
614             return false;
615         }
616
617         iRet = writeSparseComplexMatrix(_iH5File, _pstName, piDims[0], piDims[1], iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
618     }
619     else
620     {
621         sciErr = getSparseMatrix(pvCtx, _piVar, &piDims[0], &piDims[1], &iNbItem, &piNbItemRow, &piColPos, &pdblReal);
622         if (sciErr.iErr)
623         {
624             printError(&sciErr, 0);
625             return false;
626         }
627
628         iRet = writeSparseMatrix(_iH5File, _pstName, piDims[0], piDims[1], iNbItem, piNbItemRow, piColPos, pdblReal);
629     }
630
631     if (iRet)
632     {
633         return false;
634     }
635
636     //char pstMsg[512];
637     //sprintf(pstMsg, "sparse (%d x %d)", piDims[0], piDims[1]);
638     //print_type(pstMsg);
639     return true;
640 }
641
642 static bool export_matlab_sparse(int* pvCtx, int *_piVar, char* _pstName)
643 {
644     //print_type(_pstName);
645     return false;
646 }
647
648 static bool export_ints(int* pvCtx, int _iH5File, int *_piVar, char* _pstName)
649 {
650     int iRet = 0;
651     void *piData = NULL;
652     int iPrec = 0;
653     int piDims[2];
654
655     SciErr sciErr = getMatrixOfIntegerPrecision(pvCtx, _piVar, &iPrec);
656     if (sciErr.iErr)
657     {
658         printError(&sciErr, 0);
659         return false;
660     }
661
662     switch (iPrec)
663     {
664         case SCI_INT8 :
665             sciErr = getMatrixOfInteger8(pvCtx, _piVar, &piDims[0], &piDims[1], (char**)&piData);
666             if (sciErr.iErr)
667             {
668                 printError(&sciErr, 0);
669                 return false;
670             }
671             iRet = writeInteger8Matrix(_iH5File, _pstName, 2, piDims, (char*)piData);
672             break;
673         case SCI_UINT8 :
674             sciErr = getMatrixOfUnsignedInteger8(pvCtx, _piVar, &piDims[0], &piDims[1], (unsigned char**)&piData);
675             if (sciErr.iErr)
676             {
677                 printError(&sciErr, 0);
678                 return false;
679             }
680             iRet = writeUnsignedInteger8Matrix(_iH5File, _pstName, 2, piDims, (unsigned char*)piData);
681             break;
682         case SCI_INT16 :
683             sciErr = getMatrixOfInteger16(pvCtx, _piVar, &piDims[0], &piDims[1], (short**)&piData);
684             if (sciErr.iErr)
685             {
686                 printError(&sciErr, 0);
687                 return false;
688             }
689             iRet = writeInteger16Matrix(_iH5File, _pstName, 2, piDims, (short*)piData);
690             break;
691         case SCI_UINT16 :
692             sciErr = getMatrixOfUnsignedInteger16(pvCtx, _piVar, &piDims[0], &piDims[1], (unsigned short**)&piData);
693             if (sciErr.iErr)
694             {
695                 printError(&sciErr, 0);
696                 return false;
697             }
698             iRet = writeUnsignedInteger16Matrix(_iH5File, _pstName, 2, piDims, (unsigned short*)piData);
699             break;
700         case SCI_INT32 :
701             sciErr = getMatrixOfInteger32(pvCtx, _piVar, &piDims[0], &piDims[1], (int**)&piData);
702             if (sciErr.iErr)
703             {
704                 printError(&sciErr, 0);
705                 return false;
706             }
707             iRet = writeInteger32Matrix(_iH5File, _pstName, 2, piDims, (int*)piData);
708             break;
709         case SCI_UINT32 :
710             sciErr = getMatrixOfUnsignedInteger32(pvCtx, _piVar, &piDims[0], &piDims[1], (unsigned int**)&piData);
711             if (sciErr.iErr)
712             {
713                 printError(&sciErr, 0);
714                 return false;
715             }
716             iRet = writeUnsignedInteger32Matrix(_iH5File, _pstName, 2, piDims, (unsigned int*)piData);
717             break;
718         case SCI_INT64 :
719             //sciErr = getMatrixOfInteger64(_piVar, &piDims[0], &piDims[1], (long long**)&piData);
720             //if(sciErr.iErr)
721             //{
722             //  printError(&sciErr, 0);
723             //  return false;
724             //}
725             //iRet = writeInteger64Matrix(_iH5File, _pstName, 2, piDims, (long long*)piData);
726             //break;
727         case SCI_UINT64 :
728             //sciErr = getMatrixOfUnsignedInteger64(_piVar, &piDims[0], &piDims[1], (unsigned long long**)&piData);
729             //if(sciErr.iErr)
730             //{
731             //  printError(&sciErr, 0);
732             //  return false;
733             //}
734             //iRet = writeUnsignedInteger64Matrix(_iH5File, _pstName, 2, piDims, (unsigned long long*)piData);
735             //break;
736         default :
737             return 1;
738             break;
739     }
740
741     if (iRet)
742     {
743         return false;
744     }
745
746     //char pstMsg[512];
747     //sprintf(pstMsg, "int%d (%d x %d)", 8 * iPrec, piDims[0], piDims[1]);
748     //print_type(pstMsg);
749     return true;
750 }
751
752 static bool export_handles(int* pvCtx, int *_piVar, char* _pstName)
753 {
754     //print_type(_pstName);
755     return false;
756 }
757
758 static bool export_strings(int* pvCtx, int _iH5File, int *_piVar, char* _pstName)
759 {
760     int iRet = 0;
761     char** pstData = NULL;
762     int piDims[2];
763
764     SciErr sciErr = getMatrixOfString(pvCtx, _piVar, &piDims[0], &piDims[1], NULL, NULL);
765     if (sciErr.iErr)
766     {
767         printError(&sciErr, 0);
768         return false;
769     }
770
771     if (getAllocatedMatrixOfString(pvCtx, _piVar, &piDims[0], &piDims[1], &pstData))
772     {
773         if (pstData)
774         {
775             freeAllocatedMatrixOfString(piDims[0], piDims[1], pstData);
776         }
777
778         return false;
779     }
780
781     iRet = writeStringMatrix(_iH5File, _pstName, 2, piDims, pstData);
782     freeAllocatedMatrixOfString(piDims[0], piDims[1], pstData);
783     if (iRet)
784     {
785         return false;
786     }
787
788     //char pstMsg[512];
789     //sprintf(pstMsg, "string (%d x %d)", piDims[0], piDims[1]);
790     //print_type(pstMsg);
791
792     return true;
793 }
794
795 static bool export_u_function(int* pvCtx, int *_piVar, char* _pstName)
796 {
797     //print_type(_pstName);
798     return false;
799 }
800
801 static bool export_c_function(int* pvCtx, int *_piVar, char* _pstName)
802 {
803     //print_type(_pstName);
804     return false;
805 }
806
807 static bool export_lib(int* pvCtx, int *_piVar, char* _pstName)
808 {
809     //print_type(_pstName);
810     return false;
811 }
812
813 static bool export_lufact_pointer(int* pvCtx, int *_piVar, char* _pstName)
814 {
815     /*print_type*/(_pstName);
816     return false;
817 }
818
819 void print_type(char* _pstType)
820 {
821 #ifdef PRINT_DEBUG
822     for (int i = 0 ; i < iLevel ; i++)
823     {
824         sciprint("\t");
825     }
826     sciprint("%s\n", _pstType);
827 #endif
828 }
829
830 int extractVarNameList(int* pvCtx, int _iStart, int _iEnd, char** _pstNameList)
831 {
832     int iCount = 0;
833
834     for (int i = _iStart ; i <= _iEnd ; i++)
835     {
836         int* piAddr = NULL;
837         int iType   = 0;
838
839         SciErr sciErr = getVarAddressFromPosition(pvCtx, i, &piAddr);
840         if (sciErr.iErr)
841         {
842             printError(&sciErr, 0);
843             return 0;
844         }
845
846         if (getAllocatedSingleString(pvCtx, piAddr, &_pstNameList[iCount]))
847         {
848             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), "export_to_hdf5", i);
849             return 0;
850         }
851
852         iCount++;
853     }
854     return iCount;
855 }
856
857 /*--------------------------------------------------------------------------*/
858 static bool isVarExist(int* pvCtx, int _iFile, char* _pstVarName)
859 {
860     //check if variable already exists
861     int iNbItem = getVariableNames(_iFile, NULL);
862     if (iNbItem)
863     {
864         char **pstVarNameList = (char **)MALLOC(sizeof(char *) * iNbItem);
865
866         iNbItem = getVariableNames(_iFile, pstVarNameList);
867
868         //import all data
869         for (int i = 0 ; i < iNbItem ; i++)
870         {
871             if (strcmp(pstVarNameList[i], _pstVarName) == 0)
872             {
873                 freeArrayOfString(pstVarNameList, iNbItem);
874                 return true;
875             }
876         }
877
878         freeArrayOfString(pstVarNameList, iNbItem);
879     }
880
881     return false;
882 }
883 /*--------------------------------------------------------------------------*/