Merge remote-tracking branch 'origin/master' into YaSp 34/8634/1
Antoine ELIAS [Thu, 9 Aug 2012 12:44:46 +0000 (14:44 +0200)]
Conflicts:
scilab/configure
scilab/modules/core/macros/toolboxes.sci
scilab/modules/hdf5/sci_gateway/cpp/sci_export_to_hdf5.cpp
scilab/modules/hdf5/sci_gateway/cpp/sci_import_from_hdf5.cpp

Change-Id: Ia51b250988fd02b4aa91c6fe149670eb5853b3a7

1  2 
scilab/.gitignore
scilab/configure.ac
scilab/modules/hdf5/sci_gateway/cpp/sci_export_to_hdf5.cpp
scilab/modules/hdf5/sci_gateway/cpp/sci_import_from_hdf5.cpp
scilab/modules/hdf5/src/cpp/h5_readDataFromFile.cpp
scilab/modules/hdf5/src/cpp/h5_writeDataToFile.cpp
scilab/modules/renderer/renderer.iss

Simple merge
Simple merge
  *
  */
  
 +#include <stdio.h>
 +
 +#include "string.hxx"
 +#include "int.hxx"
 +#include "bool.hxx"
 +#include "polynom.hxx"
 +#include "tlist.hxx"
 +#include "mlist.hxx"
 +#include "function.hxx"
 +#include "context.hxx"
 +#include "hdf5_gw.hxx"
 +
  extern "C"
  {
 -#include <string.h>
 -#include <stdio.h>
 -#include "gw_hdf5.h"
  #include "MALLOC.h"
 -#include "Scierror.h"
  #include "localization.h"
 -#include "sciprint.h"
 -#include "api_scilab.h"
 -#include "deleteafile.h"
 -#include "expandPathVariable.h"
 +#include "charEncoding.h"
 +#include "Scierror.h"
  #include "h5_fileManagement.h"
 +#include "deleteafile.h"
  #include "h5_writeDataToFile.h"
+ #include "h5_readDataFromFile.h"
+ #include "h5_attributeConstants.h"
 -#include "freeArrayOfString.h"
 -#ifdef _MSC_VER
 -#include "strdup_windows.h"
 -#endif
 -#include "scilabmode.h"
 -#include "splitpath.h"
 -#include "scicurdir.h"
 +#include "sci_types.h"
++#include "expandPathVariable.h"
++
  }
 +
  #include "forceJHDF5load.hxx"
  
++using namespace types;
++
  //#define PRINT_DEBUG
  int iLevel = 0;
  
- static bool export_data(int _iH5File, types::InternalType* pIT, wchar_t* _pwstName);
- static bool export_list(int _iH5File, types::InternalType* pIT, wchar_t* _pwstName);
- static bool export_double(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName);
- static bool export_poly(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName);
- static bool export_boolean(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName);
- static bool export_sparse(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName);
- //static bool export_boolean_sparse(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName);
 -static bool export_data(int _iH5File, int *_piVar, char* _pstName);
 -static bool export_list(int _iH5File, int *_piVar, char* _pstName, int _iVarType);
 -static bool export_double(int _iH5File, int *_piVar, char* _pstName);
 -static bool export_poly(int _iH5File, int *_piVar, char* _pstName);
 -static bool export_boolean(int _iH5File, int *_piVar, char* _pstName);
 -static bool export_sparse(int _iH5File, int *_piVar, char* _pstName);
 -static bool export_boolean_sparse(int _iH5File, int *_piVar, char* _pstName);
 -static bool export_matlab_sparse(int *_piVar, char* _pstName);
 -static bool export_ints(int _iH5File, int *_piVar, char* _pstName);
 -static bool export_handles(int *_piVar, char* _pstName);
 -static bool export_strings(int _iH5File, int *_piVar, char* _pstName);
 -static bool export_u_function(int *_piVar, char* _pstName);
 -static bool export_c_function(int *_piVar, char* _pstName);
 -static bool export_lib(int *_piVar, char* _pstName);
 -static bool export_lufact_pointer(int *_piVar, char* _pstName);
 -static bool export_void(int _iH5File, int *_piVar, char* _pstName);
