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