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