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