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