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