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