++static bool export_data(int _iH5File, InternalType* pIT, wchar_t* _pwstName);
++static bool export_list(int _iH5File, InternalType* pIT, wchar_t* _pwstName);
++static bool export_double(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
++static bool export_poly(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
++static bool export_boolean(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
++static bool export_sparse(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
++//static bool export_boolean_sparse(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
 +//static bool export_matlab_sparse(void* pvApiCtx, int *_piVar, char* _pstName);
- static bool export_ints(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName);
++static bool export_ints(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
 +//static bool export_handles(void* pvApiCtx, int *_piVar, char* _pstName);
- static bool export_strings(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName);
++static bool export_strings(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
 +//static bool export_u_function(void* pvApiCtx, int *_piVar, char* _pstName);
 +//static bool export_c_function(void* pvApiCtx, int *_piVar, char* _pstName);
 +//static bool export_lib(void* pvApiCtx, int *_piVar, char* _pstName);
 +//static bool export_lufact_pointer(void* pvApiCtx, int *_piVar, char* _pstName);
 +
- static bool export_void(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName);
++static bool export_void(int _iH5File, InternalType* pIT,wchar_t* _pwstName);
  
 -void print_type(char* _pstType);
 -int extractVarNameList(int _iStart, int _iEnd, char** _pstNameList);
  
 +void print_type(char* _pstType);
- int extractVarNameList(types::typed_list &in, wchar_t** _pstNameList);
++int extractVarNameList(typed_list &in, wchar_t** _pstNameList);
  
  /*--------------------------------------------------------------------------*/
- types::Function::ReturnValue sci_export_to_hdf5(types::typed_list &in, int _iRetCount, types::typed_list &out)
 -int sci_export_to_hdf5(char *fname, unsigned long fname_len)
++Function::ReturnValue sci_export_to_hdf5(typed_list &in, int _iRetCount, typed_list &out)
  {
 -    int iNbVar          = 0;
 -    int** piAddrList    = NULL;
 -    char** pstNameList  = NULL;
 -    char *pstFileName   = NULL;
 -    bool bExport        = false;
 -    bool bAppendMode    = false;
 -
 -    SciErr sciErr;
 -
 -    CheckInputArgumentAtLeast(pvApiCtx, 2);
 -    CheckLhs(0, 1);
 +    int iNbVar              = 0;
++    InternalType** pITList  = NULL;
 +    wchar_t** pwstNameList    = NULL;
++    wchar_t* pwstFileName   = NULL;
 +    char* pstFileName       = NULL;
 +    bool bExport            = false;
++    bool bAppendMode        = false;
  
  #ifndef _MSC_VER
      forceJHDF5load();
  #endif
  
 -    pstNameList = (char**)MALLOC(sizeof(char*) * Rhs);
 -    iNbVar = extractVarNameList(1, Rhs, pstNameList);
 +    if(in.size() < 2)
 +    {
 +        ScierrorW(77, _W("%ls: Wrong number of input argument(s): At least %d expected.\n"), L"export_to_hdf5", 2);
-         return types::Function::Error;
++        return Function::Error;
 +    }
 +
 +    pwstNameList = (wchar_t**)MALLOC(sizeof(wchar_t*) * in.size());
 +    iNbVar = extractVarNameList(in, pwstNameList);
-     if(iNbVar != 0)
+     if (iNbVar == 0)
      {
-         //convert UTF16 to UTF8
-         pstFileName = wide_string_to_UTF8(pwstNameList[0]);
 -        FREE(pstNameList);
 -        return 1;
++        FREE(pwstNameList);
++        return Function::Error;
+     }
  
-         // open hdf5 file
-         int iH5File = createHDF5File(pstFileName);
-         if(iH5File < 0)
 -    piAddrList = (int**)MALLOC(sizeof(int*) * (iNbVar));
 -    for (int i = 1 ; i < Rhs ; i++)
++    pITList = (InternalType**)MALLOC(sizeof(InternalType*) * (iNbVar));
++    for (int i = 1 ; i < in.size() ; i++)
+     {
 -        if (strcmp(pstNameList[i], "-append") == 0)
++        if (wcscmp(pwstNameList[i], L"-append") == 0)
+         {
+             bAppendMode = true;
+         }
+         else
          {
-             if(iH5File == -2)
 -            sciErr = getVarAddressFromName(pvApiCtx, pstNameList[i], &piAddrList[i]);
 -            if (sciErr.iErr)
++            pITList[i] = symbol::Context::getInstance()->get(symbol::Symbol(pwstNameList[i]));
++            if (pITList[i] == NULL)
              {
-                 ScierrorW(999, _W("%ls: Wrong value for input argument #%d: \"%s\" is a directory"), L"export_to_hdf5", 1, pstFileName);
 -                Scierror(999, _("%s: Wrong value for input argument #%d: Defined variable expected.\n"), fname, i + 1);
 -                printError(&sciErr, 0);
 -                return 1;
++                ScierrorW(999, _W("%ls: Wrong value for input argument #%d: Defined variable expected.\n"), L"export_to_hdf5", i + 1);
++                return Function::Error;
              }
-             else
+         }
+     }
+     //check append option
+     iLevel = 0;
+     // open hdf5 file
 -    pstFileName = expandPathVariable(pstNameList[0]);
++    pwstFileName = expandPathVariableW(pwstNameList[0]);
++    pstFileName = wide_string_to_UTF8(pwstFileName);
++
+     int iH5File = 0;
+     if (bAppendMode)
+     {
+         iH5File = openHDF5File(pstFileName);
+         if (iH5File < 0)
+         {
+             iH5File = createHDF5File(pstFileName);
+         }
+     }
+     else
+     {
+         iH5File = createHDF5File(pstFileName);
+     }
+     if (iH5File < 0)
+     {
+         FREE(pstFileName);
+         if (iH5File == -2)
+         {
 -            Scierror(999, _("%s: Wrong value for input argument #%d: \"%s\" is a directory"), fname, 1, pstNameList[0]);
++            ScierrorW(999, _W("%ls: Wrong value for input argument #%d: \"%ls\" is a directory"), L"export_to_hdf5", 1, pwstNameList[0]);
+         }
+         else
+         {
 -            Scierror(999, _("%s: Cannot open file %s.\n"), fname, pstNameList[0]);
++            ScierrorW(999, _W("%ls: Cannot open file %ls.\n"), L"export_to_hdf5", pwstNameList[0]);
+         }
 -        return 1;
++        return Function::Error;
+     }
+     if (bAppendMode)
+     {
+         int iVersion = getSODFormatAttribute(iH5File);
+         if (iVersion != -1 && iVersion != SOD_FILE_VERSION)
+         {//to update version must be the same
 -            Scierror(999, _("%s: Wrong SOD file format version. Expected: %d Found: %d\n"), fname, SOD_FILE_VERSION, iVersion);
 -            return 1;
++            ScierrorW(999, _W("%ls: Wrong SOD file format version. Expected: %d Found: %d\n"), L"export_to_hfd5", SOD_FILE_VERSION, iVersion);
++            return Function::Error;
+         }
+         //check if variable already exists
+         int iNbItem = getVariableNames(iH5File, NULL);
+         if (iNbItem)
+         {
+             char **pstVarNameList = (char **)MALLOC(sizeof(char *) * iNbItem);
 -
+             iNbItem = getVariableNames(iH5File, pstVarNameList);
+             //import all data
+             for (int i = 0 ; i < iNbItem ; i++)
              {
-                 ScierrorW(999,_W("%ls: Cannot open file %s.\n"), L"export_to_hdf5", pstFileName);
 -                for (int j = 1 ; j < Rhs ; j++)
++                wchar_t *pwstVarNameList = to_wide_string(pstVarNameList[i]);
++                for (int j = 1 ; j < in.size() ; j++)
+                 {
 -                    if (strcmp(pstNameList[i], "-append") == 0)
++                    if (wcscmp(pwstNameList[i], L"-append") == 0)
+                     {
+                         continue;
+                     }
 -                    if (strcmp(pstVarNameList[i], pstNameList[j]) == 0)
++                    if (wcscmp(pwstVarNameList, pwstNameList[j]) == 0)
+                     {
 -
 -                        Scierror(999, _("%s: Variable \'%s\' already exists in file \'%s\'."), fname, pstVarNameList[i], pstNameList[0]);
 -                        return 1;
++                        ScierrorW(999, _W("%ls: Variable \'%ls\' already exists in file \'%ls\'."), L"export_to_hfd5", pwstVarNameList, pwstNameList[0]);
++                        FREE(pwstVarNameList);
++                        FREE(pstVarNameList[i]);
++                        return Function::Error;
+                     }
+                 }
++
++                FREE(pwstVarNameList);
+                 FREE(pstVarNameList[i]);
              }
 +
+             FREE(pstVarNameList);
 +            FREE(pstFileName);
 +            FREE(pwstNameList);
-             return types::Function::Error;
          }
 -    }
  
-         for(int i = 0 ; i < in.size() - 1; i++)
 -    // export data
 -    for (int i = 1 ; i < Rhs ; i++)
 -    {
 -        if (strcmp(pstNameList[i], "-append") == 0)
++        for(int i = 1 ; i < in.size(); i++)
          {
-             types::InternalType* pIT = symbol::Context::getInstance()->get(symbol::Symbol(pwstNameList[i + 1]));
 -            continue;
 -        }
++            if (wcscmp(pwstNameList[i], L"-append") == 0)
++            {
++                continue;
++            }
  
-             bExport = export_data(iH5File, pIT, pwstNameList[i + 1]);
 -        bExport = export_data(iH5File, piAddrList[i], pstNameList[i]);
 -        if (bExport == false)
 -        {
 -            break;
++            bExport = export_data(iH5File, pITList[i], pwstNameList[i]);
 +            if(bExport == false)
 +            {
 +                break;
 +            }
          }
 -    }
  
 -    if (bExport)
 -    {
 -        //add or update scilab version and file version in hdf5 file
 -        if (updateScilabVersion(iH5File) < 0)
++        if (bExport)
+         {
 -            Scierror(999, _("%s: Unable to update Scilab version in \"%s\"."), fname, pstNameList[0]);
 -            return 1;
 -        }
++            //add or update scilab version and file version in hdf5 file
++            if (updateScilabVersion(iH5File) < 0)
++            {
++                ScierrorW(999, _W("%ls: Unable to update Scilab version in \"%ls\"."), L"export_to_hfd5", pwstNameList[0]);
++                return Function::Error;
++            }
 -        if (updateFileVersion(iH5File) < 0)
 -        {
 -            Scierror(999, _("%s: Unable to update HDF5 format version in \"%s\"."), fname, pstNameList[0]);
 -            return 1;
++            if (updateFileVersion(iH5File) < 0)
++            {
++                ScierrorW(999, _W("%ls: Unable to update HDF5 format version in \"%ls\"."), L"export_to_hfd5", pwstNameList[0]);
++                return Function::Error;
++            }
+         }
 -    }
 -    //close hdf5 file
 -    closeHDF5File(iH5File);
 -    if (bExport == false)
 -    {
 -        //remove file
 -        deleteafile(pstFileName);
 +        //close hdf5 file
 +        closeHDF5File(iH5File);
 +        if(bExport == false)
 +        {//remove file
 +            deleteafileW(pwstNameList[0]);
 +        }
      }
 -    FREE(pstFileName);
 -
      //create boolean return value
-     types::Bool* pOut = new types::Bool(bExport);
 -    int *piReturn = NULL;
 -    sciErr = allocMatrixOfBoolean(pvApiCtx, Rhs + 1, 1, 1, &piReturn);
 -    if (sciErr.iErr)
 -    {
 -        printError(&sciErr, 0);
 -        return 1;
 -    }
 -
 -    if (bExport == true)
 -    {
 -        piReturn[0] = 1;
 -    }
 -    else
 -    {
 -        piReturn[0] = 0;
 -    }
 -
++    Bool* pOut = new Bool(bExport);
 +    out.push_back(pOut);
  
-     //free allocated memory
-     FREE(pstFileName);
-     FREE(pwstNameList);
+     //free memory
 -    for (int i = 0 ; i < Rhs ; i++)
++    for (int i = 0 ; i < in.size() ; i++)
+     {
 -        FREE(pstNameList[i]);
++        FREE(pwstNameList[i]);
+     }
 -    FREE(pstNameList);
 -
 -    FREE(piAddrList);
  
-     return types::Function::OK;
 -    LhsVar(1) = Rhs + 1;
 -    PutLhsVar();
 -    return 0;
++    FREE(pwstNameList);
++    FREE(pITList);
++    return Function::OK;
  }
  
- static bool export_data(int _iH5File, types::InternalType* pIT, wchar_t* _pwstName)
 -static bool export_data(int _iH5File, int* _piVar, char* _pstName)
++static bool export_data(int _iH5File, InternalType* pIT, wchar_t* _pwstName)
  {
      bool bReturn = false;
 -    int iType = 0;
  
 -    SciErr sciErr = getVarType(pvApiCtx, _piVar, &iType);
 -    if (sciErr.iErr)
 +    switch(pIT->getType())
      {
-     case types::InternalType::RealDouble :
 -        printError(&sciErr, 0);
 -        return false;
 -    }
 -
 -    switch (iType)
 -    {
 -        case sci_matrix :
 -        {
 -            bReturn = export_double(_iH5File, _piVar, _pstName);
 -            break;
 -        }
 -        case sci_poly :
++    case InternalType::RealDouble :
          {
 -            bReturn = export_poly(_iH5File, _piVar, _pstName);
 +            bReturn = export_double(_iH5File, pIT, _pwstName);
              break;
          }
-    case types::InternalType::RealPoly :
 -        case sci_boolean :
++   case InternalType::RealPoly :
          {
 -            bReturn = export_boolean(_iH5File, _piVar, _pstName);
 +            bReturn = export_poly(_iH5File, pIT, _pwstName);
              break;
          }
-     case types::InternalType::RealBool :
 -        case sci_sparse :
++    case InternalType::RealBool :
          {
 -            bReturn = export_sparse(_iH5File, _piVar, _pstName);
 +            bReturn = export_boolean(_iH5File, pIT, _pwstName);
              break;
          }
 -        case sci_boolean_sparse :
 +        /*
 +    case sci_sparse :
          {
 -            bReturn = export_boolean_sparse(_iH5File, _piVar, _pstName);
 +            bReturn = export_sparse(_iH5File, pIT, _pwstName);
              break;
          }
 -        case sci_matlab_sparse :
 +    case sci_boolean_sparse :
          {
 -            bReturn = export_matlab_sparse(_piVar, _pstName);
 +            bReturn = export_boolean_sparse(_iH5File, pIT, _pwstName);
              break;
          }
 -        case sci_ints :
 +    case sci_matlab_sparse :
          {
 -            bReturn = export_ints(_iH5File, _piVar, _pstName);
 +            bReturn = export_matlab_sparse(pvApiCtx, _piVar, _pwstName);
              break;
          }
 -        case sci_handles :
 -        {
 -            bReturn = export_handles(_piVar, _pstName);
 +     */
-     case types::InternalType::RealInt8 :
-     case types::InternalType::RealUInt8 :
-     case types::InternalType::RealInt16 :
-     case types::InternalType::RealUInt16 :
-     case types::InternalType::RealInt32 :
-     case types::InternalType::RealUInt32 :
-     case types::InternalType::RealInt64 :
-     case types::InternalType::RealUInt64 :
++    case InternalType::RealInt8 :
++    case InternalType::RealUInt8 :
++    case InternalType::RealInt16 :
++    case InternalType::RealUInt16 :
++    case InternalType::RealInt32 :
++    case InternalType::RealUInt32 :
++    case InternalType::RealInt64 :
++    case InternalType::RealUInt64 :
 +        {
 +            bReturn = export_ints(_iH5File, pIT, _pwstName);
              break;
          }
 -        case sci_strings :
 +        /*
 +    case sci_handles :
          {
 -            bReturn = export_strings(_iH5File, _piVar, _pstName);
 +            bReturn = export_handles(pvApiCtx, _piVar, _pwstName);
              break;
          }
 -        case sci_u_function :
 +        */
-     case types::InternalType::RealString :
++    case InternalType::RealString :
          {
 -            bReturn = export_u_function(_piVar, _pstName);
 +            bReturn = export_strings(_iH5File, pIT, _pwstName);
              break;
          }
 -        case sci_c_function :
 +        /*
-     case types::Function :
++    case Function :
          {
 -            bReturn = export_c_function(_piVar, _pstName);
 +            bReturn = export_u_function(pvApiCtx, _piVar, _pwstName);
              break;
          }
 -        case sci_lib :
 +    case sci_c_function :
          {
 -            bReturn = export_lib(_piVar, _pstName);
 +            bReturn = export_c_function(pvApiCtx, _piVar, _pwstName);
              break;
          }
 -        case sci_list :
 -        case sci_tlist :
 -        case sci_mlist :
 +    case sci_lib :
          {
 -            bReturn = export_list(_iH5File, _piVar, _pstName, iType);
 +            bReturn = export_lib(pvApiCtx, _piVar, _pwstName);
              break;
          }
 -        case sci_lufact_pointer :
 +        */
-     case types::InternalType::RealList :
-     case types::InternalType::RealTList :
-     case types::InternalType::RealMList :
++    case InternalType::RealList :
++    case InternalType::RealTList :
++    case InternalType::RealMList :
          {
 -            bReturn = export_lufact_pointer(_piVar, _pstName);
 +            bReturn = export_list(_iH5File, pIT, _pwstName);
              break;
          }
 -        case 0 : //void case to "null" items in list
 +        /*
 +    case sci_lufact_pointer :
          {
 -            bReturn = export_void(_iH5File, _piVar, _pstName);
 +            bReturn = export_lufact_pointer(pvApiCtx, _piVar, _pwstName);
              break;
          }
 -
 -        default :
 +        */
 +    case 0 : //void case to "null" items in list
          {
 -            bReturn = false;
 +            bReturn = export_void(_iH5File, pIT, _pwstName);
              break;
          }
      }
      return bReturn;
  }
  
 -static bool export_void(int _iH5File, int *_piVar, char* _pstName)
 +
- static bool export_void(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName)
++static bool export_void(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
  {
 -    int iRet = writeVoid(_iH5File, _pstName);
 -    if (iRet)
 +    int iRet = writeVoid(_iH5File, wide_string_to_UTF8(_pwstName));
 +    if(iRet)
      {
          return false;
      }
      return true;
  }
  
- static bool export_undefined(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName)
 -static bool export_undefined(int _iH5File, int *_piVar, char* _pstName)
++static bool export_undefined(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
  {
 -    int iRet = writeUndefined(_iH5File, _pstName);
 -    if (iRet)
 +    int iRet = writeUndefined(_iH5File, wide_string_to_UTF8(_pwstName));
 +    if(iRet)
      {
          return false;
      }
      return true;
  }
  
- static bool export_list(int _iH5File, types::InternalType* pIT, wchar_t* _pwstName)
 -static bool export_list(int _iH5File, int *_piVar, char* _pstName, int _iVarType)
++static bool export_list(int _iH5File, InternalType* pIT, wchar_t* _pwstName)
  {
      int iRet        = 0;
 +    char* pstName   = wide_string_to_UTF8(_pwstName);
      bool bReturn    = false;
 -    int iItemNumber = 0;
 -    SciErr sciErr   = getListItemNumber(pvApiCtx, _piVar, &iItemNumber);
 -    if (sciErr.iErr)
 -    {
 -        printError(&sciErr, 0);
 -        return false;
 -    }
 -
  
-     types::List* pList = pIT->getAs<types::List>();
++    List* pList = pIT->getAs<List>();
 +    int iItemNumber = pList->getSize();
      //create groupe name
 -    char* pstGroupName        = createGroupName(_pstName);
 -
 -    char pstMsg[256];
 -    sprintf(pstMsg, "list (%d)", iItemNumber);
 -    print_type(pstMsg);
 +    char* pstGroupName        = createGroupName(pstName);
  
      iLevel++;
      //open list
      void *pvList = openList(_iH5File, pstGroupName, iItemNumber);
 -    for (int i = 0 ; i < iItemNumber ; i++)
 +    for(int i = 0 ; i < iItemNumber ; i++)
      {
          int *piNewVar = NULL;
 -        getListItemAddress(pvApiCtx, _piVar, i + 1, &piNewVar);//1 indexed
 +       // getListItemAddress(_piVar, i + 1, &piNewVar);//1 indexed
-         types::InternalType* pNewIT =  pList->get(i);
++        InternalType* pNewIT =  pList->get(i);
          char* pstPathName   = createPathName(pstGroupName, i);
 -
 -        if (piNewVar == NULL)
 -        {
 -            //undefined item
 -            bReturn = export_undefined(_iH5File, piNewVar, pstPathName);
 +        wchar_t* pwstPathName = to_wide_string(pstPathName);
 +        if(pNewIT->isListUndefined())
 +        {//undefined item
 +            bReturn = export_undefined(_iH5File, pNewIT, pwstPathName);
          }
          else
          {
              return false;
      }
      iLevel--;
 -    closeList(_iH5File, pvList, _pstName, iItemNumber, _iVarType);
 +
 +    int type = 0;
 +    switch(pIT->getType())
 +    {
-     case types::InternalType::RealList :
++    case InternalType::RealList :
 +        type = sci_list;
 +        break;
-     case types::InternalType::RealTList :
++    case InternalType::RealTList :
 +        type = sci_tlist;
 +        break;
-     case types::InternalType::RealMList :
++    case InternalType::RealMList :
 +        type = sci_mlist;
 +        break;
 +    default : return false;
 +    }
 +
 +    closeList(_iH5File, pvList, pstName, iItemNumber, type);
      FREE(pstGroupName);
      //close list
      return true;
  }
  
- static bool export_double(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName)
 -static bool export_double(int _iH5File, int *_piVar, char* _pstName)
++static bool export_double(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
  {
 -    int iRet                                  = 0;
 -    int iComplex                      = isVarComplex(pvApiCtx, _piVar);
 -    int iRows                                 = 0;
 -    int iCols                                 = 0;
 -    int iType = 0;
 -    double *pdblReal  = NULL;
 -    double *pdblImg           = NULL;
 -
 -    SciErr sciErr = getVarType(pvApiCtx, _piVar, &iType);
 -    if (sciErr.iErr)
 -    {
 -        printError(&sciErr, 0);
 -        return false;
 -    }
 -
 -    if (iType != sci_matrix)
 -    {
 -        return false;
 -    }
 +    int iRet            = 0;
-     types::Double* pDbl = pIT->getAs<types::Double>();
++    Double* pDbl = pIT->getAs<Double>();
 +    char* pstName       = wide_string_to_UTF8(_pwstName);
  
 -    if (iComplex)
 -    {
 -        sciErr = getComplexMatrixOfDouble(pvApiCtx, _piVar, &iRows, &iCols, &pdblReal, &pdblImg);
 -        if (sciErr.iErr)
 -        {
 -            printError(&sciErr, 0);
 -            return false;
 -        }
 -
 -        iRet = writeDoubleComplexMatrix(_iH5File, _pstName, iRows, iCols, pdblReal, pdblImg);
 -    }
 +    if(pDbl->isComplex())
 +        iRet = writeDoubleComplexMatrix(_iH5File, pstName, pDbl->getRows(), pDbl->getCols(), pDbl->getReal(), pDbl->getImg());
      else
 -    {
 -        sciErr = getMatrixOfDouble(pvApiCtx, _piVar, &iRows, &iCols, &pdblReal);
 -        if (sciErr.iErr)
 -        {
 -            printError(&sciErr, 0);
 -            return false;
 -        }
 +        iRet = writeDoubleMatrix(_iH5File, pstName, pDbl->getRows(), pDbl->getCols(), pDbl->getReal());
  
 -        iRet = writeDoubleMatrix(_iH5File, _pstName, iRows, iCols, pdblReal);
 -    }
 +    FREE(pstName);
  
 -    if (iRet)
 +    if(iRet)
      {
          return false;
      }
      return true;
  }
  
- static bool export_poly(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName)
 -static bool export_poly(int _iH5File, int *_piVar, char* _pstName)
++static bool export_poly(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
  {
 -    int iRet                                          = 0;
 -    int iRows                                         = 0;
 -    int iCols                                         = 0;
 -    int* piNbCoef                             = NULL;
 -    double** pdblReal         = NULL;
 -    double** pdblImg          = NULL;
 -    char pstVarName[64]       = {0};
 -    int iVarNameLen                   = 0;
 -
 -    SciErr sciErr = getPolyVariableName(pvApiCtx, _piVar, pstVarName, &iVarNameLen);
 -    if (sciErr.iErr)
 +    int iRet                = 0;
-     types::Polynom* pPoly   = pIT->getAs<types::Polynom>();
++    Polynom* pPoly   = pIT->getAs<Polynom>();
 +    char* pstName           = wide_string_to_UTF8(_pwstName);
 +    char* varName           = wide_string_to_UTF8(pPoly->getVariableName().c_str());
 +    double** real           = NULL;
 +    double** img            = NULL;
 +    int* nbrCoef            = NULL;
 +    int size                = pPoly->getRows()*pPoly->getCols();
 +
 +    real = (double**)MALLOC(size*sizeof(double*));
 +    nbrCoef = (int*)MALLOC(size*sizeof(int));
 +
 +    for(int i=0; i < size; i++)
      {
 -        printError(&sciErr, 0);
 -        return false;
 +        nbrCoef[i] = pPoly->get(i)->getRank();
 +        real[i] = pPoly->get(i)->getCoefReal();
      }
  
 -    if (isVarComplex(pvApiCtx, _piVar))
 +    if(pPoly->isComplex())
      {
 -        sciErr = getComplexMatrixOfPoly(pvApiCtx, _piVar, &iRows, &iCols, NULL, NULL, NULL);
 -        if (sciErr.iErr)
 -        {
 -            printError(&sciErr, 0);
 -            return false;
 -        }
 -
 -        piNbCoef = (int*)MALLOC(iRows * iCols * sizeof(int));
 -        sciErr = getComplexMatrixOfPoly(pvApiCtx, _piVar, &iRows, &iCols, piNbCoef, NULL, NULL);
 -        if (sciErr.iErr)
 -        {
 -            printError(&sciErr, 0);
 -            return false;
 -        }
 -
 -        pdblReal = (double**)MALLOC(sizeof(double*) * iRows * iCols);
 -        pdblImg = (double**)MALLOC(sizeof(double*) * iRows * iCols);
 -        for (int i = 0 ; i < iRows * iCols ; i++)
 +        img = (double**)MALLOC(size*sizeof(double*));
 +        for(int i=0; i <size; i++)
          {
 -            pdblReal[i] = (double*)MALLOC(sizeof(double) * piNbCoef[i]);// for null termination
 -            pdblImg[i]        = (double*)MALLOC(sizeof(double) * piNbCoef[i]);// for null termination
 -        }
 -        sciErr = getComplexMatrixOfPoly(pvApiCtx, _piVar, &iRows, &iCols, piNbCoef, pdblReal, pdblImg);
 -        if (sciErr.iErr)
 -        {
 -            printError(&sciErr, 0);
 -            return false;
 +            img[i] = pPoly->get(i)->getCoefImg();
          }
  
 -        iRet = writePolyComplexMatrix(_iH5File, _pstName, pstVarName, iRows, iCols, piNbCoef, pdblReal, pdblImg);
 +        iRet = writePolyComplexMatrix(_iH5File, pstName, varName , pPoly->getRows(), pPoly->getCols(), nbrCoef, real, img);
 +        FREE(img);
      }
      else
      {
      return true;
  }
  
- static bool export_boolean(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName)
 -static bool export_boolean(int _iH5File, int *_piVar, char* _pstName)
++static bool export_boolean(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
  {
 -    int iRows                                 = 0;
 -    int iCols                                 = 0;
 -    int *piData                               = NULL;
 +    int iRet            = 0;
-     types::Bool* pBool  = pIT->getAs<types::Bool>();
++    Bool* pBool  = pIT->getAs<Bool>();
 +    char* pstName       = wide_string_to_UTF8(_pwstName);
  
 -    //for error management
 -    SciErr sciErr = getMatrixOfBoolean(pvApiCtx, _piVar, &iRows, &iCols, &piData);
 -    if (sciErr.iErr)
 -    {
 -        printError(&sciErr, 0);
 -        return 0;
 -    }
 +    iRet = writeBooleanMatrix(_iH5File, pstName, pBool->getRows(), pBool->getCols(), pBool->get());
  
 -    int iRet = writeBooleanMatrix(_iH5File, _pstName, iRows, iCols, piData);
 -    if (iRet)
 +    FREE(pstName);
 +
 +    if(iRet)
      {
          //Msg ??
          return false;
      print_type(pstMsg);
      return true;
  }
 -
 -static bool export_boolean_sparse(int _iH5File, int *_piVar, char* _pstName)
 +/*
- static bool export_boolean_sparse(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName)
++static bool export_boolean_sparse(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
  {
      int iRet                                          = 0;
 -    int iRows                                         = 0;
 +    int iRows                                         = 0;InternalType::Real
      int iCols                                         = 0;
      int iNbItem                                       = 0;
      int* piNbItemRow          = NULL;
      print_type(pstMsg);
      return true;
  }
 -
 -static bool export_sparse(int _iH5File, int *_piVar, char* _pstName)
 +/*
- static bool export_sparse(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName)
++static bool export_sparse(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
  {
      int iRet                                          = 0;
      int iRows                                         = 0;
@@@ -502,67 -709,102 +617,67 @@@ static bool export_matlab_sparse(void* 
      print_type(_pstName);
      return false;
  }
 -
 -static bool export_ints(int _iH5File, int *_piVar, char* _pstName)
 +*/
- static bool export_ints(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName)
++static bool export_ints(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
  {
 -    int iRet                                  = 0;
 -    int iRows                                 = 0;
 -    int iCols                                 = 0;
 -    void *piData                      = NULL;
 -    int iPrec                                 = 0;
 -
 -    SciErr sciErr = getMatrixOfIntegerPrecision(pvApiCtx, _piVar, &iPrec);
 -    if (sciErr.iErr)
 -    {
 -        printError(&sciErr, 0);
 -        return false;
 -    }
 +    int iRet            = 0;
 +    char* pstName       = wide_string_to_UTF8(_pwstName);
  
 -    switch (iPrec)
 +    switch(pIT->getType())
      {
-         case types::InternalType::RealInt8 :
 -        case SCI_INT8 :
 -            sciErr = getMatrixOfInteger8(pvApiCtx, _piVar, &iRows, &iCols, (char**)&piData);
 -            if (sciErr.iErr)
 -            {
 -                printError(&sciErr, 0);
 -                return false;
 -            }
 -            iRet = writeInteger8Matrix(_iH5File, _pstName, iRows, iCols, (char*)piData);
++        case InternalType::RealInt8 :
 +        {
-             types::Int8* pInt    = pIT->getAs<types::Int8>();
++            Int8* pInt    = pIT->getAs<Int8>();
 +            iRet = writeInteger8Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
              break;
 -        case SCI_UINT8 :
 -            sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, _piVar, &iRows, &iCols, (unsigned char**)&piData);
 -            if (sciErr.iErr)
 -            {
 -                printError(&sciErr, 0);
 -                return false;
 -            }
 -            iRet = writeUnsignedInteger8Matrix(_iH5File, _pstName, iRows, iCols, (unsigned char*)piData);
 +        }
-         case types::InternalType::RealUInt8 :
++        case InternalType::RealUInt8 :
 +        {
-             types::UInt8* pInt    = pIT->getAs<types::UInt8>();
++            UInt8* pInt    = pIT->getAs<UInt8>();
 +            iRet = writeUnsignedInteger8Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
              break;
 -        case SCI_INT16 :
 -            sciErr = getMatrixOfInteger16(pvApiCtx, _piVar, &iRows, &iCols, (short**)&piData);
 -            if (sciErr.iErr)
 -            {
 -                printError(&sciErr, 0);
 -                return false;
 -            }
 -            iRet = writeInteger16Matrix(_iH5File, _pstName, iRows, iCols, (short*)piData);
 +        }
-         case types::InternalType::RealInt16 :
++        case InternalType::RealInt16 :
 +        {
-             types::Int16* pInt    = pIT->getAs<types::Int16>();
++            Int16* pInt    = pIT->getAs<Int16>();
 +            iRet = writeInteger16Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
              break;
 -        case SCI_UINT16 :
 -            sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, _piVar, &iRows, &iCols, (unsigned short**)&piData);
 -            if (sciErr.iErr)
 -            {
 -                printError(&sciErr, 0);
 -                return false;
 -            }
 -            iRet = writeUnsignedInteger16Matrix(_iH5File, _pstName, iRows, iCols, (unsigned short*)piData);
 +        }
-         case types::InternalType::RealUInt16 :
++        case InternalType::RealUInt16 :
 +        {
-             types::UInt16* pInt    = pIT->getAs<types::UInt16>();
++            UInt16* pInt    = pIT->getAs<UInt16>();
 +            iRet = writeUnsignedInteger16Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
              break;
 -        case SCI_INT32 :
 -            sciErr = getMatrixOfInteger32(pvApiCtx, _piVar, &iRows, &iCols, (int**)&piData);
 -            if (sciErr.iErr)
 -            {
 -                printError(&sciErr, 0);
 -                return false;
 -            }
 -            iRet = writeInteger32Matrix(_iH5File, _pstName, iRows, iCols, (int*)piData);
 +        }
-         case types::InternalType::RealInt32 :
++        case InternalType::RealInt32 :
 +        {
-             types::Int32* pInt    = pIT->getAs<types::Int32>();
++            Int32* pInt    = pIT->getAs<Int32>();
 +            iRet = writeInteger32Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
              break;
 -        case SCI_UINT32 :
 -            sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, _piVar, &iRows, &iCols, (unsigned int**)&piData);
 -            if (sciErr.iErr)
 -            {
 -                printError(&sciErr, 0);
 -                return false;
 -            }
 -            iRet = writeUnsignedInteger32Matrix(_iH5File, _pstName, iRows, iCols, (unsigned int*)piData);
 +        }
-         case types::InternalType::RealUInt32 :
++        case InternalType::RealUInt32 :
 +        {
-             types::UInt32* pInt    = pIT->getAs<types::UInt32>();
++            UInt32* pInt    = pIT->getAs<UInt32>();
 +            iRet = writeUnsignedInteger32Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
              break;
 -        case SCI_INT64 :
 -            //sciErr = getMatrixOfInteger64(_piVar, &iRows, &iCols, (long long**)&piData);
 -            //if(sciErr.iErr)
 -            //{
 -            //        printError(&sciErr, 0);
 -            //        return false;
 -            //}
 -            //iRet = writeInteger64Matrix(_iH5File, _pstName, iRows, iCols, (long long*)piData);
 -            //break;
 -        case SCI_UINT64 :
 -            //sciErr = getMatrixOfUnsignedInteger64(_piVar, &iRows, &iCols, (unsigned long long**)&piData);
 -            //if(sciErr.iErr)
 -            //{
 -            //        printError(&sciErr, 0);
 -            //        return false;
 -            //}
 -            //iRet = writeUnsignedInteger64Matrix(_iH5File, _pstName, iRows, iCols, (unsigned long long*)piData);
 -            //break;
 -        default :
 -            return 1;
 +        }
-         case types::InternalType::RealInt64 :
++        case InternalType::RealInt64 :
 +        {
-             types::Int64* pInt    = pIT->getAs<types::Int64>();
++            Int64* pInt    = pIT->getAs<Int64>();
 +            iRet = writeInteger64Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
 +            break;
 +        }
-         case types::InternalType::RealUInt64 :
++        case InternalType::RealUInt64 :
 +        {
-             types::UInt64* pInt    = pIT->getAs<types::UInt64>();
++            UInt64* pInt    = pIT->getAs<UInt64>();
 +            iRet = writeUnsignedInteger64Matrix(_iH5File, pstName, pInt->getRows(), pInt->getCols(), pInt->get());
              break;
 +        }
 +        default :
 +            iRet = true;
      }
  
 -    if (iRet)
 +    if(iRet)
      {
          return false;
      }
@@@ -579,26 -820,46 +694,26 @@@ static bool export_handles(void* pvApiC
      print_type(_pstName);
      return false;
  }
 -
 -static bool export_strings(int _iH5File, int *_piVar, char* _pstName)
 +*/
- static bool export_strings(int _iH5File, types::InternalType* pIT,wchar_t* _pwstName)
++static bool export_strings(int _iH5File, InternalType* pIT,wchar_t* _pwstName)
  {
 -    int iRet                          = 0;
 -    int iRows                         = 0;
 -    int iCols                         = 0;
 -    int* piLen                        = NULL;
 -    char** pstData    = NULL;
  
 +    int iRet            = 0;
-     types::String* pStr = pIT->getAs<types::String>();
++    String* pStr = pIT->getAs<String>();
 +    char* pstName       = wide_string_to_UTF8(_pwstName);
 +    char** pstData      = NULL;
  
 -    SciErr sciErr = getMatrixOfString(pvApiCtx, _piVar, &iRows, &iCols, NULL, NULL);
 -    if (sciErr.iErr)
 -    {
 -        printError(&sciErr, 0);
 -        return false;
 -    }
 +    pstData = (char**)malloc(pStr->getRows()*pStr->getCols()*sizeof(char*));
  
 -    piLen = (int*)MALLOC(iRows * iCols * sizeof(int));
 -    sciErr = getMatrixOfString(pvApiCtx, _piVar, &iRows, &iCols, piLen, NULL);
 -    if (sciErr.iErr)
 -    {
 -        printError(&sciErr, 0);
 -        return false;
 -    }
 +    for(int i=0; i < pStr->getRows()*pStr->getCols(); i++)
 +        pstData[i] = wide_string_to_UTF8(pStr->get(i));
  
 -    pstData = (char**)MALLOC(sizeof(char*) * iRows * iCols);
 -    for (int i = 0 ; i < iRows * iCols ; i++)
 -    {
 -        pstData[i] = (char*)MALLOC(sizeof(char) * (piLen[i] + 1));// for null termination
 -    }
 -    sciErr = getMatrixOfString(pvApiCtx, _piVar, &iRows, &iCols, piLen, pstData);
 -    if (sciErr.iErr)
 -    {
 -        printError(&sciErr, 0);
 -        return false;
 -    }
 +    iRet = writeStringMatrix(_iH5File, pstName, pStr->getRows(), pStr->getCols(),pstData);
  
 -    iRet = writeStringMatrix(_iH5File, _pstName, iRows, iCols, pstData);
 +    FREE(pstName);
 +    FREE(pstData);
  
 -    if (iRet)
 +    if(iRet)
      {
          return false;
      }
@@@ -645,20 -907,28 +760,20 @@@ void print_type(char* _pstType
  #endif
  }
  
 -int extractVarNameList(int _iStart, int _iEnd, char** _pstNameList)
 +
- int extractVarNameList(types::typed_list &in, wchar_t** _pstNameList)
++int extractVarNameList(typed_list &in, wchar_t** _pstNameList)
  {
      int iCount = 0;
  
 -    for (int i = _iStart ; i <= _iEnd ; i++)
 +    for(int i = 0 ; i < in.size() ; i++)
      {
-         if(in[i]->isString() == false || in[i]->getAs<types::String>()->isScalar() == false)
 -        int* piAddr = NULL;
 -        int iType   = 0;
 -
 -        SciErr sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddr);
 -        if (sciErr.iErr)
++        if(in[i]->isString() == false || in[i]->getAs<String>()->isScalar() == false)
          {
 -            printError(&sciErr, 0);
 -            return 0;
 -        }
 -
 -        if (getAllocatedSingleString(pvApiCtx, piAddr, &_pstNameList[iCount]))
 -        {
 -            Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), "export_to_hdf5", i);
 +            ScierrorW(999,_W("%ls: Wrong type for input argument #%d: A string expected.\n"), L"export_to_hdf5", i + 1);
              return 0;
          }
  
-         _pstNameList[i] = in[i]->getAs<types::String>()->get(0);
++        _pstNameList[i] = in[i]->getAs<String>()->get(0);
          iCount++;
      }
      return iCount;
@@@ -31,92 -18,115 +31,104 @@@ extern "C
  #include "MALLOC.h"
  #include "Scierror.h"
  #include "localization.h"
 -#include "sciprint.h"
 -#include "api_scilab.h"
 -#include "../../../call_scilab/includes/call_scilab.h"
 +#include "charEncoding.h"
 +#include "Scierror.h"
  #include "h5_fileManagement.h"
  #include "h5_readDataFromFile.h"
+ #include "h5_attributeConstants.h"
 -#include "intmacr2tree.h"
+ #include "expandPathVariable.h"
  }
 +
  #include "forceJHDF5load.hxx"
  
 +
  //#define PRINT_DEBUG
  //#define TIME_DEBUG
  
  static int iTab = 0;
  static int iCloseList = 0;
  
 -void print_tree(char *_pstMsg);
 -
 -static bool import_variable(int _iFile, char* _pstVarName);
 -static bool import_data(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
 -static bool import_double(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
 -static bool import_string(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
 -static bool import_boolean(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
 -static bool import_integer(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
 -static bool import_sparse(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
 -static bool import_boolean_sparse(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
 -static bool import_poly(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
 -static bool import_list(int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname);
 -static bool import_void(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
 -static bool import_undefined(int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname);
 -
 -int sci_import_from_hdf5(char *fname, unsigned long fname_len)
 -{
 -    SciErr sciErr;
  
 -    int* piAddr = NULL;
 -    char* pstFilename = NULL;
 -    char* pstExpandedFilename = NULL;
 -    bool bImport = true;
 +void print_tree(char* _pstMsg);
  
 -    int iSelectedVar = Rhs - 1;
 +static types::InternalType* import_data(int _iDatasetId);
 +static types::InternalType* import_double(int _iDatasetId);
 +static types::InternalType* import_string(int _iDatasetId);
 +static types::InternalType* import_boolean(int _iDatasetId);
 +static types::InternalType* import_integer(int _iDatasetId);
 +//static types::InternalType* import_sparse(int _iDatasetId);
 +//static types::InternalType* import_boolean_sparse(int _iDatasetId);
 +static types::InternalType* import_poly(int _iDatasetId);
 +static types::InternalType* import_list(int _iDatasetId, int _iVarType);
 +//static types::InternalType* import_void(int _iDatasetId);
 +static types::InternalType* import_undefined(int _iDatasetId);
  
 -    checkInputArgumentAtLeast(pvApiCtx, 1);
 -    CheckLhs(1, 1);
 +types::Function::ReturnValue sci_import_from_hdf5(types::typed_list &in, int _iRetCount, types::typed_list &out)
 +{
 +    char* pstFileName       = NULL;
 +    int iNbItem             = 0;
 +    int iFile               = 0;
 +    bool bImport            = false;
++    int iSelectedVar        = in.size() - 1;
  
  #ifndef _MSC_VER
      forceJHDF5load();
  #endif
  
 -    iCloseList = 0;
 -
 -    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
 -    if (sciErr.iErr)
 +    if(in.size() != 1)
      {
 -        printError(&sciErr, 0);
 -        return 1;
 +        ScierrorW(77, _W("%ls: Wrong number of input argument(s): %d expected.\n"), L"import_from_hdf5", 1);
 +        return types::Function::Error;
      }
  
 -    if (getAllocatedSingleString(pvApiCtx, piAddr, &pstFilename))
 +    if(in[0]->isString() == false || in[0]->getAs<types::String>()->isScalar() == false)
      {
 -        Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
 -        return 1;
 +        ScierrorW(999,_W("%ls: Wrong type for input argument #%d: A string expected.\n"), L"import_from_hdf5", 1);
 +        return types::Function::Error;
      }
  
 +    pstFileName = wide_string_to_UTF8(in[0]->getAs<types::String>()->get(0));
 +
      //open hdf5 file
 -    pstExpandedFilename = expandPathVariable(pstFilename);
 -    int iFile = openHDF5File(pstExpandedFilename);
 -    if (iFile < 0)
 +    iFile = openHDF5File(pstFileName);
 +    if(iFile < 0)
      {
 -        FREE(pstExpandedFilename);
 -        FREE(pstFilename);
 -        Scierror(999, _("%s: Unable to open file: %s\n"), fname, pstFilename);
 -        return 1;
 +        ScierrorW(999,_W("%ls: Cannot open file %s.\n"), L"import_to_hdf5", pstFileName);
 +        return types::Function::Error;
      }
-     iNbItem = getVariableNames(iFile, NULL);
-     if(iNbItem != 0)
 -    FREE(pstExpandedFilename);
 -    FREE(pstFilename);
+     //manage version information
+     int iVersion = getSODFormatAttribute(iFile);
+     if (iVersion > SOD_FILE_VERSION)
+     {//can't read file with version newer that me !
 -        Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname, SOD_FILE_VERSION, iVersion);
 -        return 1;
++        ScierrorW(999, _W("%ls: Wrong SOD file format version. Max Expected: %d Found: %d\n"), L"import_to_hdf5", SOD_FILE_VERSION, iVersion);
++        return types::Function::Error;
+     }
+     if (iSelectedVar)
      {
 -        //selected variable
 -        char* pstVarName = NULL;
 -        for (int i = 0 ; i < iSelectedVar ; i++)
 +        char** pstVarNameList = (char**)MALLOC(sizeof(char*) * iNbItem);
 +        wchar_t** pwstVarNameList = (wchar_t**)MALLOC(sizeof(wchar_t*) * iNbItem);
 +        iNbItem = getVariableNames(iFile, pstVarNameList);
 +        for(int i=0; i<iNbItem; i++)
          {
 -            sciErr = getVarAddressFromPosition(pvApiCtx, i + 2, &piAddr);
 -            if (sciErr.iErr)
 -            {
 -                printError(&sciErr, 0);
 -                return 1;
 -            }
 +            pwstVarNameList[i] = to_wide_string(pstVarNameList[i]);
 +        }
  
 -            if (getAllocatedSingleString(pvApiCtx, piAddr, &pstVarName))
 +        //import all data
 +        for(int i = 0 ; i < iNbItem ; i++)
 +        {
 +            int iDataSetId = getDataSetIdFromName(iFile, pstVarNameList[i]);
 +            if(iDataSetId == 0)
              {
 -                Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, i + 1);
 -                return 1;
 +                return types::Function::Error;
              }
  
 -            if (import_variable(iFile, pstVarName) == false)
 +            types::InternalType* pIT = import_data(iDataSetId);
 +
 +            if(pIT == NULL)
              {
 -                bImport = false;
                  break;
              }
  
index 26f05a4,0000000..60d972a
mode 100644,000000..100644
--- /dev/null
@@@ -1,1157 -1,0 +1,1170 @@@
 +/*
 +*  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 +*  Copyright (C) 2009-2009 - DIGITEO - Bruno JOFRET
 +*
 +*  This file must be used under the terms of the CeCILL.
 +*  This source file is licensed as described in the file COPYING, which
 +*  you should have received as part of this distribution.  The terms
 +*  are also available at
 +*  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 +*
 +*/
 +
 +#define H5_USE_16_API
 +
 +extern "C"
 +{
 +#ifndef _MSC_VER
 +#include <sys/time.h>
 +#else
 +#include <windows.h>
 +//#include <winbase.h>
 +#endif
 +
 +#include <string.h>
 +#include <stdlib.h>
 +#include "MALLOC.h"
 +#include "sci_types.h"
 +#include "h5_attributeConstants.h"
 +#include "h5_readDataFromFile.h"
 +}
 +
 +#include "dynhdf5.hxx"
 +
 +//#define TIME_DEBUG
 +
 +static herr_t find_attr_by_name( hid_t loc_id, const char* name, void* data )
 +{
 +    return !strcmp(name, (const char*)data);
 +}
 +
 +static int readIntAttribute(int _iDatasetId, const char *_pstName)
 +{
 +    hid_t iAttributeId;
 +    herr_t status;
 +    int iVal = 0;
 +
 +    iAttributeId = DynHDF5::dynH5Aopen_name(_iDatasetId, _pstName);
 +    if(iAttributeId < 0)
 +    {
 +        return 0;
 +    }
 +
 +    status = DynHDF5::dynH5Aread(iAttributeId, H5T_NATIVE_INT, &iVal);
 +    if(status < 0)
 +    {
 +        return 0;
 +    }
 +
 +    status = DynHDF5::dynH5Aclose(iAttributeId);
 +    if(status < 0)
 +    {
 +        return 0;
 +    }
 +
 +    return iVal;
 +}
 +
 +/*
 +** WARNING : this function returns an allocated value that must be freed.
 +*/
 +static char *readAttribute(int _iDatasetId, const char *_pstName)
 +{
 +    hid_t iAttributeId;
 +    hid_t iFileType, memtype, iSpace;
 +    herr_t status;
 +    hsize_t dims[1];
 +    size_t iDim;
 +
 +    char *pstValue  = NULL;
 +
 +    if(DynHDF5::dynH5Aiterate(_iDatasetId, NULL, find_attr_by_name, (void*)_pstName))
 +    {
 +        iAttributeId = DynHDF5::dynH5Aopen_name(_iDatasetId, _pstName);
 +        if(iAttributeId < 0)
 +        {
 +            return NULL;
 +        }
 +        /*
 +        * Get the datatype and its size.
 +        */
 +        iFileType = DynHDF5::dynH5Aget_type (iAttributeId);
 +        iDim = DynHDF5::dynH5Tget_size (iFileType);
 +        iDim++;                         /* Make room for null terminator */
 +
 +        /*
 +        * Get dataspace and allocate memory for read buffer.  This is a
 +        * two dimensional attribute so the dynamic allocation must be done
 +        * in steps.
 +        */
 +        iSpace = DynHDF5::dynH5Aget_space (iAttributeId);
 +        if(iSpace < 0)
 +        {
 +            return NULL;
 +        }
 +
 +        status = DynHDF5::dynH5Sget_simple_extent_dims (iSpace, dims, NULL);
 +        if(status < 0)
 +        {
 +            return NULL;
 +        }
 +
 +        /*
 +        * Allocate space for string data.
 +        */
 +        pstValue = (char *) MALLOC ( (size_t)((dims[0] * iDim + 1 ) * sizeof (char)));
 +
 +        /*
 +        * Create the memory datatype.
 +        */
 +        memtype = DynHDF5::dynH5Tcopy (H5T_C_S1);
 +        status = DynHDF5::dynH5Tset_size (memtype, iDim);
 +        if(status < 0)
 +        {
 +            return NULL;
 +        }
 +
 +        /*
 +        * Read the data.
 +        */
 +        status = DynHDF5::dynH5Aread (iAttributeId, memtype, pstValue);
 +        if(status < 0)
 +        {
 +            return NULL;
 +        }
 +
 +        status = DynHDF5::dynH5Tclose(memtype);
 +        if(status < 0)
 +        {
 +            return NULL;
 +        }
 +
 +        status = DynHDF5::dynH5Sclose(iSpace);
 +        if(status < 0)
 +        {
 +            return NULL;
 +        }
 +
 +        status = DynHDF5::dynH5Tclose(iFileType);
 +        if(status < 0)
 +        {
 +            return NULL;
 +        }
 +
 +        status = DynHDF5::dynH5Aclose(iAttributeId);
 +        if(status < 0)
 +        {
 +            return NULL;
 +        }
 +    }
 +    return pstValue;
 +
 +}
 +
 +static int checkAttribute(int _iDatasetId, char* _pstAttribute, char* _pstValue)
 +{
 +    int iRet                = 0;
 +    char *pstScilabClass    = NULL;
 +
 +    pstScilabClass = readAttribute(_iDatasetId, _pstAttribute);
 +    if(pstScilabClass != NULL && strcmp(pstScilabClass, _pstValue) == 0)
 +    {
 +        iRet = 1;
 +    }
 +    if(pstScilabClass)
 +    {
 +        FREE(pstScilabClass);
 +    }
 +    return iRet;
 +}
 +
++/*
++** WARNING : this function returns an allocated value that must be freed.
++*/
++char* getScilabVersionAttribute(int _iFile)
++{
++    return readAttribute(_iFile, g_SCILAB_CLASS_SCI_VERSION);
++}
++
++int getSODFormatAttribute(int _iFile)
++{
++    return readIntAttribute(_iFile, g_SCILAB_CLASS_SOD_VERSION);
++}
++
 +int getDatasetDimension(int _iDatasetId, int* _piRows, int * _piCols)
 +{
 +    int iRet                = 0;
 +    int iDummy              = 0;
 +
 +
 +    *_piRows = readIntAttribute(_iDatasetId, g_SCILAB_CLASS_ROWS);
 +    *_piCols = readIntAttribute(_iDatasetId, g_SCILAB_CLASS_COLS);
 +
 +    return iRet;
 +}
 +
 +int getSparseDimension(int _iDatasetId, int* _piRows, int * _piCols, int* _piNbItem)
 +{
 +    int iRet                = 0;
 +    int iDummy              = 0;
 +
 +
 +    //get number of item in the sparse matrix
 +    getDatasetDims(_iDatasetId, _piRows, _piCols);
 +    *_piNbItem = readIntAttribute(_iDatasetId, g_SCILAB_CLASS_ITEMS);
 +
 +    return iRet;
 +}
 +
 +static int isEmptyDataset(int _iDatasetId)
 +{
 +    return checkAttribute(_iDatasetId, (char*)g_SCILAB_CLASS_EMPTY, "true");
 +}
 +
 +int isComplexData(int _iDatasetId)
 +{
 +    return checkAttribute(_iDatasetId, (char*)g_SCILAB_CLASS_COMPLEX, "true");
 +}
 +
 +int getDatasetPrecision(int _iDatasetId, int* _piPrec)
 +{
 +    int iRet                = 0;
 +    char* pstScilabClass    = readAttribute(_iDatasetId, g_SCILAB_CLASS_PREC);
 +
 +    if(pstScilabClass == NULL)
 +    {
 +        return -1;
 +    }
 +    else if(strcmp(pstScilabClass, "8") == 0)
 +    {
 +        *_piPrec    = SCI_INT8;
 +    }
 +    else if(strcmp(pstScilabClass, "u8") == 0)
 +    {
 +        *_piPrec    = SCI_UINT8;
 +    }
 +    else if(strcmp(pstScilabClass, "16") == 0)
 +    {
 +        *_piPrec = SCI_INT16;
 +    }
 +    else if(strcmp(pstScilabClass, "u16") == 0)
 +    {
 +        *_piPrec = SCI_UINT16;
 +    }
 +    else if(strcmp(pstScilabClass, "32") == 0)
 +    {
 +        *_piPrec = SCI_INT32;
 +    }
 +    else if(strcmp(pstScilabClass, "u32") == 0)
 +    {
 +        *_piPrec = SCI_UINT32;
 +    }
 +    else if(strcmp(pstScilabClass, "64") == 0)
 +    {
 +        *_piPrec = SCI_INT64;
 +    }
 +    else if(strcmp(pstScilabClass, "u64") == 0)
 +    {
 +        *_piPrec = SCI_UINT64;
 +    }
 +    else
 +    {
 +        iRet = 1;
 +    }
 +
 +    FREE(pstScilabClass);
 +    return iRet;
 +}
 +
 +int getVariableNames(int _iFile, char **pstNameList)
 +{
 +    hsize_t i           = 0;
 +    hsize_t iCount      = 0;
 +    herr_t status       = 0;
 +    int iNbItem         = 0;
 +
 +    status = DynHDF5::dynH5Gget_num_objs(_iFile, &iCount);
 +    if(status != 0)
 +    {
 +        return 0;
 +    }
 +
 +    for(i = 0 ; i < iCount ; i++)
 +    {
 +        if(DynHDF5::dynH5Gget_objtype_by_idx(_iFile, i) == H5G_DATASET)
 +        {
 +            if(pstNameList != NULL)
 +            {
 +                int iLen = 0;
 +                iLen = (int)DynHDF5::dynH5Gget_objname_by_idx(_iFile, i, NULL, iLen);
 +                pstNameList[iNbItem] = (char*)MALLOC(sizeof(char) * (iLen + 1)); //null terminated
 +                DynHDF5::dynH5Gget_objname_by_idx(_iFile, i, pstNameList[iNbItem], iLen + 1);
 +            }
 +            iNbItem++;
 +        }
 +    }
 +    return iNbItem;
 +}
 +
 +int getDataSetIdFromName(int _iFile, char *_pstName)
 +{
 +    return DynHDF5::dynH5Dopen(_iFile, _pstName);
 +}
 +
 +int getListDims(int _iDatasetId, int *_piItems)
 +{
 +    /*
 +    * Get dataspace and dimensions of the dataset. This is a
 +    * two dimensional dataset.
 +    */
 +    if(isEmptyDataset(_iDatasetId))
 +    {
 +        *_piItems = 0;
 +    }
 +    else
 +    {
 +        *_piItems = readIntAttribute(_iDatasetId, g_SCILAB_CLASS_ITEMS);
 +    }
 +    return 0;
 +}
 +
 +int getDatasetDims(int _iDatasetId, int *_piRows, int *_piCols)
 +{
 +    /*
 +    * Get dataspace and dimensions of the dataset. This is a
 +    * two dimensional dataset.
 +    */
 +    if(isEmptyDataset(_iDatasetId))
 +    {
 +        *_piCols = 0;
 +        *_piRows = 0;
 +    }
 +    else
 +    {
 +        *_piRows = readIntAttribute(_iDatasetId, g_SCILAB_CLASS_ROWS);
 +        *_piCols = readIntAttribute(_iDatasetId, g_SCILAB_CLASS_COLS);
 +    }
 +    return 0;
 +}
 +
 +int readDouble(int _iDatasetId, int _iRows, int _iCols, double *_pdblData)
 +{
 +    herr_t status;
 +
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread(_iDatasetId, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pdblData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int readDoubleMatrix(int _iDatasetId, int _iRows, int _iCols, double *_pdblData)
 +{
 +    herr_t status;
 +
 +    if(_iRows != 0 && _iCols != 0)
 +    {
 +        hid_t obj;
 +        hobj_ref_t *pRef = (hobj_ref_t *) MALLOC (1 * sizeof (hobj_ref_t));
 +
 +        //Read the data.
 +        status = DynHDF5::dynH5Dread (_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pRef);
 +
 +        //Open the referenced object, get its name and type.
 +        obj = DynHDF5::dynH5Rdereference (_iDatasetId, H5R_OBJECT, &pRef[0]);
 +        readDouble(obj,_iRows, _iCols, _pdblData);
 +        FREE(pRef);
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int readDoubleComplexMatrix(int _iDatasetId, int _iRows, int _iCols, double *_pdblReal, double *_pdblImg)
 +{
 +    hid_t obj;
 +    herr_t status;
 +    hobj_ref_t *pRef = (hobj_ref_t *) MALLOC (2 * sizeof (hobj_ref_t));
 +
 +    //Read the data.
 +    status = DynHDF5::dynH5Dread (_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pRef);
 +
 +    //Open the referenced object, get its name and type.
 +    obj = DynHDF5::dynH5Rdereference (_iDatasetId, H5R_OBJECT, &pRef[0]);
 +    status = readDouble(obj,_iRows, _iCols, _pdblReal);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    obj = DynHDF5::dynH5Rdereference (_iDatasetId, H5R_OBJECT, &pRef[1]);
 +    status = readDouble(obj,_iRows, _iCols, _pdblImg);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int readEmptyMatrix(int _iDatasetId)
 +{//close dataset
 +    herr_t status;
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int readBooleanMatrix(int _iDatasetId, int _iRows, int _iCols, int* _piData)
 +{
 +    herr_t status = 0;
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread(_iDatasetId, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +
 +static int readString(int _iDatasetId, char **_pstData)
 +{
 +    hid_t iFileType, memtype, iSpace;
 +    herr_t status;
 +    hsize_t dims[1];
 +    size_t iDim;
 +
 +    /*
 +    * Get the datatype and its size.
 +    */
 +    iFileType = DynHDF5::dynH5Dget_type (_iDatasetId);
 +    iDim = DynHDF5::dynH5Tget_size (iFileType);
 +    iDim++;                         /* Make room for null terminator */
 +
 +    /*
 +    * Get dataspace and allocate memory for read buffer.  This is a
 +    * two dimensional attribute so the dynamic allocation must be done
 +    * in steps.
 +    */
 +    iSpace = DynHDF5::dynH5Dget_space (_iDatasetId);
 +    if(iSpace< 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sget_simple_extent_dims (iSpace, dims, NULL);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    /*
 +    * Allocate space for string data.
 +    */
 +    *_pstData = (char *) MALLOC ( (size_t)((dims[0] * iDim + 1) * sizeof (char)));
 +
 +    /*
 +    * Create the memory datatype.
 +    */
 +    memtype = DynHDF5::dynH5Tcopy (H5T_C_S1);
 +    status = DynHDF5::dynH5Tset_size (memtype, iDim);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread (_iDatasetId, memtype, H5S_ALL, H5S_ALL, H5P_DEFAULT, *_pstData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Tclose(memtype);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose(iSpace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Tclose(iFileType);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int readStringMatrix(int _iDatasetId, int _iRows, int _iCols, char **_pstData)
 +{
 +    int i;
 +    herr_t status;
 +    hsize_t dims[1];
 +    hsize_t subdims[1]  = {1};
 +    hid_t space, memspace, filetype, memtype;
 +    size_t iDim;
 +    size_t iAllocSize   = 0;
 +
 +#ifdef TIME_DEBUG
 +    LARGE_INTEGER *piStart;
 +    LARGE_INTEGER *piEnd;
 +    LARGE_INTEGER iFreq;
 +
 +    QueryPerformanceFrequency(&iFreq);
 +
 +    piStart = (LARGE_INTEGER*)MALLOC(sizeof(LARGE_INTEGER) * (_iRows * _iCols + 1));
 +    piEnd   = (LARGE_INTEGER*)MALLOC(sizeof(LARGE_INTEGER) * (_iRows * _iCols + 1));
 +
 +    QueryPerformanceCounter(&piStart[0]);
 +#endif
 +
 +    /*
 +    * Get the datatype and its size.
 +    */
 +    filetype = DynHDF5::dynH5Dget_type (_iDatasetId);
 +    iDim = DynHDF5::dynH5Tget_size (filetype);
 +    iDim++;                         /* Make room for null terminator */
 +
 +
 +    /*create sub space*/
 +    memspace = DynHDF5::dynH5Screate_simple(1, subdims, NULL);
 +    if(memspace < 0)
 +    {
 +        return -1;
 +    }
 +
 +
 +    status = DynHDF5::dynH5Sget_simple_extent_dims (memspace, dims, NULL);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    space = DynHDF5::dynH5Dget_space (_iDatasetId);
 +    if(space < 0)
 +    {
 +        return -1;
 +    }
 +
 +
 +    /*
 +    * Create the memory datatype.
 +    */
 +    memtype = DynHDF5::dynH5Tcopy (H5T_C_S1);
 +    status = DynHDF5::dynH5Tset_size (memtype, iDim);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    /*
 +    * Allocate space for string data.
 +    */
 +    iAllocSize = (size_t)((iDim + 1) * sizeof (char));
 +    for (i = 0 ; i < _iRows * _iCols; i++)
 +    {
 +        _pstData[i] = (char *) MALLOC (iAllocSize);
 +    }
 +
 +    /*
 +    * Read the data.
 +    */
 +    for (i = 0 ; i < _iRows * _iCols; i++)
 +    {
 +        hsize_t start[1]={i};
 +        hsize_t count[1]={1};
 +#ifdef TIME_DEBUG
 +        QueryPerformanceCounter(&piStart[i+1]);
 +#endif
 +        status = DynHDF5::dynH5Sselect_hyperslab (space, H5S_SELECT_SET, start, NULL, count, NULL);
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +
 +        /*
 +        * Read the data.
 +        */
 +        status = DynHDF5::dynH5Dread (_iDatasetId, memtype, memspace, space, H5P_DEFAULT, _pstData[i]);
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +#ifdef TIME_DEBUG
 +        QueryPerformanceCounter(&piEnd[i+1]);
 +#endif
 +    }
 +
 +    status = DynHDF5::dynH5Sclose(space);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose(memspace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +
 +    status = DynHDF5::dynH5Tclose(filetype);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +#ifdef TIME_DEBUG
 +    QueryPerformanceCounter(&piEnd[0]);
 +
 +    //print debuf timer
 +    printf("\nGlobalTime : %0.3f ms\n", ((piEnd[0].QuadPart - piStart[0].QuadPart) * 1000.0) / iFreq.QuadPart);
 +    for (i = 0 ; i < _iRows * _iCols; i++)
 +    {
 +        double dblTime    =((piEnd[i+1].QuadPart - piStart[i+1].QuadPart) * 1000.0) / iFreq.QuadPart;
 +        printf("SubTime %d : %0.3f ms\n", i, dblTime);
 +    }
 +#endif
 +    return 0;
 +}
 +
 +static int readComplexPoly(int _iDatasetId, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
 +{
 +    int iRows   = 0;
 +    int iCols   = 0;
 +
 +    //Get the datatype and its size.
 +    getDatasetDims(_iDatasetId, &iRows, &iCols);
 +
 +    //Allocate space for string data.
 +    *_piNbCoef  = iRows * iCols;
 +    *_pdblReal  = (double*)MALLOC(*_piNbCoef * sizeof(double));
 +    *_pdblImg   = (double*)MALLOC(*_piNbCoef * sizeof(double));
 +
 +    //Read the data and return result.
 +    return readDoubleComplexMatrix(_iDatasetId, 1, *_piNbCoef, *_pdblReal, *_pdblImg);
 +}
 +
 +static int readPoly(int _iDatasetId, int* _piNbCoef, double** _pdblData)
 +{
 +    int iRows   = 0;
 +    int iCols   = 0;
 +
 +    //Get the datatype and its size.
 +    getDatasetDims(_iDatasetId, &iRows, &iCols);
 +
 +    *_piNbCoef  = iRows * iCols;
 +    *_pdblData  = (double*)MALLOC(*_piNbCoef * sizeof(double));
 +
 +    //Read the data and return result.
 +    return readDoubleMatrix(_iDatasetId, 1, *_piNbCoef, *_pdblData);
 +}
 +
 +int readCommonPolyMatrix(int _iDatasetId, char* _pstVarname, int _iComplex, int _iRows, int _iCols, int* _piNbCoef, double **_pdblReal, double **_pdblImg)
 +{
 +    int    i            = 0;
 +    hid_t obj           = 0;
 +    char* pstVarName    = 0;
 +    hobj_ref_t *pData   = (hobj_ref_t *)MALLOC(_iRows * _iCols * sizeof (hobj_ref_t));
 +    herr_t status;
 +
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread (_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    for (i = 0 ; i < _iRows * _iCols; i++)
 +    {
 +        /*
 +        * Open the referenced object, get its name and type.
 +        */
 +        obj = DynHDF5::dynH5Rdereference (_iDatasetId, H5R_OBJECT, &pData[i]);
 +        if(_iComplex)
 +        {
 +            status = readComplexPoly(obj, &_piNbCoef[i], &_pdblReal[i], &_pdblImg[i]);
 +        }
 +        else
 +        {
 +            status = readPoly(obj, &_piNbCoef[i], &_pdblReal[i]);
 +        }
 +
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +    }
 +
 +    pstVarName = readAttribute(_iDatasetId, g_SCILAB_CLASS_VARNAME);
 +    strcpy(_pstVarname, pstVarName);
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    FREE(pData);
 +    FREE(pstVarName);
 +
 +    return 0;
 +}
 +
 +int readPolyMatrix(int _iDatasetId, char* _pstVarname, int _iRows, int _iCols, int* _piNbCoef, double **_pdblData)
 +{
 +    return readCommonPolyMatrix(_iDatasetId, _pstVarname, 0, _iRows, _iCols, _piNbCoef, _pdblData, NULL);
 +}
 +
 +int readPolyComplexMatrix(int _iDatasetId, char* _pstVarname, int _iRows, int _iCols, int* _piNbCoef, double **_pdblReal, double **_pdblImg)
 +{
 +    return readCommonPolyMatrix(_iDatasetId, _pstVarname, 1, _iRows, _iCols, _piNbCoef, _pdblReal, _pdblImg);
 +}
 +
 +int readInteger8Matrix(int _iDatasetId, int _iRows, int _iCols, char* _pcData)
 +{
 +    herr_t status = 0;
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread(_iDatasetId, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pcData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int readInteger16Matrix(int _iDatasetId, int _iRows, int _iCols, short* _psData)
 +{
 +    herr_t status = 0;
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread(_iDatasetId, H5T_NATIVE_INT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _psData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int readInteger32Matrix(int _iDatasetId, int _iRows, int _iCols, int* _piData)
 +{
 +    herr_t status = 0;
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread(_iDatasetId, H5T_NATIVE_INT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int readInteger64Matrix(int _iDatasetId, int _iRows, int _iCols, long long* _pllData)
 +{
 +    herr_t status = 0;
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread(_iDatasetId, H5T_NATIVE_INT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pllData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int readUnsignedInteger8Matrix(int _iDatasetId, int _iRows, int _iCols, unsigned char* _pucData)
 +{
 +    herr_t status = 0;
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread(_iDatasetId, H5T_NATIVE_UINT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pucData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int readUnsignedInteger16Matrix(int _iDatasetId, int _iRows, int _iCols, unsigned short* _pusData)
 +{
 +    herr_t status = 0;
 +
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread(_iDatasetId, H5T_NATIVE_UINT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pusData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int readUnsignedInteger32Matrix(int _iDatasetId, int _iRows, int _iCols, unsigned int* _puiData)
 +{
 +    herr_t status = 0;
 +
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread(_iDatasetId, H5T_NATIVE_UINT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _puiData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int readUnsignedInteger64Matrix(int _iDatasetId, int _iRows, int _iCols, unsigned long long* _pullData)
 +{
 +    herr_t status = 0;
 +
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread(_iDatasetId, H5T_NATIVE_UINT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pullData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int readCommonSparseComplexMatrix(int _iDatasetId, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow,    int* _piColPos, double *_pdblReal, double *_pdblImg)
 +{
 +    hid_t obj           = 0;
 +    hobj_ref_t *pRef    = (hobj_ref_t *)MALLOC(3 * sizeof (hobj_ref_t));
 +    herr_t status;
 +
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread (_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pRef);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //read Row data
 +    obj = DynHDF5::dynH5Rdereference (_iDatasetId, H5R_OBJECT, &pRef[0]);
 +    status = readInteger32Matrix(obj, 1, _iRows, _piNbItemRow);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //read cols data
 +    obj = DynHDF5::dynH5Rdereference (_iDatasetId, H5R_OBJECT, &pRef[1]);
 +    status = readInteger32Matrix(obj, 1, _iNbItem, _piColPos);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //read sparse data
 +    obj = DynHDF5::dynH5Rdereference (_iDatasetId, H5R_OBJECT, &pRef[2]);
 +
 +    if(_iComplex)
 +    {
 +        status = readDoubleComplexMatrix(obj, 1, _iNbItem, _pdblReal, _pdblImg);
 +    }
 +    else
 +    {
 +        status = readDoubleMatrix(obj, 1, _iNbItem, _pdblReal);
 +    }
 +
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    FREE(pRef);
 +
 +    return 0;
 +}
 +
 +int readSparseMatrix(int _iDatasetId, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow,    int* _piColPos, double *_pdblReal)
 +{
 +    return readCommonSparseComplexMatrix(_iDatasetId, 0, _iRows, _iCols, _iNbItem, _piNbItemRow,    _piColPos, _pdblReal, NULL);
 +}
 +
 +int readSparseComplexMatrix(int _iDatasetId, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow,    int* _piColPos, double *_pdblReal, double *_pdblImg)
 +{
 +    return readCommonSparseComplexMatrix(_iDatasetId, 1, _iRows, _iCols, _iNbItem, _piNbItemRow,    _piColPos, _pdblReal, _pdblImg);
 +}
 +
 +int readBooleanSparseMatrix(int _iDatasetId, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow,    int* _piColPos)
 +{
 +    hid_t obj           = 0;
 +    hobj_ref_t *pRef    = (hobj_ref_t *)MALLOC(2 * sizeof (hobj_ref_t));
 +    herr_t status;
 +
 +    /*
 +    * Read the data.
 +    */
 +    status = DynHDF5::dynH5Dread (_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pRef);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //read Row data
 +    obj = DynHDF5::dynH5Rdereference (_iDatasetId, H5R_OBJECT, &pRef[0]);
 +    status = readInteger32Matrix(obj, 1, _iRows, _piNbItemRow);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //read cols data
 +    obj = DynHDF5::dynH5Rdereference (_iDatasetId, H5R_OBJECT, &pRef[1]);
 +    status = readInteger32Matrix(obj, 1, _iNbItem, _piColPos);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    FREE(pRef);
 +
 +    return 0;
 +}
 +
 +int getScilabTypeFromDataSet(int _iDatasetId)
 +{
 +    int iVarType            = 0;
 +    char *pstScilabClass    = readAttribute(_iDatasetId, g_SCILAB_CLASS);
 +
 +    if(pstScilabClass == NULL)
 +    {
 +        return unknow_type;
 +    }
 +    /* HDF5 Float type + SCILAB_Class = double <=> double */
 +    if(strcmp(pstScilabClass, g_SCILAB_CLASS_DOUBLE) == 0)
 +    {
 +        iVarType = sci_matrix;
 +    }
 +    else if(strcmp(pstScilabClass, g_SCILAB_CLASS_STRING) == 0)
 +    {
 +        iVarType = sci_strings;
 +    }
 +    else if(strcmp(pstScilabClass, g_SCILAB_CLASS_BOOLEAN) == 0)
 +    {
 +        iVarType = sci_boolean;
 +    }
 +    else if(strcmp(pstScilabClass, g_SCILAB_CLASS_BOOLEAN) == 0)
 +    {
 +        iVarType = sci_boolean;
 +    }
 +    else if(strcmp(pstScilabClass, g_SCILAB_CLASS_POLY) == 0)
 +    {
 +        iVarType = sci_poly;
 +    }
 +    else if(strcmp(pstScilabClass, g_SCILAB_CLASS_INT) == 0)
 +    {
 +        iVarType = sci_ints;
 +    }
 +    else if(strcmp(pstScilabClass, g_SCILAB_CLASS_SPARSE) == 0)
 +    {
 +        iVarType = sci_sparse;
 +    }
 +    else if(strcmp(pstScilabClass, g_SCILAB_CLASS_BSPARSE) == 0)
 +    {
 +        iVarType = sci_boolean_sparse;
 +    }
 +    else if(strcmp(pstScilabClass, g_SCILAB_CLASS_LIST) == 0)
 +    {
 +        iVarType = sci_list;
 +    }
 +    else if(strcmp(pstScilabClass, g_SCILAB_CLASS_TLIST) == 0)
 +    {
 +        iVarType = sci_tlist;
 +    }
 +    else if(strcmp(pstScilabClass, g_SCILAB_CLASS_MLIST) == 0)
 +    {
 +        iVarType = sci_mlist;
 +    }
 +    else if(strcmp(pstScilabClass, g_SCILAB_CLASS_VOID) == 0)
 +    {
 +        iVarType = sci_void;
 +    }
 +    else if(strcmp(pstScilabClass, g_SCILAB_CLASS_UNDEFINED) == 0)
 +    {
 +        iVarType = sci_undefined;
 +    }
 +
 +    if(iVarType == 0)
 +    {
 +        return 0;
 +    }
 +    FREE(pstScilabClass);
 +    return iVarType;
 +}
 +
 +
 +int getListItemReferences(int _iDatasetId, hobj_ref_t** _piItemRef)
 +{
 +    int iItem       = 0;
 +    herr_t status   = 0;
 +
 +    getListDims(_iDatasetId, &iItem);
 +
 +    *_piItemRef = (hobj_ref_t *) MALLOC (iItem * sizeof (hobj_ref_t));
 +
 +    status = DynHDF5::dynH5Dread (_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, *_piItemRef);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int getListItemDataset(int _iDatasetId, void* _piItemRef, int _iItemPos, int* _piItemDataset)
 +{
 +    hobj_ref_t poRef    = ((hobj_ref_t*)_piItemRef)[_iItemPos];
 +    *_piItemDataset     = DynHDF5::dynH5Rdereference (_iDatasetId, H5R_OBJECT, &poRef);
 +
 +    if(*_piItemDataset == 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int deleteListItemReferences(int _iDatasetId, void* _piItemRef)
 +{
 +    herr_t status;
 +    if(_piItemRef)
 +    {
 +        hobj_ref_t *poRef    = (hobj_ref_t*)_piItemRef;
 +        FREE(poRef);
 +    }
 +
 +    status = DynHDF5::dynH5Dclose(_iDatasetId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
index 8db99f9,0000000..52a8503
mode 100644,000000..100644
--- /dev/null
@@@ -1,2068 -1,0 +1,2118 @@@
 +/*
 +*  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 +*  Copyright (C) 2009-2009 - DIGITEO - Bruno JOFRET
 +*
 +*  This file must be used under the terms of the CeCILL.
 +*  This source file is licensed as described in the file COPYING, which
 +*  you should have received as part of this distribution.  The terms
 +*  are also available at
 +*  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 +*
 +*/
 +
 +#define H5_USE_16_API
 +
 +#include "dynhdf5.hxx"
 +
 +extern "C"
 +{
 +#include <MALLOC.h>
 +#include <math.h>
 +#include <string.h>
 +#include "sci_types.h"
 +#include "core_math.h"
 +#include "h5_writeDataToFile.h"
 +#include "h5_attributeConstants.h"
++#include "h5_readDataFromFile.h"
++#include "version.h"
 +}
 +
 +static hid_t enableCompression(int _iLevel, int _iRank, const hsize_t* _piDims)
 +{
 +    hid_t iRet  = 0;
 +    int iLevel  = _iLevel;
 +
 +    return H5P_DEFAULT;
 +/*
 +  if(iLevel < 0)
 +    {
 +        iLevel = 0;
 +    }
 +
 +  if(iLevel > 9)
 +    {
 +        iLevel = 9;
 +    }
 +
 +    if(iLevel)
 +    {
 +        iRet = DynHDF5::dynH5Pcreate(H5P_DATASET_CREATE);
 +        if(iRet < 0)
 +        {
 +            iRet = 0;
 +        }
 +        else
 +        {
 +            if(H5Pset_layout(iRet,H5D_COMPACT)<0)
 +            {
 +                DynHDF5::dynH5Pclose(iRet);
 +                iRet = 0;
 +            }
 +            else
 +            {
 +                if(H5Pset_chunk(iRet,_iRank, _piDims)<0)
 +                {
 +                    DynHDF5::dynH5Pclose(iRet);
 +                    iRet = 0;
 +                }
 +                else
 +                {
 +                    if(H5Pset_deflate(iRet,iLevel)<0)
 +                    {
 +                        DynHDF5::dynH5Pclose(iRet);
 +                        iRet = 0;
 +                    }
 +                }
 +            }
 +        }
 +    }
 +    else
 +    {
 +        iRet = DynHDF5::dynH5Pcopy(H5P_DEFAULT);
 +    }
 +    return iRet;
 +*/
 +}
 +
 +static herr_t addIntAttribute(int _iDatasetId, const char *_pstName, const int _iVal)
 +{
 +    hsize_t attributeDims[1] = {1};
 +    hid_t attributeTypeId, attributeSpace;
 +    herr_t status;
 +
 +    //Create attribute dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    attributeSpace = DynHDF5::dynH5Screate_simple (1, attributeDims, NULL);
 +
 +    //Create the attribute and write it.
 +    attributeTypeId = DynHDF5::dynH5Acreate (_iDatasetId, _pstName, H5T_NATIVE_INT, attributeSpace, H5P_DEFAULT);
 +    if(attributeTypeId < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Awrite (attributeTypeId, H5T_NATIVE_INT, &_iVal);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Aclose (attributeTypeId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (attributeSpace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +static herr_t addAttribute(int _iDatasetId, const char *_pstName, const char *_pstValue)
 +{
 +    hsize_t attributeDims[1] = {1};
 +    hid_t attributeTypeId, attributeSpace, attr;
 +    herr_t status;
 +
 +    //Create attribute dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    attributeSpace = DynHDF5::dynH5Screate_simple (1, attributeDims, NULL);
 +
 +    //Create special attribute type
 +    attributeTypeId = DynHDF5::dynH5Tcopy(H5T_C_S1);
 +    status = DynHDF5::dynH5Tset_size(attributeTypeId, strlen(_pstValue));
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create the attribute and write it.
 +    attr = DynHDF5::dynH5Acreate (_iDatasetId, _pstName, attributeTypeId, attributeSpace, H5P_DEFAULT);
 +    if(attr < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Awrite (attr, attributeTypeId, _pstValue);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Aclose (attr);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Tclose (attributeTypeId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
++int updateScilabVersion(int _iFile)
++{
++    herr_t status;
++    //try to read attribute
++    char* pstScilabVersion = getScilabVersionAttribute(_iFile);
++    if (pstScilabVersion)
++    {
++        //delete before write
++        status = H5Adelete(_iFile, g_SCILAB_CLASS_SCI_VERSION);
++        if (status < 0)
++        {
++            return -1;
++        }
++    }
++
++    if (strstr(SCI_VERSION_STRING, "branch"))
++    {
++        //compiled by user
++        char pstVersion[64];
++        sprintf(pstVersion, "%s %d.%d.%d", SCI_VERSION_STRING, SCI_VERSION_MAJOR, SCI_VERSION_MINOR, SCI_VERSION_MAINTENANCE);
++        status = addAttribute(_iFile, g_SCILAB_CLASS_SCI_VERSION, pstVersion);
++    }
++    else
++    {
++        //compiled by compilation chain
++        status = addAttribute(_iFile, g_SCILAB_CLASS_SCI_VERSION, SCI_VERSION_STRING);
++    }
++
++    return status;
++}
++
++int updateFileVersion(int _iFile)
++{
++    herr_t status;
++    //try to read attribute
++    int iHdf5Version = getSODFormatAttribute(_iFile);
++    if (iHdf5Version != -1)
++    {
++        status = H5Adelete(_iFile, g_SCILAB_CLASS_SOD_VERSION);
++        if (status < 0)
++        {
++            return -1;
++        }
++    }
++
++    return addIntAttribute(_iFile, g_SCILAB_CLASS_SOD_VERSION, SOD_FILE_VERSION);
++}
++
 +static int writeString(int _iFile, char* _pstDatasetName, char *_pstData)
 +{
 +    hsize_t dims[1] = {1};
 +    hid_t typeId, space, dset;
 +    herr_t status;
 +    hid_t iCompress;
 +
 +    //Create string dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    space = DynHDF5::dynH5Screate_simple (1, dims, NULL);
 +    if(space < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create special string type
 +    typeId = DynHDF5::dynH5Tcopy(H5T_C_S1);
 +    if(strlen(_pstData) > 0)
 +    {
 +        status = DynHDF5::dynH5Tset_size(typeId, strlen(_pstData));
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +    }
 +
 +    //Create the data set and write it.
 +    iCompress = enableCompression(9, 1, dims);
 +    dset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, typeId, space, iCompress);
 +    if(dset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite (dset, typeId, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pstData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = string to dataset
 +    status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_STRING);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose(dset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Tclose(typeId);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose(space);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int writeStringMatrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, char **data)
 +{
 +    int i;
 +    hsize_t dims[1] = {_iRows * _iCols};
 +    hsize_t subdims[1] = {1};
 +    hid_t typeId, space, dset, memspace;
 +    herr_t status;
 +    hid_t iCompress;
 +    size_t iMaxLen = 0;
 +    char* pstDataTemp = NULL;
 +
 +    for(i = 0 ; i < _iRows * _iCols ; i++)
 +    {
 +        iMaxLen = Max(iMaxLen, strlen(data[i]));
 +    }
 +
 +    //Create string dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    space = DynHDF5::dynH5Screate_simple (1, dims, NULL);
 +    if(space < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create special string type
 +    typeId = DynHDF5::dynH5Tcopy(H5T_C_S1);
 +
 +    /* Bug 6474 */
 +    /* we allocate datas in fixed length string */
 +    /* workaround for memcpy in hdf5 with wrong size */
 +    pstDataTemp = (char*)MALLOC(sizeof(char) * (iMaxLen + 1));
 +
 +    if(iMaxLen > 0)
 +    {
 +        status = DynHDF5::dynH5Tset_size(typeId,iMaxLen);
 +        if(status < 0)
 +        {
 +            FREE(pstDataTemp);
 +            return -1;
 +        }
 +    }
 +
 +    //Create the data set and write it.
 +    iCompress = enableCompression(9, 1, dims);
 +    dset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, typeId, space, iCompress);
 +    if(dset < 0)
 +    {
 +        FREE(pstDataTemp);
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose(space);
 +    if(status < 0)
 +    {
 +        FREE(pstDataTemp);
 +        return -1;
 +    }
 +
 +
 +
 +    for(i = 0 ; i < _iRows * _iCols ; i++)
 +    {
 +        hsize_t start[1]={i};
 +        hsize_t count[1]={1};
 +
 +        strcpy(pstDataTemp, data[i]);
 +
 +        space = DynHDF5::dynH5Dget_space(dset);
 +        if(space < 0)
 +        {
 +            FREE(pstDataTemp);
 +            return -1;
 +        }
 +
 +        status = DynHDF5::dynH5Sselect_hyperslab (space, H5S_SELECT_SET, start, NULL, count, NULL);
 +        if(status < 0)
 +        {
 +            FREE(pstDataTemp);
 +            return -1;
 +        }
 +
 +        /*create sub space*/
 +        memspace = DynHDF5::dynH5Screate_simple(1, subdims, NULL);
 +        if(memspace < 0)
 +        {
 +            FREE(pstDataTemp);
 +            return -1;
 +        }
 +
 +        status = DynHDF5::dynH5Dwrite (dset, typeId, memspace, space, H5P_DEFAULT, pstDataTemp);
 +
 +        if(status < 0)
 +        {
 +            FREE(pstDataTemp);
 +            return -1;
 +        }
 +
 +        status=DynHDF5::dynH5Sclose(space);
 +        if(status < 0)
 +        {
 +            FREE(pstDataTemp);
 +            return -1;
 +        }
 +
 +        status=DynHDF5::dynH5Sclose(memspace);
 +        if(status < 0)
 +        {
 +            FREE(pstDataTemp);
 +            return -1;
 +        }
 +
 +    }
 +
 +    //Add attribute SCILAB_Class = string to dataset
 +    status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_STRING);
 +    if(status < 0)
 +    {
 +        FREE(pstDataTemp);
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_rows = _iRows
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        FREE(pstDataTemp);
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_cols = _iCols
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        FREE(pstDataTemp);
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose(dset);
 +    if(status < 0)
 +    {
 +        FREE(pstDataTemp);
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Tclose(typeId);
 +    if(status < 0)
 +    {
 +        FREE(pstDataTemp);
 +        return -1;
 +    }
 +
 +    FREE(pstDataTemp);
 +
 +    return 0;
 +}
 +
 +char* createGroupName(char* _pstGroupName)
 +{
 +    char* pstSlash      = NULL;
 +    char* pstGroupName  = (char *)MALLOC((strlen(_pstGroupName) + 3) * sizeof(char));
 +    // Generate groupname #<dataSetName>#
 +    sprintf(pstGroupName, "#%s#", _pstGroupName);
 +    pstSlash            = strstr(pstGroupName, "/");
 +    if(pstSlash != NULL)
 +    {
 +        pstSlash[0]     = '_';
 +    }
 +
 +    return pstGroupName;
 +}
 +
 +char* createPathName(char* _pstGroupName, int _iIndex)
 +{
 +    char* pstName       = NULL;
 +    char* pstPathName   = NULL;
 +
 +    pstName             = (char*)MALLOC(((int)log10((double)(_iIndex + 1)) + 3) * sizeof(char));
 +    //1 for null termination, 2 for '#' characters
 +    sprintf(pstName, "#%d#", _iIndex);
 +
 +    pstPathName         = (char*)MALLOC((strlen(_pstGroupName) + strlen(pstName) + 2) * sizeof(char));
 +    //1 for null termination, 1 for separator, 2 for '#' characters
 +    sprintf(pstPathName, "%s/%s", _pstGroupName, pstName);
 +    return pstPathName;
 +}
 +
 +int writeVoid(int _iFile, char* _pstDatasetName)
 +{
 +    hsize_t piDims[1]   = {1};
 +    herr_t status       = 0;
 +    hid_t iSpace        = 0;
 +    hid_t iDataset      = 0;
 +    hid_t iCompress     = 0;
 +    char cData          = 0;
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    iSpace = DynHDF5::dynH5Screate_simple (1, piDims, NULL);
 +    if(iSpace < 0)
 +    {
 +        return -1;
 +    }
 +    //Create the dataset and write the array data to it.
 +    iCompress    = enableCompression(9, 1, piDims);
 +    iDataset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress);
 +    if(iDataset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite (iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, &cData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = double to dataset
 +    status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_VOID);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose (iDataset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (iSpace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int writeUndefined(int _iFile, char* _pstDatasetName)
 +{
 +    hsize_t piDims[1]   = {1};
 +    herr_t status       = 0;
 +    hid_t iSpace        = 0;
 +    hid_t iDataset      = 0;
 +    hid_t iCompress     = 0;
 +    char cData          = 0;
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    iSpace = DynHDF5::dynH5Screate_simple (1, piDims, NULL);
 +    if(iSpace < 0)
 +    {
 +        return -1;
 +    }
 +    //Create the dataset and write the array data to it.
 +    iCompress = enableCompression(9, 1, piDims);
 +    iDataset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress);
 +    if(iDataset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite (iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, &cData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = double to dataset
 +    status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_UNDEFINED);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose (iDataset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (iSpace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +static hobj_ref_t writeCommomDoubleMatrix(int _iFile, char* _pstGroupName, char* _pstDatasetName, int _iIndex, int _iRows, int _iCols, double *_pdblData)
 +{
 +    hid_t space;
 +    hid_t dset;
 +    hid_t iCompress     = 0;
 +    hsize_t dims[1]     = {_iRows * _iCols};
 +    herr_t status       = 0;
 +    hobj_ref_t iRef     = 0;
 +
 +    char* pstPathName   = NULL;
 +
 +    //createGroupe and dataset name
 +    pstPathName         = createPathName(_pstGroupName, _iIndex);
 +
 +    if(_iRows * _iCols == 0)
 +    {
 +        double dblZero = 0;
 +        //tips for empty double matrix
 +
 +        //Create dataspace.  Setting maximum size to NULL sets the maximum
 +        //size to be the current size.
 +        dims[0] = 1;
 +
 +        space = DynHDF5::dynH5Screate_simple (1, dims, NULL);
 +        if(space < 0)
 +        {
 +            return (hobj_ref_t)(-1);
 +        }
 +
 +        //Create the dataset and write the array data to it.
 +        iCompress = enableCompression(9, 1, dims);
 +        dset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, H5T_NATIVE_DOUBLE, space, iCompress);
 +        if(dset < 0)
 +        {
 +            return (hobj_ref_t)(-1);
 +        }
 +
 +        status = DynHDF5::dynH5Dwrite (dset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, &dblZero);
 +        if(status < 0)
 +        {
 +            return (hobj_ref_t)(-1);
 +        }
 +
 +        //Add attribute SCILAB_Class = double to dataset
 +        status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
 +        if(status < 0)
 +        {
 +            return (hobj_ref_t)(-1);
 +        }
 +
 +        status = addAttribute(dset, g_SCILAB_CLASS_EMPTY, "true");
 +        if(status < 0)
 +        {
 +            return (hobj_ref_t)(-1);
 +        }
 +    }
 +    else
 +    {
 +        //Create dataspace.  Setting maximum size to NULL sets the maximum
 +        //size to be the current size.
 +        space = DynHDF5::dynH5Screate_simple (1, dims, NULL);
 +        if(space < 0)
 +        {
 +            return (hobj_ref_t)(-1);
 +        }
 +
 +        //Create the dataset and write the array data to it.
 +        iCompress = enableCompression(9, 1, dims);
 +        dset = DynHDF5::dynH5Dcreate (_iFile, pstPathName, H5T_NATIVE_DOUBLE, space, iCompress);
 +        if(dset < 0)
 +        {
 +            return (hobj_ref_t)(-1);
 +        }
 +
 +        status = DynHDF5::dynH5Dwrite (dset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pdblData);
 +        if(status < 0)
 +        {
 +            return (hobj_ref_t)(-1);
 +        }
 +
 +        //Add attribute SCILAB_Class = double to dataset
 +        status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
 +        if(status < 0)
 +        {
 +            return (hobj_ref_t)(-1);
 +        }
 +
 +        //Add attribute SCILAB_Class_rows = double to dataset
 +        status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
 +        if(status < 0)
 +        {
 +            return (hobj_ref_t)(-1);
 +        }
 +
 +        //Add attribute SCILAB_Class_cols = double to dataset
 +        status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
 +        if(status < 0)
 +        {
 +            return (hobj_ref_t)(-1);
 +        }
 +
 +        // create the ref
 +        status = DynHDF5::dynH5Rcreate (&iRef, _iFile, pstPathName, H5R_OBJECT, -1);
 +        if(status < 0)
 +        {
 +            return (hobj_ref_t)(-1);
 +        }
 +    }
 +
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose (dset);
 +    if(status < 0)
 +    {
 +        return (hobj_ref_t)(-1);
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (space);
 +    if(status < 0)
 +    {
 +        return (hobj_ref_t)(-1);
 +    }
 +
 +    FREE(pstPathName);
 +
 +    return iRef;
 +}
 +
 +int writeDoubleMatrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, double *_pdblData)
 +{
 +    hid_t space         = 0;
 +    hid_t dset          = 0;
 +    herr_t status       = 0;
 +    hsize_t dims[1]     = {1};
 +    hid_t iCompress     = 0;
 +    hobj_ref_t pRef[1]  = {0};
 +
 +    hid_t group         = 0;
 +    char* pstGroupName  = NULL;
 +    pstGroupName        = createGroupName(_pstDatasetName);
 +
 +    //create sub group only for non empty matrix
 +    if(_iRows * _iCols != 0)
 +    {
 +        group   = DynHDF5::dynH5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
 +        status  = DynHDF5::dynH5Gclose(group);
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +    }
 +
 +    pRef[0] = writeCommomDoubleMatrix(_iFile, pstGroupName, _pstDatasetName, 0, _iRows, _iCols, _pdblData);
 +
 +    //don't create reference for empty matrix
 +    if(_iRows * _iCols == 0)
 +    {
 +        return 0;
 +    }
 +
 +    if(pRef[0] == 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    space = DynHDF5::dynH5Screate_simple(1, dims, NULL);
 +    if(space < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create the dataset and write the array data to it.
 +    iCompress   = enableCompression(9, 1, dims);
 +    dset        = DynHDF5::dynH5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
 +    if(dset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pRef);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = double to dataset
 +    status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_rows = double to dataset
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_cols = double to dataset
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose(dset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose(space);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    FREE(pstGroupName);
 +    return status;
 +}
 +
 +
 +
 +int writeDoubleComplexMatrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, double *_pdblReal, double *_pdblImg)
 +{
 +    hid_t space         = 0;
 +    hid_t dset          = 0;
 +    herr_t status       = 0;
 +    hid_t iCompress     = 0;
 +    hsize_t dims[1]     = {2};
 +    hobj_ref_t pRef[2]  = {0};
 +
 +    hid_t group         = 0;
 +    char* pstGroupName  = NULL;
 +    pstGroupName        = createGroupName(_pstDatasetName);
 +    group               = DynHDF5::dynH5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
 +    status              = DynHDF5::dynH5Gclose(group);
 +
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    pRef[0] = writeCommomDoubleMatrix(_iFile, pstGroupName, _pstDatasetName, 0, _iRows, _iCols, _pdblReal);
 +    pRef[1] = writeCommomDoubleMatrix(_iFile, pstGroupName, _pstDatasetName, 1, _iRows, _iCols, _pdblImg);
 +    if(pRef[0] == 0 || pRef[1] == 0)
 +    {
 +        return 1;
 +    }
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    space = DynHDF5::dynH5Screate_simple(1, dims, NULL);
 +    if(space < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create the dataset and write the array data to it.
 +    iCompress   = enableCompression(9, 1, dims);
 +    dset        = DynHDF5::dynH5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
 +    if(dset < 0)
 +    {
 +        printf("\nH5Dcreate\n");
 +        return -1;
 +    }
 +    status = DynHDF5::dynH5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pRef);
 +    if(status < 0)
 +    {
 +        printf("\nH5Dwrite\n");
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = double to dataset
 +    status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_rows = double to dataset
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_cols = double to dataset
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose(dset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose(space);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    FREE(pstGroupName);
 +    return 0;
 +}
 +
 +int writeBooleanMatrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, int *_piData)
 +{
 +    hsize_t piDims[1] = {_iRows * _iCols};
 +    herr_t status;
 +    hid_t iSpace;
 +    hid_t    iCompress;
 +    hid_t iDataset;
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    iSpace = DynHDF5::dynH5Screate_simple (1, piDims, NULL);
 +    if(iSpace < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create the dataset and write the array data to it.
 +    iCompress    = enableCompression(9, 1, piDims);
 +    iDataset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, H5T_NATIVE_INT, iSpace, iCompress);
 +    if(iDataset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite (iDataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = double to dataset
 +    status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_BOOLEAN);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_rows = double to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_cols = double to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose (iDataset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (iSpace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +static int writeCommonPolyMatrix(int _iFile, char* _pstDatasetName, char* _pstVarName, int _iComplex, int _iRows, int _iCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
 +{
 +    int i               = 0;
 +    hsize_t dims[1]     = {_iRows * _iCols};
 +    herr_t status       = 0;
 +    hid_t space         = 0;
 +    hid_t dset          = 0;
 +    hid_t group         = 0;
 +    hid_t iCompress     = 0;
 +    hobj_ref_t* pData   = 0;
 +
 +    char* pstName       = NULL;
 +    char* pstPathName   = NULL;
 +
 +    char* pstGroupName  = NULL;
 +
 +
 +    // Create ref matrix
 +    pData = (hobj_ref_t *)MALLOC(_iRows * _iCols * sizeof(hobj_ref_t));
 +
 +    // Generate groupname #<dataSetName>#
 +    pstGroupName = createGroupName(_pstDatasetName);
 +
 +    //First create a group to store all referenced objects.
 +    group = DynHDF5::dynH5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
 +    status = DynHDF5::dynH5Gclose(group);
 +
 +    //Now create each String as a dedicated DataSet.
 +    for (i = 0 ; i < _iRows * _iCols; i++)
 +    {
 +        pstPathName = createPathName(pstGroupName, i);
 +
 +        // Write the string to ref
 +        if(_iComplex)
 +        {
 +            status = writeDoubleComplexMatrix(_iFile, pstPathName, 1, _piNbCoef[i], _pdblReal[i], _pdblImg[i] );
 +        }
 +        else
 +        {
 +            status = writeDoubleMatrix(_iFile, pstPathName, 1, _piNbCoef[i],  _pdblReal[i]);
 +        }
 +
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +        // create the ref
 +        status = DynHDF5::dynH5Rcreate(&pData[i], _iFile, pstPathName, H5R_OBJECT, -1);
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +
 +        FREE(pstName);
 +        FREE(pstPathName);
 +    }
 +
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    space = DynHDF5::dynH5Screate_simple(1, dims, NULL);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create the dataset and write the array data to it.
 +    iCompress = enableCompression(9, 1, dims);
 +    dset = DynHDF5::dynH5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
 +    if(dset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +    //Add attribute SCILAB_Class = poly to dataset
 +    status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_POLY);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute Varname attribute to dataset
 +    status = addAttribute(dset, g_SCILAB_CLASS_VARNAME, _pstVarName);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    if(_iComplex)
 +    {
 +        //Add attribute Varname attribute to dataset
 +        status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +    }
 +
 +    //Add attribute SCILAB_Class_rows = double to dataset
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_cols = double to dataset
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose(dset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose(space);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    FREE(pstGroupName);
 +    FREE(pData);
 +
 +    return 0;
 +}
 +
 +int writePolyMatrix(int _iFile, char* _pstDatasetName, char* _pstVarName, int _iRows, int _iCols, int* _piNbCoef, double** _pdblReal)
 +{
 +    return writeCommonPolyMatrix(_iFile, _pstDatasetName, _pstVarName, 0, _iRows, _iCols, _piNbCoef, _pdblReal, NULL);
 +}
 +
 +int writePolyComplexMatrix(int _iFile, char* _pstDatasetName, char* _pstVarName, int _iRows, int _iCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
 +{
 +    return writeCommonPolyMatrix(_iFile, _pstDatasetName, _pstVarName, 1, _iRows, _iCols, _piNbCoef, _pdblReal, _pdblImg);
 +}
 +
 +int writeInteger8Matrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, char* _pcData)
 +{
 +    hsize_t piDims[1]   = {_iRows * _iCols};
 +    herr_t status       = 0;
 +    hid_t iSpace        = 0;
 +    hid_t iDataset      = 0;
 +    hid_t iCompress     = 0;
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    iSpace = DynHDF5::dynH5Screate_simple (1, piDims, NULL);
 +    if(iSpace < 0)
 +    {
 +        return -1;
 +    }
 +    //Create the dataset and write the array data to it.
 +    iCompress = enableCompression(9, 1, piDims);
 +    iDataset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress);
 +    if(iDataset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite (iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pcData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = double to dataset
 +    status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "8");
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_rows to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_cols to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose (iDataset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (iSpace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int writeInteger16Matrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, short* _psData)
 +{
 +    hsize_t piDims[1]   = {_iRows * _iCols};
 +    herr_t status       = 0;
 +    hid_t iSpace        = 0;
 +    hid_t iDataset      = 0;
 +    hid_t iCompress     = 0;
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    iSpace = DynHDF5::dynH5Screate_simple (1, piDims, NULL);
 +    if(iSpace < 0)
 +    {
 +        return -1;
 +    }
 +    //Create the dataset and write the array data to it.
 +    iCompress = enableCompression(9, 1, piDims);
 +    iDataset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, H5T_NATIVE_INT16, iSpace, iCompress);
 +    if(iDataset < 0)
 +    {
 +        return -1;
 +    }
 +    status = DynHDF5::dynH5Dwrite (iDataset, H5T_NATIVE_INT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _psData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = double to dataset
 +    status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "16");
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_rows to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_cols to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose (iDataset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (iSpace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int writeInteger32Matrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, int* _piData)
 +{
 +    hsize_t piDims[1]   = {_iRows * _iCols};
 +    herr_t status       = 0;
 +    hid_t iSpace        = 0;
 +    hid_t iDataset      = 0;
 +    hid_t iCompress     = 0;
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    iSpace = DynHDF5::dynH5Screate_simple (1, piDims, NULL);
 +    if(iSpace < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create the dataset and write the array data to it.
 +    iCompress = enableCompression(9, 1, piDims);
 +    iDataset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, H5T_NATIVE_INT32, iSpace, iCompress);
 +    if(iDataset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite (iDataset, H5T_NATIVE_INT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = double to dataset
 +    status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "32");
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_rows to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_cols to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose (iDataset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (iSpace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int writeInteger64Matrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, long long* _pllData)
 +{
 +    hsize_t piDims[1]   = {_iRows * _iCols};
 +    herr_t status       = 0;
 +    hid_t iSpace        = 0;
 +    hid_t iDataset      = 0;
 +    hid_t iCompress     = 0;
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    iSpace = DynHDF5::dynH5Screate_simple (1, piDims, NULL);
 +    if(iSpace < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create the dataset and write the array data to it.
 +    iCompress = enableCompression(9, 1, piDims);
 +    iDataset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, H5T_NATIVE_INT64, iSpace, iCompress);
 +    if(iDataset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite (iDataset, H5T_NATIVE_INT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pllData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = double to dataset
 +    status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "64");
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_rows to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_cols to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose (iDataset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (iSpace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +HDF5_SCILAB_IMPEXP int writeUnsignedInteger8Matrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, unsigned char* _pucData)
 +{
 +    hsize_t piDims[1]   = {_iRows * _iCols};
 +    herr_t status       = 0;
 +    hid_t iSpace        = 0;
 +    hid_t iDataset      = 0;
 +    hid_t iCompress     = 0;
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    iSpace = DynHDF5::dynH5Screate_simple (1, piDims, NULL);
 +    if(iSpace < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create the dataset and write the array data to it.
 +    iCompress    = enableCompression(9, 1, piDims);
 +    iDataset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, H5T_NATIVE_UINT8, iSpace, iCompress);
 +    if(iDataset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite (iDataset, H5T_NATIVE_UINT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pucData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = double to dataset
 +    status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u8");
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_rows to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_cols to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose (iDataset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (iSpace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +HDF5_SCILAB_IMPEXP int writeUnsignedInteger16Matrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, unsigned short* _pusData)
 +{
 +    hsize_t piDims[1]   = {_iRows * _iCols};
 +    herr_t status       = 0;
 +    hid_t iSpace        = 0;
 +    hid_t iDataset      = 0;
 +    hid_t iCompress     = 0;
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    iSpace = DynHDF5::dynH5Screate_simple (1, piDims, NULL);
 +    if(iSpace < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create the dataset and write the array data to it.
 +    iCompress    = enableCompression(9, 1, piDims);
 +    iDataset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, H5T_NATIVE_UINT16, iSpace, iCompress);
 +    if(iDataset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite (iDataset, H5T_NATIVE_UINT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pusData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = double to dataset
 +    status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u16");
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_rows to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_cols to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose (iDataset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (iSpace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +HDF5_SCILAB_IMPEXP int writeUnsignedInteger32Matrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, unsigned int* _puiData)
 +{
 +    hsize_t piDims[1]   = {_iRows * _iCols};
 +    herr_t status       = 0;
 +    hid_t iSpace        = 0;
 +    hid_t iDataset      = 0;
 +    hid_t iCompress     = 0;
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    iSpace = DynHDF5::dynH5Screate_simple (1, piDims, NULL);
 +    if(iSpace < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create the dataset and write the array data to it.
 +    iCompress = enableCompression(9, 1, piDims);
 +    iDataset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, H5T_NATIVE_UINT32, iSpace, iCompress);
 +    if(iDataset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite (iDataset, H5T_NATIVE_UINT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _puiData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = double to dataset
 +    status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u32");
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_rows to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_cols to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose (iDataset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (iSpace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +HDF5_SCILAB_IMPEXP int writeUnsignedInteger64Matrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, unsigned long long* _pullData)
 +{
 +    hsize_t piDims[1]   = {_iRows * _iCols};
 +    herr_t status       = 0;
 +    hid_t iSpace        = 0;
 +    hid_t iDataset      = 0;
 +    hid_t iCompress     = 0;
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    iSpace = DynHDF5::dynH5Screate_simple (1, piDims, NULL);
 +    if(iSpace < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create the dataset and write the array data to it.
 +    iCompress = enableCompression(9, 1, piDims);
 +    iDataset = DynHDF5::dynH5Dcreate (_iFile, _pstDatasetName, H5T_NATIVE_UINT64, iSpace, iCompress);
 +    if(iDataset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite (iDataset, H5T_NATIVE_UINT64, H5S_ALL, H5S_ALL, H5P_DEFAULT,    _pullData);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = double to dataset
 +    status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u64");
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_rows to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class_cols to dataset
 +    status = addIntAttribute(iDataset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose (iDataset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (iSpace);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    return 0;
 +}
 +
 +int writeCommonSparseComplexMatrix(int _iFile, char* _pstDatasetName, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
 +{
 +    hsize_t dims[1]         = {3};
 +    herr_t status           = 0;
 +    hid_t space             = 0;
 +    hid_t dset              = 0;
 +    hid_t group             = 0;
 +    hid_t iCompress         = 0;
 +    hobj_ref_t* pDataRef    = 0;
 +
 +    char* pstRowPath        = NULL;
 +    char* pstColPath        = NULL;
 +    char* pstDataPath       = NULL;
 +    char* pstGroupName      = NULL;
 +
 +
 +    // Create ref matrix
 +    //3 refs : 1 for data, 1 for Number Item by row ( row size ) and 1 for column position
 +    pDataRef = (hobj_ref_t *)MALLOC(3 * sizeof(hobj_ref_t));
 +
 +    // Generate groupname #<dataSetName>#
 +    pstGroupName = createGroupName(_pstDatasetName);
 +
 +    //First create a group to store all referenced objects.
 +    group   = DynHDF5::dynH5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
 +    status  = DynHDF5::dynH5Gclose(group);
 +
 +    //Create each sub dataset and insert data
 +    pstRowPath = createPathName(pstGroupName, 0);
 +    status = writeInteger32Matrix(_iFile, pstRowPath, 1, _iRows, _piNbItemRow);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Rcreate(&pDataRef[0], _iFile, pstRowPath, H5R_OBJECT, -1);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    pstColPath = createPathName(pstGroupName, 1);
 +    status = writeInteger32Matrix(_iFile, pstColPath, 1, _iNbItem, _piColPos);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Rcreate(&pDataRef[1], _iFile, pstColPath, H5R_OBJECT, -1);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    pstDataPath = createPathName(pstGroupName, 2);
 +    if(_iComplex)
 +    {
 +        status = writeDoubleComplexMatrix(_iFile, pstDataPath, 1, _iNbItem, _pdblReal, _pdblImg);
 +    }
 +    else
 +    {
 +        status = writeDoubleMatrix(_iFile, pstDataPath, 1, _iNbItem, _pdblReal);
 +    }
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Rcreate(&pDataRef[2], _iFile, pstDataPath, H5R_OBJECT, -1);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //FREE group names
 +    FREE(pstRowPath);
 +    FREE(pstColPath);
 +    FREE(pstDataPath);
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    space = DynHDF5::dynH5Screate_simple(1, dims, NULL);
 +    if(space < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create the dataset and write the array data to it.
 +    iCompress   = enableCompression(9, 1, dims);
 +    dset        = DynHDF5::dynH5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
 +    if(dset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +    //Add attribute SCILAB_Class = poly to dataset
 +    //sprintf(pstRow, "%d", _iRows);
 +    //sprintf(pstCol, "%d", _iCols);
 +    status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_SPARSE);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +    if(_iComplex)
 +    {
 +        //Add attribute Varname attribute to dataset
 +        status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +    }
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose(dset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose(space);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    FREE(pstGroupName);
 +
 +    return 0;
 +}
 +
 +int writeSparseMatrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal)
 +{
 +    return writeCommonSparseComplexMatrix(_iFile, _pstDatasetName, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
 +}
 +
 +int writeSparseComplexMatrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
 +{
 +    return writeCommonSparseComplexMatrix(_iFile, _pstDatasetName, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
 +}
 +
 +int writeBooleanSparseMatrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos)
 +{
 +    int iRet                = 0;
 +    hsize_t dims[1]         = {2};
 +    herr_t status           = 0;
 +    hid_t space             = 0;
 +    hid_t dset              = 0;
 +    hid_t group             = 0;
 +    hid_t iCompress         = 0;
 +    hobj_ref_t* pDataRef    = 0;
 +
 +    char* pstRowPath        = NULL;
 +    char* pstColPath        = NULL;
 +    char* pstGroupName      = NULL;
 +
 +
 +    // Create ref matrix
 +    //2 refs : 1 for data, 1 for Number Item by row ( row size ) and 1 for column position
 +    pDataRef = (hobj_ref_t *)MALLOC(2 * sizeof(hobj_ref_t));
 +
 +    // Generate groupname #<dataSetName>#
 +    pstGroupName = createGroupName(_pstDatasetName);
 +
 +    //First create a group to store all referenced objects.
 +    group   = DynHDF5::dynH5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
 +    status  = DynHDF5::dynH5Gclose(group);
 +
 +    //Create each sub dataset and insert data
 +    pstRowPath = createPathName(pstGroupName, 0);
 +    status = writeInteger32Matrix(_iFile, pstRowPath, 1, _iRows, _piNbItemRow);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Rcreate(&pDataRef[0], _iFile, pstRowPath, H5R_OBJECT, -1);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    pstColPath  = createPathName(pstGroupName, 1);
 +    status      = writeInteger32Matrix(_iFile, pstColPath, 1, _iNbItem, _piColPos);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Rcreate(&pDataRef[1], _iFile, pstColPath, H5R_OBJECT, -1);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +
 +    //FREE group names
 +    FREE(pstRowPath);
 +    FREE(pstColPath);
 +
 +    //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +    space = DynHDF5::dynH5Screate_simple(1, dims, NULL);
 +    if(space < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Create the dataset and write the array data to it.
 +    iCompress   = enableCompression(9, 1, dims);
 +    dset        = DynHDF5::dynH5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
 +    if(dset < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    //Add attribute SCILAB_Class = boolean sparse to dataset
 +    status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_BSPARSE);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose(dset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose(space);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    FREE(pstGroupName);
 +    FREE(pDataRef);
 +
 +    return 0;
 +}
 +
 +
 +//create a group and create hobj_ref_t array
 +void* openList(int _iFile, char* pstDatasetName, int _iNbItem)
 +{
 +    herr_t status           = 0;
 +    hid_t group             = 0;
 +    hobj_ref_t* pobjArray   = NULL;
 +
 +    //First create a group to store all referenced objects.
 +    group = DynHDF5::dynH5Gcreate(_iFile, pstDatasetName, H5P_DEFAULT);
 +    status = DynHDF5::dynH5Gclose(group);
 +    if(status < 0)
 +    {
 +        return NULL;
 +    }
 +
 +    if(_iNbItem)
 +    {
 +        pobjArray = (hobj_ref_t*)MALLOC(sizeof(hobj_ref_t) * _iNbItem);
 +    }
 +
 +    return pobjArray;
 +}
 +
 +int addItemInList(int _iFile, void* _pvList, int _iPos, char* _pstItemName)
 +{
 +    hobj_ref_t* pobjArray = (hobj_ref_t*)_pvList;
 +    return DynHDF5::dynH5Rcreate(&pobjArray[_iPos], _iFile, _pstItemName, H5R_OBJECT, -1);
 +}
 +
 +int closeList(int _iFile,  void* _pvList, char* _pstListName, int _iNbItem, int _iVarType)
 +{
 +    herr_t status           = 0;
 +    hsize_t dims[1]         = {_iNbItem};
 +    hid_t space             = 0;
 +    hid_t dset              = 0;
 +    hid_t iCompress         = 0;
 +    const char* pcstClass   = NULL;
 +
 +    switch(_iVarType)
 +    {
 +    case sci_list :
 +        pcstClass = g_SCILAB_CLASS_LIST;
 +        break;
 +    case sci_tlist :
 +        pcstClass = g_SCILAB_CLASS_TLIST;
 +        break;
 +    case sci_mlist :
 +        pcstClass = g_SCILAB_CLASS_MLIST;
 +        break;
 +    default :
 +        return 1;
 +    }
 +
 +    if(_iNbItem == 0)
 +    {
 +        //tips for empty list
 +        //insert a fake refence in the array, value = 0
 +
 +        hobj_ref_t pvList[1];
 +        pvList[0] = 0;
 +        //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +
 +        dims[0] = 1;
 +        space = DynHDF5::dynH5Screate_simple (1, dims, NULL);
 +        if(space < 0)
 +        {
 +            return -1;
 +        }
 +
 +        //Create the dataset and write the array data to it.
 +        iCompress = enableCompression(9, 1, dims);
 +        dset = DynHDF5::dynH5Dcreate (_iFile, _pstListName, H5T_STD_REF_OBJ, space, iCompress);
 +        if(dset < 0)
 +        {
 +            return -1;
 +        }
 +
 +        status = DynHDF5::dynH5Dwrite (dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, (hobj_ref_t*)pvList);
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +
 +        //Add attribute SCILAB_Class = string to dataset
 +        status = addAttribute(dset, g_SCILAB_CLASS,  pcstClass);
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +
 +
 +        status = addAttribute(dset, g_SCILAB_CLASS_EMPTY, "true");
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +    }
 +    else
 +    {
 +        //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 +        space = DynHDF5::dynH5Screate_simple (1, dims, NULL);
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +
 +        //Create the dataset and write the array data to it.
 +        iCompress = enableCompression(9, 1, dims);
 +        dset = DynHDF5::dynH5Dcreate (_iFile, _pstListName, H5T_STD_REF_OBJ, space, iCompress);
 +        if(dset < 0)
 +        {
 +            return -1;
 +        }
 +
 +        status = DynHDF5::dynH5Dwrite (dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT,(hobj_ref_t*)_pvList);
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +
 +        //Add attribute SCILAB_Class = string to dataset
 +        status = addAttribute(dset, g_SCILAB_CLASS,  pcstClass);
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +
 +        status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
 +        if(status < 0)
 +        {
 +            return -1;
 +        }
 +    }
 +
 +
 +    //Close and release resources.
 +    status = DynHDF5::dynH5Dclose (dset);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    status = DynHDF5::dynH5Sclose (space);
 +    if(status < 0)
 +    {
 +        return -1;
 +    }
 +
 +    FREE(_pvList);
 +    return 0;
 +}
 +
Simple merge