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