Merge remote-tracking branch 'origin/master' into 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 * Copyright (C) 2011 - DIGITEO - Cedric DELAMARRE
5 *
6 * This file must be used under the terms of the CeCILL.
7 * This source file is licensed as described in the file COPYING, which
8 * you should have received as part of this distribution.  The terms
9 * are also available at
10 * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11 *
12 */
13
14 #include <stdio.h>
15
16 #include "string.hxx"
17 #include "int.hxx"
18 #include "bool.hxx"
19 #include "polynom.hxx"
20 #include "tlist.hxx"
21 #include "mlist.hxx"
22 #include "function.hxx"
23 #include "context.hxx"
24 #include "hdf5_gw.hxx"
25
26 extern "C"
27 {
28 #include "MALLOC.h"
29 #include "localization.h"
30 #include "charEncoding.h"
31 #include "Scierror.h"
32 #include "h5_fileManagement.h"
33 #include "deleteafile.h"
34 #include "h5_writeDataToFile.h"
35 #include "h5_readDataFromFile.h"
36 #include "h5_attributeConstants.h"
37 #include "sci_types.h"
38 #include "expandPathVariable.h"
39
40 }
41
42 #include "forceJHDF5load.hxx"
43
44 using namespace types;
45
46 //#define PRINT_DEBUG
47 int iLevel = 0;
48
49 static bool export_data(int _iH5File, InternalType* pIT, wchar_t* _pwstName);
50 static bool export_list(int _iH5File, InternalType* pIT, wchar_t* _pwstName);
51 static bool export_double(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
52 static bool export_poly(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
53 static bool export_boolean(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
54 static bool export_sparse(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
55 //static bool export_boolean_sparse(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
56 //static bool export_matlab_sparse(void* pvApiCtx, int *_piVar, char* _pstName);
57 static bool export_ints(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
58 //static bool export_handles(void* pvApiCtx, int *_piVar, char* _pstName);
59 static bool export_strings(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
60 //static bool export_u_function(void* pvApiCtx, int *_piVar, char* _pstName);
61 //static bool export_c_function(void* pvApiCtx, int *_piVar, char* _pstName);
62 //static bool export_lib(void* pvApiCtx, int *_piVar, char* _pstName);
63 //static bool export_lufact_pointer(void* pvApiCtx, int *_piVar, char* _pstName);
64
65 static bool export_void(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
66
67
68 void print_type(char* _pstType);
69 int extractVarNameList(typed_list &in, wchar_t** _pstNameList);
70
71 /*--------------------------------------------------------------------------*/
72 Function::ReturnValue sci_export_to_hdf5(typed_list &in, int _iRetCount, typed_list &out)
73 {
74     int iNbVar              = 0;
75     InternalType** pITList  = NULL;
76     wchar_t** pwstNameList      = NULL;
77     wchar_t* pwstFileName   = NULL;
78     char* pstFileName       = NULL;
79     bool bExport            = false;
80     bool bAppendMode        = false;
81
82 #ifndef _MSC_VER
83     forceJHDF5load();
84 #endif
85
86     if(in.size() < 2)
87     {
88         ScierrorW(77, _W("%ls: Wrong number of input argument(s): At least %d expected.\n"), L"export_to_hdf5", 2);
89         return Function::Error;
90     }
91
92     pwstNameList = (wchar_t**)MALLOC(sizeof(wchar_t*) * in.size());
93     iNbVar = extractVarNameList(in, pwstNameList);
94     if (iNbVar == 0)
95     {
96         FREE(pwstNameList);
97         return Function::Error;
98     }
99
100     pITList = (InternalType**)MALLOC(sizeof(InternalType*) * (iNbVar));
101     for (int i = 1 ; i < in.size() ; i++)
102     {
103         if (wcscmp(pwstNameList[i], L"-append") == 0)
104         {
105             bAppendMode = true;
106         }
107         else
108         {
109             pITList[i] = symbol::Context::getInstance()->get(symbol::Symbol(pwstNameList[i]));
110             if (pITList[i] == NULL)
111             {
112                 ScierrorW(999, _W("%ls: Wrong value for input argument #%d: Defined variable expected.\n"), L"export_to_hdf5", i + 1);
113                 return Function::Error;
114             }
115         }
116     }
117
118     //check append option
119
120     iLevel = 0;
121     // open hdf5 file
122     pwstFileName = expandPathVariableW(pwstNameList[0]);
123     pstFileName = wide_string_to_UTF8(pwstFileName);
124
125     int iH5File = 0;
126     if (bAppendMode)
127     {
128         iH5File = openHDF5File(pstFileName);
129         if (iH5File < 0)
130         {
131             iH5File = createHDF5File(pstFileName);
132         }
133     }
134     else
135     {
136         iH5File = createHDF5File(pstFileName);
137     }
138
139
140     if (iH5File < 0)
141     {
142         FREE(pstFileName);
143         if (iH5File == -2)
144         {
145             ScierrorW(999, _W("%ls: Wrong value for input argument #%d: \"%ls\" is a directory"), L"export_to_hdf5", 1, pwstNameList[0]);
146         }
147         else
148         {
149             ScierrorW(999, _W("%ls: Cannot open file %ls.\n"), L"export_to_hdf5", pwstNameList[0]);
150         }
151
152         return Function::Error;
153     }
154
155     if (bAppendMode)
156     {
157         int iVersion = getSODFormatAttribute(iH5File);
158         if (iVersion != -1 && iVersion != SOD_FILE_VERSION)
159         {//to update version must be the same
160             ScierrorW(999, _W("%ls: Wrong SOD file format version. Expected: %d Found: %d\n"), L"export_to_hfd5", SOD_FILE_VERSION, iVersion);
161             return Function::Error;
162         }
163
164         //check if variable already exists
165         int iNbItem = getVariableNames(iH5File, NULL);
166         if (iNbItem)
167         {
168             char **pstVarNameList = (char **)MALLOC(sizeof(char *) * iNbItem);
169             iNbItem = getVariableNames(iH5File, pstVarNameList);
170
171             //import all data
172             for (int i = 0 ; i < iNbItem ; i++)
173             {
174                 wchar_t *pwstVarNameList = to_wide_string(pstVarNameList[i]);
175                 for (int j = 1 ; j < in.size() ; j++)
176                 {
177                     if (wcscmp(pwstNameList[i], L"-append") == 0)
178                     {
179                         continue;
180                     }
181
182                     if (wcscmp(pwstVarNameList, pwstNameList[j]) == 0)
183                     {
184                         ScierrorW(999, _W("%ls: Variable \'%ls\' already exists in file \'%ls\'."), L"export_to_hfd5", pwstVarNameList, pwstNameList[0]);
185                         FREE(pwstVarNameList);
186                         FREE(pstVarNameList[i]);
187                         return Function::Error;
188                     }
189                 }
190
191                 FREE(pwstVarNameList);
192                 FREE(pstVarNameList[i]);
193             }
194
195             FREE(pstVarNameList);
196             FREE(pstFileName);
197             FREE(pwstNameList);
198         }
199
200         for(int i = 1 ; i < in.size(); i++)
201         {
202             if (wcscmp(pwstNameList[i], L"-append") == 0)
203             {
204                 continue;
205             }
206
207             bExport = export_data(iH5File, pITList[i], pwstNameList[i]);
208             if(bExport == false)
209             {
210                 break;
211             }
212         }
213
214         if (bExport)
215         {
216             //add or update scilab version and file version in hdf5 file
217             if (updateScilabVersion(iH5File) < 0)
218             {
219                 ScierrorW(999, _W("%ls: Unable to update Scilab version in \"%ls\"."), L"export_to_hfd5", pwstNameList[0]);
220                 return Function::Error;
221             }
222
223             if (updateFileVersion(iH5File) < 0)
224             {
225                 ScierrorW(999, _W("%ls: Unable to update HDF5 format version in \"%ls\"."), L"export_to_hfd5", pwstNameList[0]);
226                 return Function::Error;
227             }
228         }
229
230         //close hdf5 file
231         closeHDF5File(iH5File);
232         if(bExport == false)
233         {//remove file
234             deleteafileW(pwstNameList[0]);
235         }
236     }
237     //create boolean return value
238     Bool* pOut = new Bool(bExport);
239     out.push_back(pOut);
240
241     //free memory
242     for (int i = 0 ; i < in.size() ; i++)
243     {
244         FREE(pwstNameList[i]);
245     }
246
247     FREE(pwstNameList);
248     FREE(pITList);
249     return Function::OK;
250 }
251
252 static bool export_data(int _iH5File, InternalType* pIT, wchar_t* _pwstName)
253 {
254     bool bReturn = false;
255
256     switch(pIT->getType())
257     {
258     case InternalType::RealDouble :
259         {
260             bReturn = export_double(_iH5File, pIT, _pwstName);
261             break;
262         }
263    case InternalType::RealPoly :
264         {
265             bReturn = export_poly(_iH5File, pIT, _pwstName);
266             break;
267         }
268     case InternalType::RealBool :
269         {
270             bReturn = export_boolean(_iH5File, pIT, _pwstName);
271             break;
272         }
273         /*
274     case sci_sparse :
275         {
276             bReturn = export_sparse(_iH5File, pIT, _pwstName);
277             break;
278         }
279     case sci_boolean_sparse :
280         {
281             bReturn = export_boolean_sparse(_iH5File, pIT, _pwstName);
282             break;
283         }
284     case sci_matlab_sparse :
285         {
286             bReturn = export_matlab_sparse(pvApiCtx, _piVar, _pwstName);
287             break;
288         }
289      */
290     case InternalType::RealInt8 :
291     case InternalType::RealUInt8 :
292     case InternalType::RealInt16 :
293     case InternalType::RealUInt16 :
294     case InternalType::RealInt32 :
295     case InternalType::RealUInt32 :
296     case InternalType::RealInt64 :
297     case InternalType::RealUInt64 :
298         {
299             bReturn = export_ints(_iH5File, pIT, _pwstName);
300             break;
301         }
302         /*
303     case sci_handles :
304         {
305             bReturn = export_handles(pvApiCtx, _piVar, _pwstName);
306             break;
307         }
308         */
309     case InternalType::RealString :
310         {
311             bReturn = export_strings(_iH5File, pIT, _pwstName);
312             break;
313         }
314         /*
315     case Function :
316         {
317             bReturn = export_u_function(pvApiCtx, _piVar, _pwstName);
318             break;
319         }
320     case sci_c_function :
321         {
322             bReturn = export_c_function(pvApiCtx, _piVar, _pwstName);
323             break;
324         }
325     case sci_lib :
326         {
327             bReturn = export_lib(pvApiCtx, _piVar, _pwstName);
328             break;
329         }
330         */
331     case InternalType::RealList :
332     case InternalType::RealTList :
333     case InternalType::RealMList :
334         {
335             bReturn = export_list(_iH5File, pIT, _pwstName);
336             break;
337         }
338         /*
339     case sci_lufact_pointer :
340         {
341             bReturn = export_lufact_pointer(pvApiCtx, _piVar, _pwstName);
342             break;
343         }
344         */
345     case 0 : //void case to "null" items in list
346         {
347             bReturn = export_void(_iH5File, pIT, _pwstName);
348             break;
349         }
350     }
351     return bReturn;
352 }
353
354
355 static bool export_void(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
356 {
357     int iRet = writeVoid(_iH5File, wide_string_to_UTF8(_pwstName));
358     if(iRet)
359     {
360         return false;
361     }
362
363     char pstMsg[] = "void";
364     print_type(pstMsg);
365     return true;
366 }
367
368 static bool export_undefined(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
369 {
370     int iRet = writeUndefined(_iH5File, wide_string_to_UTF8(_pwstName));
371     if(iRet)
372     {
373         return false;
374     }
375
376     char pstMsg[] = "void";
377     print_type(pstMsg);
378     return true;
379 }
380
381 static bool export_list(int _iH5File, InternalType* pIT, wchar_t* _pwstName)
382 {
383     int iRet        = 0;
384     char* pstName   = wide_string_to_UTF8(_pwstName);
385     bool bReturn    = false;
386
387     List* pList = pIT->getAs<List>();
388     int iItemNumber = pList->getSize();
389     //create groupe name
390     char* pstGroupName  = createGroupName(pstName);
391
392     iLevel++;
393     //open list
394     void *pvList = openList(_iH5File, pstGroupName, iItemNumber);
395     for(int i = 0 ; i < iItemNumber ; i++)
396     {
397         int *piNewVar = NULL;
398        // getListItemAddress(_piVar, i + 1, &piNewVar);//1 indexed
399         InternalType* pNewIT =  pList->get(i);
400         char* pstPathName   = createPathName(pstGroupName, i);
401         wchar_t* pwstPathName = to_wide_string(pstPathName);
402         if(pNewIT->isListUndefined())
403         {//undefined item
404             bReturn = export_undefined(_iH5File, pNewIT, pwstPathName);
405         }
406         else
407         {
408             bReturn = export_data(_iH5File, pNewIT, pwstPathName);
409         }
410
411         iRet = addItemInList(_iH5File, pvList, i, pstPathName);
412         FREE(pstPathName);
413         FREE(pwstPathName);
414
415         if(bReturn == false || iRet)
416             return false;
417     }
418     iLevel--;
419
420     int type = 0;
421     switch(pIT->getType())
422     {
423     case InternalType::RealList :
424         type = sci_list;
425         break;
426     case InternalType::RealTList :
427         type = sci_tlist;
428         break;
429     case InternalType::RealMList :
430         type = sci_mlist;
431         break;
432     default : return false;
433     }
434
435     closeList(_iH5File, pvList, pstName, iItemNumber, type);
436     FREE(pstGroupName);
437     //close list
438     return true;
439 }
440
441 static bool export_double(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
442 {
443     int iRet            = 0;
444     Double* pDbl = pIT->getAs<Double>();
445     char* pstName       = wide_string_to_UTF8(_pwstName);
446
447     if(pDbl->isComplex())
448         iRet = writeDoubleComplexMatrix(_iH5File, pstName, pDbl->getRows(), pDbl->getCols(), pDbl->getReal(), pDbl->getImg());
449     else
450         iRet = writeDoubleMatrix(_iH5File, pstName, pDbl->getRows(), pDbl->getCols(), pDbl->getReal());
451
452     FREE(pstName);
453
454     if(iRet)
455     {
456         return false;
457     }
458
459     char pstMsg[512];
460     sprintf(pstMsg, "double (%d x %d)", pDbl->getRows(), pDbl->getCols());
461     print_type(pstMsg);
462     return true;
463 }
464
465 static bool export_poly(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
466 {
467     int iRet                = 0;
468     Polynom* pPoly   = pIT->getAs<Polynom>();
469     char* pstName           = wide_string_to_UTF8(_pwstName);
470     char* varName           = wide_string_to_UTF8(pPoly->getVariableName().c_str());
471     double** real           = NULL;
472     double** img            = NULL;
473     int* nbrCoef            = NULL;
474     int size                = pPoly->getRows()*pPoly->getCols();
475
476     real = (double**)MALLOC(size*sizeof(double*));
477     nbrCoef = (int*)MALLOC(size*sizeof(int));
478
479     for(int i=0; i < size; i++)
480     {
481         nbrCoef[i] = pPoly->get(i)->getRank();
482         real[i] = pPoly->get(i)->getCoefReal();
483     }
484
485     if(pPoly->isComplex())
486     {
487         img = (double**)MALLOC(size*sizeof(double*));
488         for(int i=0; i <size; i++)
489         {
490             img[i] = pPoly->get(i)->getCoefImg();
491         }
492
493         iRet = writePolyComplexMatrix(_iH5File, pstName, varName , pPoly->getRows(), pPoly->getCols(), nbrCoef, real, img);
494         FREE(img);
495     }
496     else
497     {
498         iRet = writePolyMatrix(_iH5File, pstName, varName, pPoly->getRows(), pPoly->getCols(), nbrCoef, real);
499     }
500
501     FREE(nbrCoef);
502     FREE(real);
503     FREE(pstName);
504     FREE(varName);
505
506     if(iRet)
507     {
508         return false;
509     }
510 /*
511     char pstMsg[512];
512     sprintf(pstMsg, "poly (%d x %d)", iRows, iCols);
513     print_type(pstMsg);
514 */
515     return true;
516 }
517
518 static bool export_boolean(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
519 {
520     int iRet            = 0;
521     Bool* pBool  = pIT->getAs<Bool>();
522     char* pstName       = wide_string_to_UTF8(_pwstName);
523
524     iRet = writeBooleanMatrix(_iH5File, pstName, pBool->getRows(), pBool->getCols(), pBool->get());
525
526     FREE(pstName);
527
528     if(iRet)
529     {
530         //Msg ??
531         return false;
532     }
533
534     char pstMsg[512];
535     sprintf(pstMsg, "bool (%d x %d)", pBool->getRows(), pBool->getCols());
536     print_type(pstMsg);
537     return true;
538 }
539 /*
540 static bool export_boolean_sparse(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
541 {
542     int iRet                                            = 0;
543     int iRows                                           = 0;InternalType::Real
544     int iCols                                           = 0;
545     int iNbItem                                 = 0;
546     int* piNbItemRow            = NULL;
547     int* piColPos                               = NULL;
548
549     SciErr sciErr = getBooleanSparseMatrix(pvApiCtx, _piVar, &iRows, &iCols, &iNbItem, &piNbItemRow, &piColPos);
550     if(sciErr.iErr)
551     {
552         printError(&sciErr, 0);
553         return false;
554     }
555
556     iRet = writeBooleanSparseMatrix(_iH5File, _pstName, iRows, iCols, iNbItem, piNbItemRow, piColPos);
557     if(iRet)
558     {
559         //Msg ??
560         return false;
561     }
562
563     char pstMsg[512];
564     sprintf(pstMsg, "boolean sparse (%d x %d)", iRows, iCols);
565     print_type(pstMsg);
566     return true;
567 }
568 /*
569 static bool export_sparse(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
570 {
571     int iRet                                            = 0;
572     int iRows                                           = 0;
573     int iCols                                           = 0;
574     int iNbItem                                 = 0;
575     int* piNbItemRow            = NULL;
576     int* piColPos                               = NULL;
577     double* pdblReal            = NULL;
578     double* pdblImg             = NULL;
579     SciErr sciErr;
580
581     if(isVarComplex(pvApiCtx, _piVar))
582     {
583         sciErr = getComplexSparseMatrix(pvApiCtx, _piVar, &iRows, &iCols, &iNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
584         if(sciErr.iErr)
585         {
586             printError(&sciErr, 0);
587             return false;
588         }
589
590         iRet = writeSparseComplexMatrix(_iH5File, _pstName, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
591     }
592     else
593     {
594         sciErr = getSparseMatrix(pvApiCtx, _piVar, &iRows, &iCols, &iNbItem, &piNbItemRow, &piColPos, &pdblReal);
595         if(sciErr.iErr)
596         {
597             printError(&sciErr, 0);
598             return false;
599         }
600
601         iRet = writeSparseMatrix(_iH5File, _pstName, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
602     }
603
604     if(iRet)
605     {
606         return false;
607     }
608
609     char pstMsg[512];
610     sprintf(pstMsg, "sparse (%d x %d)", iRows, iCols);
611     print_type(pstMsg);
612     return true;
613 }
614 /*
615 static bool export_matlab_sparse(void* pvApiCtx, int *_piVar, char* _pstName)
616 {
617     print_type(_pstName);
618     return false;
619 }
620 */
621 static bool export_ints(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
622 {
623     int iRet            = 0;
624     char* pstName       = wide_string_to_UTF8(_pwstName);
625
626     switch(pIT->getType())
627     {
628         case InternalType::RealInt8 :
629         {
630             Int8* pInt    = pIT->getAs<Int8>();
631             iRet = writeInteger8Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
632             break;
633         }
634         case InternalType::RealUInt8 :
635         {
636             UInt8* pInt    = pIT->getAs<UInt8>();
637             iRet = writeUnsignedInteger8Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
638             break;
639         }
640         case InternalType::RealInt16 :
641         {
642             Int16* pInt    = pIT->getAs<Int16>();
643             iRet = writeInteger16Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
644             break;
645         }
646         case InternalType::RealUInt16 :
647         {
648             UInt16* pInt    = pIT->getAs<UInt16>();
649             iRet = writeUnsignedInteger16Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
650             break;
651         }
652         case InternalType::RealInt32 :
653         {
654             Int32* pInt    = pIT->getAs<Int32>();
655             iRet = writeInteger32Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
656             break;
657         }
658         case InternalType::RealUInt32 :
659         {
660             UInt32* pInt    = pIT->getAs<UInt32>();
661             iRet = writeUnsignedInteger32Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
662             break;
663         }
664         case InternalType::RealInt64 :
665         {
666             Int64* pInt    = pIT->getAs<Int64>();
667             iRet = writeInteger64Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
668             break;
669         }
670         case InternalType::RealUInt64 :
671         {
672             UInt64* pInt    = pIT->getAs<UInt64>();
673             iRet = writeUnsignedInteger64Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
674             break;
675         }
676         default :
677             iRet = true;
678     }
679
680     if(iRet)
681     {
682         return false;
683     }
684 /*
685     char pstMsg[512];
686     sprintf(pstMsg, "int%d (%d x %d)", 8*iPrec, iRows, iCols);
687     print_type(pstMsg);
688 */
689     return true;
690 }
691 /*
692 static bool export_handles(void* pvApiCtx, int *_piVar, char* _pstName)
693 {
694     print_type(_pstName);
695     return false;
696 }
697 */
698 static bool export_strings(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
699 {
700
701     int iRet            = 0;
702     String* pStr = pIT->getAs<String>();
703     char* pstName       = wide_string_to_UTF8(_pwstName);
704     char** pstData      = NULL;
705
706     pstData = (char**)malloc(pStr->getRows()*pStr->getCols()*sizeof(char*));
707
708     for(int i=0; i < pStr->getRows()*pStr->getCols(); i++)
709         pstData[i] = wide_string_to_UTF8(pStr->get(i));
710
711     iRet = writeStringMatrix(_iH5File, pstName, pStr->getRows(), pStr->getCols(),pstData);
712
713     FREE(pstName);
714     FREE(pstData);
715
716     if(iRet)
717     {
718         return false;
719     }
720
721     char pstMsg[512];
722     sprintf(pstMsg, "string (%d x %d)", pStr->getRows(), pStr->getCols());
723     print_type(pstMsg);
724
725     return true;
726 }
727 /*
728 static bool export_u_function(void* pvApiCtx, int *_piVar, char* _pstName)
729 {
730     print_type(_pstName);
731     return false;
732 }
733 /*
734 static bool export_c_function(void* pvApiCtx, int *_piVar, char* _pstName)
735 {
736     print_type(_pstName);
737     return false;
738 }
739 /*
740 static bool export_lib(void* pvApiCtx, int *_piVar, char* _pstName)
741 {
742     print_type(_pstName);
743     return false;
744 }
745 /*
746 static bool export_lufact_pointer(void* pvApiCtx, int *_piVar, char* _pstName)
747 {
748     print_type(_pstName);
749     return false;
750 }
751 */
752 void print_type(char* _pstType)
753 {
754 #ifdef PRINT_DEBUG
755     for(int i = 0 ; i < iLevel ; i++)
756     {
757         sciprint("\t");
758     }
759     sciprint("%s\n", _pstType);
760 #endif
761 }
762
763
764 int extractVarNameList(typed_list &in, wchar_t** _pstNameList)
765 {
766     int iCount = 0;
767
768     for(int i = 0 ; i < in.size() ; i++)
769     {
770         if(in[i]->isString() == false || in[i]->getAs<String>()->isScalar() == false)
771         {
772             ScierrorW(999,_W("%ls: Wrong type for input argument #%d: A string expected.\n"), L"export_to_hdf5", i + 1);
773             return 0;
774         }
775
776         _pstNameList[i] = in[i]->getAs<String>()->get(0);
777         iCount++;
778     }
779     return iCount;
780 }
781 /*--------------------------------------------------------------------------*/