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