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