Add types dependency to mexlib. 67/4167/9
Iuri de Silvio [Mon, 6 Jun 2011 16:27:51 +0000 (13:27 -0300)]
Change some mexlib functions to new API.

Change-Id: I865953bc8acd26bbe3c69e5dab468515f60bafc8

59 files changed:
scilab/Scilab.sln
scilab/etc/modules.xml.in
scilab/etc/modules.xml.vc
scilab/modules/abstractSyntaxTree/includes/run_OpExp.hxx
scilab/modules/dynamic_link/macros/ilib_gen_gateway.sci
scilab/modules/mexlib/Makefile.am
scilab/modules/mexlib/Makefile.in
scilab/modules/mexlib/includes/mex.h
scilab/modules/mexlib/src/cpp/mexlib.cpp
scilab/modules/mexlib/src/cpp/mexlib.h
scilab/modules/mexlib/src/libmat/libmat.vcxproj
scilab/modules/mexlib/src/libmex/libmex.vcxproj
scilab/modules/mexlib/src/libmx/libmx.vcxproj
scilab/modules/mexlib/tests/unit_tests/mxCreateDouble.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateDouble.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateDouble.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalMatrix.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalMatrix.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalMatrix.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalScalar.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalScalar.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalScalar.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateNumericArray.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateNumericArray.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateNumericArray.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateString.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateString.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateString.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxDuplicateArray.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxDuplicateArray.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxDuplicateArray.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetEps.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetEps.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetEps.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfDimensions.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfDimensions.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfDimensions.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfElements.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfElements.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfElements.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetScalar.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetScalar.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetScalar.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetSetMN.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetSetMN.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetSetMN.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetSetPri.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetSetPri.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetSetPri.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsEmpty.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsEmpty.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsEmpty.win.dia.ref [new file with mode: 0644]
scilab/modules/operations/src/cpp/types_power.cpp
scilab/modules/symbol/includes/addGatewayInContext.h
scilab/modules/symbol/src/cpp/context.cpp
scilab/modules/types/includes/c_gateway_prototype.h
scilab/modules/types/includes/function.hxx
scilab/modules/types/includes/types.hxx
scilab/modules/types/src/cpp/function.cpp

index 9f1b12d..1e8a0d6 100644 (file)
@@ -38,6 +38,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LibScilab", "libs\LibScilab
                {C4C3EA58-1C27-4EFB-A5BF-0DB24EC5F87A} = {C4C3EA58-1C27-4EFB-A5BF-0DB24EC5F87A}
                {BB8D4E6F-F09E-49FC-8BCB-9F496F639F60} = {BB8D4E6F-F09E-49FC-8BCB-9F496F639F60}
                {0BB16C71-0FCD-4FB9-B7C0-F2601330C980} = {0BB16C71-0FCD-4FB9-B7C0-F2601330C980}
+               {C352587B-F5E4-457C-80EE-A1AEAB176C8E} = {C352587B-F5E4-457C-80EE-A1AEAB176C8E}
                {D2B63E7D-1E66-4EFC-892E-FA6DAF4E5895} = {D2B63E7D-1E66-4EFC-892E-FA6DAF4E5895}
                {D98B0986-14E4-44FD-B006-CACE4B291F38} = {D98B0986-14E4-44FD-B006-CACE4B291F38}
                {F0F55692-0355-4BC3-BE9D-552C8AAC5238} = {F0F55692-0355-4BC3-BE9D-552C8AAC5238}
@@ -166,11 +167,13 @@ EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libmx", "modules\mexlib\src\libmx\libmx.vcxproj", "{CEF88C5F-6820-46D4-BCCD-44D5581481C5}"
        ProjectSection(ProjectDependencies) = postProject
                {DBC45B0D-6E0A-4107-B284-5A3B0C5BB50D} = {DBC45B0D-6E0A-4107-B284-5A3B0C5BB50D}
+               {64E090DA-DCB5-4F4D-93D7-E88DDEC9C2EF} = {64E090DA-DCB5-4F4D-93D7-E88DDEC9C2EF}
        EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libmat", "modules\mexlib\src\libmat\libmat.vcxproj", "{8A508625-C2AA-4295-AA76-16E4E456D13D}"
        ProjectSection(ProjectDependencies) = postProject
                {DBC45B0D-6E0A-4107-B284-5A3B0C5BB50D} = {DBC45B0D-6E0A-4107-B284-5A3B0C5BB50D}
+               {64E090DA-DCB5-4F4D-93D7-E88DDEC9C2EF} = {64E090DA-DCB5-4F4D-93D7-E88DDEC9C2EF}
        EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SetupAtlas", "tools\SetupAtlas\SetupAtlas.vcxproj", "{AAFF2053-3F1E-4B8B-B174-4407A6B98FA5}"
index 902bb80..2c74eff 100644 (file)
@@ -40,5 +40,6 @@
     <!-- <module name="scicos" activate="@XCOS_ENABLE@"/> -->
     <module name="dynamic_link" activate="yes"/>
     <module name="action_binding" activate="yes"/>
+    <module name="mexlib" activate="yes"/>
 </modules>
 
index d3309e4..35ad332 100644 (file)
@@ -37,5 +37,6 @@
     <module name="hdf5" activate="yes"/>
     <module name="dynamic_link" activate="yes"/>
     <module name="action_binding" activate="yes"/>
+    <module name="mexlib" activate="yes"/>
 </modules>
 
index 8d37d07..23388a4 100644 (file)
@@ -149,7 +149,7 @@ void visitprivate(const OpExp &e)
             {
                 try
                 {
-                    pResult = GenericDotTimes(execMeL.result_get(), execMeR.result_get());
+                    pResult = GenericDotTimes(pITL, pITR);
                 }
                 catch (ScilabException *pSE)
                 {
@@ -170,7 +170,7 @@ void visitprivate(const OpExp &e)
             {
                 try
                 {
-                    pResult = GenericDotPower(execMeL.result_get(), execMeR.result_get());
+                    pResult = GenericDotPower(pITL, pITR);
                 }
                 catch (ScilabException *pSE)
                 {
@@ -191,7 +191,7 @@ void visitprivate(const OpExp &e)
             {
               try
                 {
-                    pResult = GenericComparisonEqual(execMeL.result_get(), execMeR.result_get());
+                    pResult = GenericComparisonEqual(pITL, pITR);
                 }
                 catch (ScilabException *pSE)
                 {
@@ -211,7 +211,7 @@ void visitprivate(const OpExp &e)
             {
               try
                 {
-                    pResult = GenericComparisonNonEqual(execMeL.result_get(), execMeR.result_get());
+                    pResult = GenericComparisonNonEqual(pITL, pITR);
                 }
                 catch (ScilabException *pSE)
                 {
@@ -452,7 +452,7 @@ void visitprivate(const OpExp &e)
             {
                 try
                 {
-                    pResult = GenericPower(execMeL.result_get(), execMeR.result_get());
+                    pResult = GenericPower(pITL, pITR);
                 }
                 catch (ScilabException *pSE)
                 {
index 090e226..776ccd2 100644 (file)
@@ -1,6 +1,7 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) INRIA/ENPC
 // Copyright (C) DIGITEO - 2010 - Allan CORNET
+// Copyright (C) DIGITEO - 2011 - Antoine ELIAS
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
@@ -63,6 +64,13 @@ function gateway_filename = ilib_gen_gateway(name,tables)
       nt = 3;
     end
 
+    prototype = '(char* fname, int* _piKey);';
+    addGWFunction = "addGatewayInContext";
+    if isdef("ismex") & ismex == %t then
+        prototype = '(int nlhs, int* plhs[], int nrhs, int* prhs[]);';
+        addGWFunction = "addMexGatewayInContext";
+    end
+
     if ( nt <> 3 ) then
       error(msprintf(gettext("%s: Wrong size for input argument #%d: %d expected.\n"),"ilib_gen_gateway",2,3));
     end
@@ -77,11 +85,11 @@ function gateway_filename = ilib_gen_gateway(name,tables)
             '';
             '#define MODULE_NAME L""' + tname + '""';
             '';
-            'extern int ' + names(:) + '(char* fname, int* _piKey);';
+            'extern int ' + names(:) + prototype;
             '';
             'int ' + tname + '(wchar_t* _pwstName)';
             '{';
-            '   if(wcscmp(_pwstName, L""' + table(:,1) + '"") == 0){addGatewayInContext(L""' + table(:,1) + '"", &' + names(:) + ', MODULE_NAME);}';
+            '   if(wcscmp(_pwstName, L""' + table(:,1) + '"") == 0){' + addGWFunction + '(L""' + table(:,1) + '"", &' + names(:) + ', MODULE_NAME);}';
             '}'];
         
     old = [ 'static int direct_gateway(char *fname,void F(void)) { F();return 0;};';
index 5fbc498..9bca4aa 100644 (file)
@@ -11,15 +11,18 @@ MEXLIB_FLAGS =      -I$(srcdir)/includes/ \
                -I$(top_srcdir)/modules/output_stream/includes/ \
                -I$(top_srcdir)/modules/call_scilab/includes/ \
                -I$(top_srcdir)/modules/elementary_functions/includes/ \
-               -I$(top_srcdir)/modules/operations/includes/
-
-MEXLIB_FLAGS += -I$(top_srcdir)/modules/string/includes
+               -I$(top_srcdir)/modules/operations/includes/ \
+               -I$(top_srcdir)/modules/string/includes \
+               -I$(top_srcdir)/modules/types/includes \
+               -I$(top_srcdir)/modules/symbol/includes \
+               -I$(top_srcdir)/modules/abstractSyntaxTree/includes
 
 MEXLIB_DEP =  \
        $(top_builddir)/modules/dynamic_link/libscidynamic_link.la \
        $(top_builddir)/modules/data_structures/libscidata_structures.la \
        $(top_builddir)/modules/output_stream/libscioutput_stream.la \
-    $(top_builddir)/modules/string/libscistring.la
+       $(top_builddir)/modules/string/libscistring.la \
+       $(top_builddir)/modules/types/libscitypes.la
 
 pkglib_LTLIBRARIES = libmat.la libmex.la libmx.la
 
@@ -56,7 +59,7 @@ INCLUDE_FLAGS = $(MEXLIB_FLAGS)
 
 #### mexlib : Conf files ####
 libmex_la_rootdir = $(mydatadir)
-libmex_la_root_DATA =  license.txt 
+libmex_la_root_DATA =  license.txt
 
 #### mexlib : init scripts ####
 libmex_la_etcdir = $(mydatadir)/etc
index 5d912c7..424a9b2 100644 (file)
@@ -413,16 +413,21 @@ MEXLIB_CPP_SOURCES = src/cpp/mexlib.cpp \
 src/cpp/sci_gateway.cpp
 
 MEXLIB_FLAGS = -I$(srcdir)/includes/ \
-       -I$(top_srcdir)/modules/output_stream/includes/ \
-       -I$(top_srcdir)/modules/call_scilab/includes/ \
-       -I$(top_srcdir)/modules/elementary_functions/includes/ \
-       -I$(top_srcdir)/modules/operations/includes/ \
-       -I$(top_srcdir)/modules/string/includes
+               -I$(top_srcdir)/modules/output_stream/includes/ \
+               -I$(top_srcdir)/modules/call_scilab/includes/ \
+               -I$(top_srcdir)/modules/elementary_functions/includes/ \
+               -I$(top_srcdir)/modules/operations/includes/ \
+               -I$(top_srcdir)/modules/string/includes \
+               -I$(top_srcdir)/modules/types/includes \
+               -I$(top_srcdir)/modules/symbol/includes \
+               -I$(top_srcdir)/modules/abstractSyntaxTree/includes
+
 MEXLIB_DEP = \
        $(top_builddir)/modules/dynamic_link/libscidynamic_link.la \
        $(top_builddir)/modules/data_structures/libscidata_structures.la \
        $(top_builddir)/modules/output_stream/libscioutput_stream.la \
-    $(top_builddir)/modules/string/libscistring.la
+       $(top_builddir)/modules/string/libscistring.la \
+       $(top_builddir)/modules/types/libscitypes.la
 
 pkglib_LTLIBRARIES = libmat.la libmex.la libmx.la
 libmex_la_SOURCES = $(MEXLIB_CPP_SOURCES)
@@ -447,7 +452,7 @@ INCLUDE_FLAGS = $(MEXLIB_FLAGS)
 
 #### mexlib : Conf files ####
 libmex_la_rootdir = $(mydatadir)
-libmex_la_root_DATA = license.txt 
+libmex_la_root_DATA = license.txt
 
 #### mexlib : init scripts ####
 libmex_la_etcdir = $(mydatadir)/etc
index 4692b7e..d910167 100644 (file)
@@ -292,6 +292,8 @@ typedef int (*GT) ();
     mxUINT16_CLASS,
     mxINT32_CLASS,
     mxUINT32_CLASS,
+    mxINT64_CLASS,
+    mxUINT64_CLASS,
     mxUNKNOWN_CLASS = 0
   } mxClassID;
   
@@ -306,7 +308,7 @@ typedef int (*GT) ();
   void mxSetPi(mxArray *array_ptr, double *pi);
   void mxSetData(mxArray *array_ptr, void *pr);
   mxArray *mxCreateNumericArray(int ndim, const int *dims, mxClassID classid, mxComplexity flag);
-  mxArray *mxCreateNumericMatrix(int m, int n, mxClassID classid, int cmplx_flag);
+  mxArray *mxCreateNumericMatrix(int m, int n, mxClassID classid, mxComplexity flag);
   int mxSetDimensions(mxArray *array_ptr, const int *dims, int ndim);
   mxArray *mxCreateDoubleMatrix(int m, int n, mxComplexity it);
   mxArray *mxCreateDoubleScalar(double value);
index 11e1ad2..e48c429 100644 (file)
@@ -44,6 +44,7 @@
  *                 values)
  *     values = vector of doubles or int8-16-32 or char
  --------------------------------------------------------------------------*/
+
 #include <string.h>
 #include <stdio.h>
 #include <stdarg.h>
        #include <stdlib.h> /* for exit()*/
 #endif
 
-#include "stack-c.h"
-extern "C" {
-  #include "elementary_functions.h"
-}
+#include "types.hxx"
+#include "int8.hxx"
+#include "uint8.hxx"
+#include "int16.hxx"
+#include "uint16.hxx"
+#include "int32.hxx"
+#include "uint32.hxx"
+#include "int64.hxx"
+#include "uint64.hxx"
+#include "double.hxx"
+#include "bool.hxx"
+#include "string.hxx"
+#include "container.hxx"
+#include "cell.hxx"
+#include "context.hxx"
+
 
 #include "mex.h"
 
+extern "C" {
+#include "stack-c.h"
+#include "elementary_functions.h"
+#include "cvstr.h"
+#include "cerro.h"
+#include "erro.h"
 #include "MALLOC.h" /* MALLOC */
 #include "mexlib.h"
 #include "sciprint.h"
-extern "C" {
-  #include "cvstr.h"
-  #include "cerro.h"
-  #include "erro.h"
-}
 #include "localization.h"
 #include "Scierror.h"
 #include "call_scilab.h"
+}
+
+#ifdef getType
+#undef getType
+#endif
 
 static char *the_current_mex_name;
 
 extern "C" {
-  int  C2F(hmcreate)(int *lw,int *nz,int *sz,int *typv,int *iflag,int *retval);
-  int  C2F(stcreate)(int *lw1,int *ndim,int *dims, int *nfields, char **field_names, int *retval);
-  double C2F(dlamch)(char *CMACH, unsigned long int);
+    int  C2F(hmcreate)(int *lw,int *nz,int *sz,int *typv,int *iflag,int *retval);
+    int  C2F(stcreate)(int *lw1,int *ndim,int *dims, int *nfields, char **field_names, int *retval);
+    double C2F(dlamch)(char *CMACH, unsigned long int);
 }
 extern int arr2num( mxArray  *ptr );
 extern int arr2numcst(const mxArray  *ptr );
@@ -100,1276 +119,1213 @@ extern int IsReference  (mxArray *array_ptr);
 
 vraiptrst stkptr(long int ptr_lstk)
 {
-  vraiptrst ptr =  C2F(locptr)(stk((long int)(ptr_lstk)));
-  return ptr;
+    vraiptrst ptr =  C2F(locptr)(stk((long int)(ptr_lstk)));
+    return ptr;
 }
 
 int *Header(const mxArray *ptr)
 {
-  /* Retuns an int pointer to the header of a mxArray */
-  int *header = (int *) stkptr((long int)ptr);
-  if (header[0] < 0) header = (int *) stk(header[1]);
-  return header;
+    /* Retuns an int pointer to the header of a mxArray */
+    int *header = (int *) stkptr((long int)ptr);
+    if (header[0] < 0) header = (int *) stk(header[1]);
+    return header;
 }
 
 
 mxArray *header2ptr(int *header)
 {
-  mxArray ptr;
-  ptr=(mxArray) ((double *)header-(double *)stkptr(C2F(vstk).lstk[0])+C2F(vstk).lstk[0]) ;
-  return (mxArray *) ptr;
+    mxArray ptr;
+    ptr=(mxArray) ((double *)header-(double *)stkptr(C2F(vstk).lstk[0])+C2F(vstk).lstk[0]) ;
+    return (mxArray *) ptr;
 }
 
 int *listentry(int *header, int i)
 {
-  /*Usage int *header = header(array_ptr)
-   *      int *headersub = listentry(header, k)
-   *   then headersub[0] ... is the header of the kth object in the
-   *   list array_ptr  */
-  int n, *ptr;
-  n = header[1];
-  if (i <= n) {
-    if ( n%2 == 0 ) n++;
-    /* n = n if n odd, n=n+1 if n even (=> n is odd and ptr even !) */
-    ptr = (int *) header + 3 + n + 2*( header[2 + (i - 1) ] -1);
-  return ptr;
-  } else {
-    return NULL;
-  }
+    /*Usage int *header = header(array_ptr)
+    *      int *headersub = listentry(header, k)
+    *   then headersub[0] ... is the header of the kth object in the
+    *   list array_ptr  */
+    int n, *ptr;
+    n = header[1];
+    if (i <= n) {
+        if ( n%2 == 0 ) n++;
+        /* n = n if n odd, n=n+1 if n even (=> n is odd and ptr even !) */
+        ptr = (int *) header + 3 + n + 2*( header[2 + (i - 1) ] -1);
+        return ptr;
+    } else {
+        return NULL;
+    }
 }
 
 int theMLIST(int *header)
 {
-  /* Returns the type of the mlist  (CELL, STRUCT or HYPERMATRIX)  */
-  int *header1; int nfplus2, l;
-  if (header[0]==MLIST && header[1]==3 && header[6]==STRINGMATRIX) {
-    if (header[14]==12 && header[15]==14) return 2;  /* CELL "c"=12 "e"=14  */
-    if (header[14]==17 && header[15]==22) return 1;  /* NDARRAY "h"=17 "m"=22   */
-  }
-  if (header[0]==MLIST) {
-    header1 = (int *) listentry(header,1);
-    nfplus2 = header1[1]*header1[2];
-    l = 5 + nfplus2;
-  /*  "s"=28,  "t"=29   */
-    if (header1[0]==STRINGMATRIX && header1[l]==28 && header1[l+1]==29) return 3;  /* STRUCT */
-  }
-  return 0;
+    /* Returns the type of the mlist  (CELL, STRUCT or HYPERMATRIX)  */
+    int *header1; int nfplus2, l;
+    if (header[0]==MLIST && header[1]==3 && header[6]==STRINGMATRIX) {
+        if (header[14]==12 && header[15]==14) return 2;  /* CELL "c"=12 "e"=14  */
+        if (header[14]==17 && header[15]==22) return 1;  /* NDARRAY "h"=17 "m"=22   */
+    }
+    if (header[0]==MLIST) {
+        header1 = (int *) listentry(header,1);
+        nfplus2 = header1[1]*header1[2];
+        l = 5 + nfplus2;
+        /*  "s"=28,  "t"=29   */
+        if (header1[0]==STRINGMATRIX && header1[l]==28 && header1[l+1]==29) return 3;  /* STRUCT */
+    }
+    return 0;
 }
 
 /*----------------------------------------------------------------
- *                       DOUBLEMATRIX
- *   header[0]= DOUBLEMATRIX  =1
- *   header[1]= M (number of rows)
- *   header[2]= N (number of cols)
- *   header[3]= mxComplexity  (0 real, 1 complex)
- *   value[2] = real part
- *   value[2+M*N] = imaginary part  (if mxComplexity =1)
- *
- *-----------------------------------------------------------------
- *                       INTMATRIX
- *   header[0] = INTMATRIX =8
- *   header[1]= M (number of rows)
- *   header[2]= N (number of cols)
- *   header[3]= TYPE
- *      TYPE=   01    02   04    11     12    14
- *             int8 int16 int32 uint8 uint16 uint32
- *   value[2] = real part
- *
- *------------------------------------------------------------------
- *                    SPARSEMATRIX
- *   int *header = Header(ptr);
- *   value = (double *) header;
- *   header[0]= SPARSEMATRIX  =7 (converted from 8)
- *   header[1]= M (number of rows)
- *   header[2]= N (number of cols)
- *   header[3]= mxComplexity  (0 real, 1 complex)
- *   header[4]=nzmax
- *   header[5]=Jc[0]  ... header[5+N]=Jc[N]
- *   header[5+N+1]=Ir[0]  ... header[5+N+nzmax]=Ir[nzmax];
- *   value[(5+N+nzmax)/2 + 1] = Pr[0]  ...
- *   value[(5+N+nzmax)/2 + nzmax] = Pr[nzmax]
- *   value[(5+N+nzmax)/2 + 1 + nzmax+1] = Pi[0]
- *   value[(5+N+nzmax)/2 + 1 + nzmax+nzmax] = Pi[nzmax]
- *   (5 + (N+1) + nzmax)*sizeof(int) + nzmax*sizeof(double) * (1+mxComplx)
- *
- *-------------------------------------------------------------------
- *                    STRINGMATRIX
- *    header[0]= STRINGMATRIX   = 10
- *    header[1]=  nrows
- *    header[2]=  ncols  (MUST be 1 since Matlab string matrices are seen
- *                           as Scilab  column matrices, all columns
- *                           having  the same length
- *    header[3]=  0
- *    header[4:...]= 1, ptr1, ..., ptrnrows,
- *    header[5]=header[4] + length of string in row 1
- *    header[6]=header[5] + length of string in row 2
- *    header[5+header[1]:...] = code of strings  (int)
- *
- *--------------------------------------------------------------------
- *
- *                   MLIST
- *           <=>  ndim matlab numeric or char array
- *           <=>  mlist(["hm","dims","entries"],[dim1,...,dimk], vector)
- *
- *            or
- *           <=>  matlab cell array
- *           <=> mlist(["ce","dims","entries"],[dim1,...,dimk], list())
- *
- *   header[0]=   MLIST  =  17
- *   header[1]= 3   (3 elements in the mlist)
- *   header[2,3,4,5]= 1,12,*,*  <-> 4 pointers
- *
- * ->header[6:27]  <-> ["hm","dims","entries"] = ...
- *                     HYPERMATRIX
- *             10,1,3,0,1,3,7,14,17,22,13,18,22,28,14,23,29,27,18,14,28,*
- *                                h  m  d  i  m  s  e  n  t  r  i  e  s
- *               <-> ["ce","dims","entries"] = ...
- *                     CELL
- *             10,1,3,0,1,3,7,14,12,14,13,18,22,28,14,23,29,27,18,14,28,*
- *                                c  e  d  i  m  s  e  n  t  r  i  e  s
- *
- * ->header[28:...] <-> [dim1, ..., dimk] = ...
- *                1,ndims,1,0,****** (dimensions)  28=6+2*(header[3]-1)
- *                            ^
- *                            |
- *                         header[32]
- *
- * ->header[6+2*(header[4]-1):...] <-> vector
- *                            = 1,m,n,it,*  for double  array
- *                            = 8,m,n,it,* for int array   with n=1
- *                            = 10,m,n,0,1,len+1 for char array with m=1, n=1
- *                            = 15,n,...         for cell array
- *                              ^
- *                              |
- *                     header[6+2*(header[4]-1)]   ( = 1, 8, 10)
- *   header[6+2*(header[4]-1)+4:...] = ***** (entries) for double or int array
- *
- *   header[6+2*(header[4]-1)+4:6+2*(header[4]-1)+5] = [1,length+1]
- *   header[6+2*(header[4]-1)+6:...] = entries = code of string  (int)
- *
- *----------------------------------------------------------------------
- **************************************************************************/
+*                       DOUBLEMATRIX
+*   header[0]= DOUBLEMATRIX  =1
+*   header[1]= M (number of rows)
+*   header[2]= N (number of cols)
+*   header[3]= mxComplexity  (0 real, 1 complex)
+*   value[2] = real part
+*   value[2+M*N] = imaginary part  (if mxComplexity =1)
+*
+*-----------------------------------------------------------------
+*                       INTMATRIX
+*   header[0] = INTMATRIX =8
+*   header[1]= M (number of rows)
+*   header[2]= N (number of cols)
+*   header[3]= TYPE
+*      TYPE=   01    02   04    11     12    14
+*             int8 int16 int32 uint8 uint16 uint32
+*   value[2] = real part
+*
+*------------------------------------------------------------------
+*                    SPARSEMATRIX
+*   int *header = Header(ptr);
+*   value = (double *) header;
+*   header[0]= SPARSEMATRIX  =7 (converted from 8)
+*   header[1]= M (number of rows)
+*   header[2]= N (number of cols)
+*   header[3]= mxComplexity  (0 real, 1 complex)
+*   header[4]=nzmax
+*   header[5]=Jc[0]  ... header[5+N]=Jc[N]
+*   header[5+N+1]=Ir[0]  ... header[5+N+nzmax]=Ir[nzmax];
+*   value[(5+N+nzmax)/2 + 1] = Pr[0]  ...
+*   value[(5+N+nzmax)/2 + nzmax] = Pr[nzmax]
+*   value[(5+N+nzmax)/2 + 1 + nzmax+1] = Pi[0]
+*   value[(5+N+nzmax)/2 + 1 + nzmax+nzmax] = Pi[nzmax]
+*   (5 + (N+1) + nzmax)*sizeof(int) + nzmax*sizeof(double) * (1+mxComplx)
+*
+*-------------------------------------------------------------------
+*                    STRINGMATRIX
+*    header[0]= STRINGMATRIX   = 10
+*    header[1]=  nrows
+*    header[2]=  ncols  (MUST be 1 since Matlab string matrices are seen
+*                           as Scilab  column matrices, all columns
+*                           having  the same length
+*    header[3]=  0
+*    header[4:...]= 1, ptr1, ..., ptrnrows,
+*    header[5]=header[4] + length of string in row 1
+*    header[6]=header[5] + length of string in row 2
+*    header[5+header[1]:...] = code of strings  (int)
+*
+*--------------------------------------------------------------------
+*
+*                   MLIST
+*           <=>  ndim matlab numeric or char array
+*           <=>  mlist(["hm","dims","entries"],[dim1,...,dimk], vector)
+*
+*            or
+*           <=>  matlab cell array
+*           <=> mlist(["ce","dims","entries"],[dim1,...,dimk], list())
+*
+*   header[0]=   MLIST  =  17
+*   header[1]= 3   (3 elements in the mlist)
+*   header[2,3,4,5]= 1,12,*,*  <-> 4 pointers
+*
+* ->header[6:27]  <-> ["hm","dims","entries"] = ...
+*                     HYPERMATRIX
+*             10,1,3,0,1,3,7,14,17,22,13,18,22,28,14,23,29,27,18,14,28,*
+*                                h  m  d  i  m  s  e  n  t  r  i  e  s
+*               <-> ["ce","dims","entries"] = ...
+*                     CELL
+*             10,1,3,0,1,3,7,14,12,14,13,18,22,28,14,23,29,27,18,14,28,*
+*                                c  e  d  i  m  s  e  n  t  r  i  e  s
+*
+* ->header[28:...] <-> [dim1, ..., dimk] = ...
+*                1,ndims,1,0,****** (dimensions)  28=6+2*(header[3]-1)
+*                            ^
+*                            |
+*                         header[32]
+*
+* ->header[6+2*(header[4]-1):...] <-> vector
+*                            = 1,m,n,it,*  for double  array
+*                            = 8,m,n,it,* for int array   with n=1
+*                            = 10,m,n,0,1,len+1 for char array with m=1, n=1
+*                            = 15,n,...         for cell array
+*                              ^
+*                              |
+*                     header[6+2*(header[4]-1)]   ( = 1, 8, 10)
+*   header[6+2*(header[4]-1)+4:...] = ***** (entries) for double or int array
+*
+*   header[6+2*(header[4]-1)+4:6+2*(header[4]-1)+5] = [1,length+1]
+*   header[6+2*(header[4]-1)+6:...] = entries = code of string  (int)
+*
+*----------------------------------------------------------------------
+**************************************************************************/
 
 mxClassID mxGetClassID(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  switch (header[0]) {
-  case DOUBLEMATRIX:
-    return mxDOUBLE_CLASS;
-  case STRINGMATRIX:
-    return mxCHAR_CLASS;
-  case SPARSEMATRIX:
-    return mxSPARSE_CLASS;
-  case INTMATRIX:
-    /*[8,m,n,it] it=01    02   04    11     12    14
-                   int8 int16 int32 uint8 uint16 uint32    */
-    switch (header[3]){
-    case 1:
-      return mxINT8_CLASS;
-    case 2:
-      return mxINT16_CLASS;
-    case 4:
-      return mxINT32_CLASS;
-    case 11:
-      return mxUINT8_CLASS;
-    case 12:
-      return mxUINT16_CLASS;
-    case 14:
-      return mxUINT32_CLASS;
-    default:
-      return mxUNKNOWN_CLASS;
-    }
-  case MLIST:
-    switch (theMLIST(header)) {
-    case CELL:
-      return mxCELL_CLASS;
-    case STRUCT:
-      return mxSTRUCT_CLASS;
-    case NDARRAY:
-    /* header[6+2*(header[4]-1)]   ( = 1, 10, 8)  */
-    switch (header[6+2*(header[4]-1)]) {
+    int *header = Header(ptr);
+    switch (header[0]) {
     case DOUBLEMATRIX:
-      return mxDOUBLE_CLASS;
+        return mxDOUBLE_CLASS;
     case STRINGMATRIX:
-      return mxCHAR_CLASS;
+        return mxCHAR_CLASS;
+    case SPARSEMATRIX:
+        return mxSPARSE_CLASS;
     case INTMATRIX:
-      switch (header[6+2*(header[4]-1)+3]) {
-      case 1:
-       return mxINT8_CLASS;
-      case 2:
-       return mxINT16_CLASS;
-      case 4:
-       return mxINT32_CLASS;
-      case 11:
-       return mxUINT8_CLASS;
-      case 12:
-       return  mxUINT16_CLASS;
-      case 14:
-       return  mxUINT32_CLASS;
-      default:
-       return mxUNKNOWN_CLASS;
-      }
-    }
-    default:
-      return mxUNKNOWN_CLASS;
+        /*[8,m,n,it] it=01    02   04    11     12    14
+        int8 int16 int32 uint8 uint16 uint32    */
+        switch (header[3]){
+        case 1:
+            return mxINT8_CLASS;
+        case 2:
+            return mxINT16_CLASS;
+        case 4:
+            return mxINT32_CLASS;
+        case 11:
+            return mxUINT8_CLASS;
+        case 12:
+            return mxUINT16_CLASS;
+        case 14:
+            return mxUINT32_CLASS;
+        default:
+            return mxUNKNOWN_CLASS;
+        }
+    case MLIST:
+        switch (theMLIST(header)) {
+        case CELL:
+            return mxCELL_CLASS;
+        case STRUCT:
+            return mxSTRUCT_CLASS;
+        case NDARRAY:
+            /* header[6+2*(header[4]-1)]   ( = 1, 10, 8)  */
+            switch (header[6+2*(header[4]-1)]) {
+            case DOUBLEMATRIX:
+                return mxDOUBLE_CLASS;
+            case STRINGMATRIX:
+                return mxCHAR_CLASS;
+            case INTMATRIX:
+                switch (header[6+2*(header[4]-1)+3]) {
+                case 1:
+                    return mxINT8_CLASS;
+                case 2:
+                    return mxINT16_CLASS;
+                case 4:
+                    return mxINT32_CLASS;
+                case 11:
+                    return mxUINT8_CLASS;
+                case 12:
+                    return  mxUINT16_CLASS;
+                case 14:
+                    return  mxUINT32_CLASS;
+                default:
+                    return mxUNKNOWN_CLASS;
+                }
+            }
+        default:
+            return mxUNKNOWN_CLASS;
+        }
     }
-  }
-  return mxUNKNOWN_CLASS;
+    return mxUNKNOWN_CLASS;
 }
 
 
 bool mxIsInt8(const mxArray *ptr)
 {
-  return mxGetClassID(ptr)==mxINT8_CLASS;
+    return mxGetClassID(ptr)==mxINT8_CLASS;
 }
 
 bool mxIsInt16(const mxArray *ptr)
 {
-  return mxGetClassID(ptr)==mxINT16_CLASS;
+    return mxGetClassID(ptr)==mxINT16_CLASS;
 }
 
 bool mxIsInt32(const mxArray *ptr)
 {
-  return mxGetClassID(ptr)==mxINT32_CLASS;
+    return mxGetClassID(ptr)==mxINT32_CLASS;
 }
 
 bool mxIsUint8(const mxArray *ptr)
 {
-  return mxGetClassID(ptr)==mxUINT8_CLASS;
+    return mxGetClassID(ptr)==mxUINT8_CLASS;
 }
 
 bool mxIsUint16(const mxArray *ptr)
 {
-  return mxGetClassID(ptr)==mxUINT16_CLASS;
+    return mxGetClassID(ptr)==mxUINT16_CLASS;
 }
 
 bool mxIsUint32(const mxArray *ptr)
 {
-  return mxGetClassID(ptr)==mxUINT32_CLASS;
+    return mxGetClassID(ptr)==mxUINT32_CLASS;
 }
 
 double mxGetEps(void)
 {
-  double eps;
-  eps=C2F(dlamch)("e",1L);
-  return eps;
+    types::InternalType* pITEps = symbol::Context::getInstance()->get(symbol::Symbol(L"%eps"));
+    if(pITEps && pITEps->isDouble())
+    {
+        return pITEps->getAs<types::Double>()->get(0);
+    }
+    
+    return -1;
+    //return EPSILON;
 }
 
 
 double mxGetInf(void)
 {
-  double big;
-  big=C2F(dlamch)("o",1L);
-  return big*big;
+    double big;
+    big=C2F(dlamch)("o",1L);
+    return big*big;
 }
 
 double mxGetNaN(void)
 {
-double x,y;
-x=mxGetInf();
-y=x/x;
-  return y;
+    double x,y;
+    x=mxGetInf();
+    y=x/x;
+    return y;
 }
 
 bool mxIsInf(double x)
 {
-  if (x == x+1)
-    return 1;
-  else return 0;
+    if (x == x+1)
+        return 1;
+    else return 0;
 }
 
 bool mxIsFinite(double x)
 {
-  if (x < x+1)
-    return 1;
-  else return 0;
+    if (x < x+1)
+        return 1;
+    else return 0;
 }
 
 bool mxIsNaN(double x)
 {
-  if ( x != x )
-    return 1;
-  else return 0;
+    if ( x != x )
+        return 1;
+    else return 0;
 }
 
 int *RawHeader(const mxArray *ptr)
 {
-  /* Utility function : return an int pointer to   *
-   * a Scilab variable. The variable can be            *
-   * a reference (header[0] < 0)                       */
-  int *header = (int *) stkptr((long int)ptr);
-  return header;
+    /* Utility function : return an int pointer to   *
+    * a Scilab variable. The variable can be            *
+    * a reference (header[0] < 0)                       */
+    int *header = (int *) stkptr((long int)ptr);
+    return header;
 }
 
 int Is1x1(const mxArray *ptr)
 {
-  int proddims,k;
-  int *header = RawHeader(ptr);
-  int *headerdims = listentry(header,2);
-  proddims=1;
-  for (k=0; k<headerdims[1]*headerdims[2]; k++) {
-    proddims=proddims*headerdims[4+k];
-  }
-  return (int) proddims==1;
+    int proddims,k;
+    int *header = RawHeader(ptr);
+    int *headerdims = listentry(header,2);
+    proddims=1;
+    for (k=0; k<headerdims[1]*headerdims[2]; k++) {
+        proddims=proddims*headerdims[4+k];
+    }
+    return (int) proddims==1;
 }
 
 
 mxArray *mxCreateData(int m)
-     /* Utility fctn : create a no-header, unpopulated  *
-      * mxArray of size=m*sizeof(double)               */
-{
-  static int lw, lr;
-  int n; int size;
-  lw = Nbvars + 1;
-  size=m-2;
-  if (! C2F(createvar)(&lw, "d", &size, (n=1,&n), &lr, 1L)) {
-    mexErrMsgTxt(_("No more memory available: increase stacksize"));
-  }
-  C2F(intersci).ntypes[lw-1]=AsIs;
-  return (mxArray *) C2F(intersci).iwhere[lw-1];
+    /* Utility fctn : create a no-header, unpopulated  *
+    * mxArray of size=m*sizeof(double)               */
+{
+    static int lw, lr;
+    int n; int size;
+    lw = Nbvars + 1;
+    size=m-2;
+    if (! C2F(createvar)(&lw, "d", &size, (n=1,&n), &lr, 1L)) {
+        mexErrMsgTxt(_("No more memory available: increase stacksize"));
+    }
+    C2F(intersci).ntypes[lw-1]=AsIs;
+    return (mxArray *) C2F(intersci).iwhere[lw-1];
 }
 
 
 int mxGetNumberOfElements(const mxArray *ptr)
 {
-  int m, commonlength, k, proddims;
-  int *headerdims;
-  int *header=Header(ptr);
-  switch (header[0]) {
-  case DOUBLEMATRIX: case INTMATRIX:
-    return header[1]*header[2];
-  case MLIST:
-    switch (theMLIST(header)) {
-    case NDARRAY:
-      headerdims = listentry(header,2);
-      proddims=1;
-      for (k=0; k<headerdims[1]*headerdims[2]; k++) {
-        proddims = proddims * headerdims[4+k];
-      }
-      return proddims;
-    case CELL: case STRUCT:
-      headerdims = listentry(header,2);
-      proddims=1;
-      for (k=0; k<headerdims[1]*headerdims[2]; k++) {
-        proddims = proddims * headerdims[4+k];
-      }
-      return proddims;
-    default:
-      return 0;
-    }
-  /*  return header[6+2*(header[4]-1)+1];  */
-  case STRINGMATRIX:
-    m=header[1];
-    commonlength=header[5]-header[4];
-    return m*commonlength;
-    /*case SPARSEMATRIX to be done */
-  default:
-    return 0;
-  }
+    types::InternalType* pIT = (types::InternalType*)ptr;
+    if(pIT == NULL)
+    {
+        return 0;
+    }
+
+    types::GenericType* pGT = dynamic_cast<types::GenericType*>(pIT);
+    if(pGT == NULL)
+    {
+        return 0;
+    }
+
+    return pGT->getSize();
 }
 
 
 double *mxGetPr(const mxArray *ptr)
 {
-  double *value;
-  int *header = Header(ptr);
-  switch (header[0]) {
-  case DOUBLEMATRIX: case INTMATRIX:
-    /*    return (header[1]==0 || header[2] == 0) ? NULL : &header[4]; */
-    return (header[1]==0 || header[2] == 0) ? NULL : (double *) &header[4];
-  case MLIST:
-    switch (header[6+2*(header[4]-1)]){
-    case DOUBLEMATRIX: case INTMATRIX:
-      return (double *) &header[6+2*(header[4]-1)+4];
-    case STRINGMATRIX:
-      return (double *) &header[6+2*(header[4]-1)+6];
-    default:
-      return 0;
+    types::InternalType* pIT = (types::InternalType*)ptr;
+    if(pIT == NULL)
+    {
+        return NULL;
     }
-  case STRINGMATRIX:
-    value = (double *) header;
-    return &value[i2sadr(5 + header[2])];
-  case SPARSEMATRIX:
-    value = (double *) header;
-    return &value[ i2sadr(5+header[2]+header[4]) ];
-  default:
-    return 0;
-  }
-}
 
+    types::Double* pD = dynamic_cast<types::Double*>(pIT);
+    if(pD == NULL)
+    {
+        return NULL;
+    }
 
+    return pD->get();
+}
 
 double *mxGetPi(const mxArray *ptr)
 {
-  int debut; int m,n,it;
-  /*  double *value = (double *) stkptr((long int)ptr); */
-  double *value;
-  int *header = Header(ptr);
-  value = (double *) header;
-  switch (header[0]) {
-  case DOUBLEMATRIX: case INTMATRIX:
-    if (header[3]==0 || header[1]==0 || header[2] == 0) return NULL;
-    return  &value[2 + header[1] * header[2]];
-  case MLIST:
-    debut=6+2*(header[4]-1);
-    switch (header[debut]){
-    case DOUBLEMATRIX: case INTMATRIX:
-      m=header[debut+1];n=header[debut+2];
-      it=header[debut+3];  /* it should be 1 */
-      if (it==0) return NULL;
-      return (double *) &header[debut+4+2*m*n];
-    default:
-      return 0;
-    }
-  case SPARSEMATRIX:
-    if (header[3]==0) return NULL;
-    return &value[ i2sadr(5+header[2] +header[4]) + header[4]];
-  default:
-    return 0;
- }
+    return ((types::Double *) ptr)->getImg();
 }
 
 int mxGetNumberOfDimensions(const mxArray *ptr)
 {
-  int *header1;
-  int *header = Header(ptr);
-  switch (header[0]) {
-  case DOUBLEMATRIX: case INTMATRIX: case SPARSEMATRIX: case STRINGMATRIX:
-    return 2;
-  case MLIST:
-    switch (theMLIST(header)) {
-    case NDARRAY:
-      return header[29]*header[30]; /* header[29] or header[30] = 1  */
-    case CELL: case STRUCT:
-      header1 = (int *) listentry(header,2)  ;
-      return header1[1]*header1[2];
-    default:
-      return 0;
-       }
-  default:
-    return 0;
-  }
+    types::InternalType* pIT = (types::InternalType*)ptr;
+    if(pIT == NULL)
+    {
+        return 0;
+    }
+
+    types::GenericType* pGT = pIT->getAs<types::GenericType>();
+    if(pGT == NULL)
+    {//InternalType but not GenericType, so mono dimension type.
+        return 1;
+    }
+
+    return pGT->getDims();
 }
 
 int *mxGetDimensions(const mxArray *ptr)
 {
-  int *header1;
-  int *header = Header(ptr);
-  switch (header[0]) {
-  case DOUBLEMATRIX: case INTMATRIX: case STRINGMATRIX:
-    return &header[1];
-  case SPARSEMATRIX: /* to be done  */
-    return &header[1];
-    break;
-  case MLIST:
-    switch (theMLIST(header)) {
-      /*  case NDARRAY       return &header[32];       break;  */
-    case NDARRAY: case CELL: case STRUCT:
-      header1 = (int *) listentry(header,2);
-      return &header1[4];
-  default:
-    return 0;
+    types::InternalType* pIT = (types::InternalType*)ptr;
+    if(pIT == NULL)
+    {
+        return NULL;
+    }
+
+    switch(pIT->getType())
+    {
+    case types::InternalType::RealList:
+    case types::InternalType::RealMList:
+    case types::InternalType::RealTList:
+        {
+            int* piDims = (int*)MALLOC(sizeof(int));
+            piDims[0] = pIT->getAs<types::Container>()->getSize();
+            return piDims;
+        }
+    default : 
+        {
+            types::GenericType* pGT = pIT->getAs<types::GenericType>();
+            if(pGT == NULL)
+            {
+                return NULL;
+            }
+            return pGT->getDimsArray();
+        }
     }
-  }
-  return 0;
+    return NULL;
 }
 
 int mxGetM(const mxArray *ptr)
 {
-  int *header1;
-  int *header = Header(ptr);
-  switch (header[0]) {
-  case DOUBLEMATRIX: case INTMATRIX: case STRINGMATRIX: case SPARSEMATRIX:
-    return header[1];
-  case MLIST:
-    switch (theMLIST(header)) {
-    case NDARRAY:
-      return header[32];
-    case CELL: case STRUCT:
-      header1 = (int *) listentry(header,2);
-      return header1[4];
-    default:
-      return 0;
+    types::InternalType* pIT = (types::InternalType*)ptr;
+    if(pIT == NULL)
+    {
+        return NULL;
     }
-  default:
-    return 0;
-  }
+
+    types::GenericType* pGT = pIT->getAs<types::GenericType>();
+    if(pGT == NULL)
+    {
+        return NULL;
+    }
+    return pGT->getRows();
 }
 
 void mxSetM(mxArray *ptr, int M)
 {
-  mxArray *mxNew;
-  int size;
-  int oldM; int commonlength; int j;
-  int *headernew;
-  double *valueold, *valuenew;
-  int *header = Header(ptr);
-  switch (header[0]) {
-  case STRINGMATRIX:
-    /* string: copy header[5+oldM] to header[5+mnew]  */
-    oldM=header[1];
-    commonlength=header[5]-header[4];
-    for (j=0; j<=M*commonlength; ++j) {
-      header[5+j+M]=header[5+j+oldM];
-    }
-    header[1]=M;
-    break;
-  case DOUBLEMATRIX: case INTMATRIX:
-    /* make ptr a reference */
-    size=2+M*header[2]*(header[3]+1);  /*  oldN=header[2] */
-    mxNew = mxCreateData(size);   /* performs Nbvars++ */
-    headernew = (int *) stkptr((long int) mxNew);
-    headernew[0]=header[0];
-    headernew[1]=M;
-    headernew[2]=header[2];
-    headernew[3]=header[3];
-    valueold = (double *) &header[4]; valuenew = (double *) &headernew[4];
-    memcpy(valuenew, valueold, M*header[2]*(header[3]+1)*sizeof(double));
-    ChangeToRef(arr2num(ptr),Nbvars);
-    break;
-  default:
-    break;
-  }
+    types::InternalType* pIT = (types::InternalType*)ptr;
+    if(pIT == NULL)
+    {
+        return;
+    }
+
+    types::GenericType* pGT = pIT->getAs<types::GenericType>();
+    if(pGT == NULL)
+    {
+        return;
+    }
+
+    pGT->resize(M, pGT->getCols());
 }
 
 
 int *mxGetJc(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  if (header[0] != SPARSEMATRIX) {
-    return 0;}
-  /*  header[0]=7;  M=header[1];  N=header[2];  it =header[3];  nzmax=header[4];
-      Jc[0]=header[5];  Jc[1]=header[6]; etc; Jc[N]=nnz; */
-  return &header[5];
+    int *header = Header(ptr);
+    if (header[0] != SPARSEMATRIX) {
+        return 0;}
+    /*  header[0]=7;  M=header[1];  N=header[2];  it =header[3];  nzmax=header[4];
+    Jc[0]=header[5];  Jc[1]=header[6]; etc; Jc[N]=nnz; */
+    return &header[5];
 }
 
 int *mxGetIr(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  /* ... N=header[2],  nzmax=header[4]; then Jc,  then Ir   */
-  return &header[5+header[2]+1];
+    int *header = Header(ptr);
+    /* ... N=header[2],  nzmax=header[4]; then Jc,  then Ir   */
+    return &header[5+header[2]+1];
 }
 
 void mxSetJc(mxArray *array_ptr, int *jc_data)
 {
- int * start_of_jc;
- int N;
- int *header = Header(array_ptr);
+    int * start_of_jc;
+    int N;
+    int *header = Header(array_ptr);
 
- start_of_jc = (int *) mxGetJc(array_ptr);
- N = header[2];
- memcpy(start_of_jc, jc_data, (N+1)*sizeof(int));
+    start_of_jc = (int *) mxGetJc(array_ptr);
+    N = header[2];
+    memcpy(start_of_jc, jc_data, (N+1)*sizeof(int));
 }
 
 void mxSetIr(mxArray *array_ptr, int *ir_data)
 {
-  int * start_of_ir;
-  int NZMAX;
-  int *header = Header(array_ptr);
+    int * start_of_ir;
+    int NZMAX;
+    int *header = Header(array_ptr);
 
-  if(ir_data == NULL)return;
-  start_of_ir = (int *) mxGetIr(array_ptr);
-  NZMAX = header[4];
-  memcpy(start_of_ir, ir_data, NZMAX*sizeof(int));
+    if(ir_data == NULL)return;
+    start_of_ir = (int *) mxGetIr(array_ptr);
+    NZMAX = header[4];
+    memcpy(start_of_ir, ir_data, NZMAX*sizeof(int));
 }
 
 void mxSetNzmax(mxArray *array_ptr, int nzmax)
 {
-  int isize, Mold, Nold, NZMAXold, ITold;
-  double *Prold, *Piold;
-  int *Irold, *Jcold;
-  mxArray *mxNew; int *headernew;
-  int *header = Header(array_ptr);
-  Mold=header[1]; Nold=header[2]; ITold=header[3]; NZMAXold=header[4];
-  Jcold=mxGetJc(array_ptr);
-  Irold=mxGetIr(array_ptr);
-  Prold=mxGetPr(array_ptr);
-  isize = 5 + (Nold+1) + nzmax + (ITold+1)*2*nzmax;
-  mxNew = mxCreateData( sadr(isize));   /* performs Nbvars++ */
-  headernew = (int *) stkptr((long int) mxNew);
-  headernew[0]=header[0];
-  headernew[1]=Mold;  headernew[2]=Nold;  headernew[3]=ITold;
-  headernew[4]=nzmax;
-  memcpy( mxGetJc(mxNew), Jcold, (Nold+1)*sizeof(int));
-  memcpy( mxGetIr(mxNew), Irold, NZMAXold*sizeof(int));
-  memcpy( mxGetPr(mxNew), Prold, NZMAXold*sizeof(double));
-  if (ITold==1) {
-    Piold = mxGetPi(array_ptr);
-    memcpy( mxGetPi(mxNew), Piold, NZMAXold*sizeof(double));
-  }
-  ChangeToRef(arr2num(array_ptr),Nbvars);
+    int isize, Mold, Nold, NZMAXold, ITold;
+    double *Prold, *Piold;
+    int *Irold, *Jcold;
+    mxArray *mxNew; int *headernew;
+    int *header = Header(array_ptr);
+    Mold=header[1]; Nold=header[2]; ITold=header[3]; NZMAXold=header[4];
+    Jcold=mxGetJc(array_ptr);
+    Irold=mxGetIr(array_ptr);
+    Prold=mxGetPr(array_ptr);
+    isize = 5 + (Nold+1) + nzmax + (ITold+1)*2*nzmax;
+    mxNew = mxCreateData( sadr(isize));   /* performs Nbvars++ */
+    headernew = (int *) stkptr((long int) mxNew);
+    headernew[0]=header[0];
+    headernew[1]=Mold;  headernew[2]=Nold;  headernew[3]=ITold;
+    headernew[4]=nzmax;
+    memcpy( mxGetJc(mxNew), Jcold, (Nold+1)*sizeof(int));
+    memcpy( mxGetIr(mxNew), Irold, NZMAXold*sizeof(int));
+    memcpy( mxGetPr(mxNew), Prold, NZMAXold*sizeof(double));
+    if (ITold==1) {
+        Piold = mxGetPi(array_ptr);
+        memcpy( mxGetPi(mxNew), Piold, NZMAXold*sizeof(double));
+    }
+    ChangeToRef(arr2num(array_ptr),Nbvars);
 }
 
 int mxGetN(const mxArray *ptr)
 {
-  int ret;int j;
-  int *header1;
-  int numberofdim;
-  int *header = Header(ptr);
-  switch (header[0]) {
-  case DOUBLEMATRIX: case INTMATRIX: case SPARSEMATRIX:
-    return header[2];
-  case STRINGMATRIX:
-    /*  for strings, N=length of first (and unique, header[2]=1) column
-        (all rows have same Matlab-length) */
-    return header[5]-header[4];
-  case MLIST:
-    switch (theMLIST(header)) {
-    case NDARRAY: case CELL: case STRUCT:
-      header1 = (int *) listentry(header,2);
-      numberofdim = header1[1]*header1[2];
-      if (numberofdim==2)
-      return header1[5];
-      else
-       ret=header1[5];
-      for (j=0; j < numberofdim-2; ++j) ret=ret*header1[6+j];
-      return ret;
-    default:
-      return 0;
-       }
-  default:
-    return 0;
-  }
+    types::InternalType* pIT = (types::InternalType*)ptr;
+    if(pIT == NULL)
+    {
+        return NULL;
+    }
+
+    types::GenericType* pGT = pIT->getAs<types::GenericType>();
+    if(pGT == NULL)
+    {
+        return NULL;
+    }
+    return pGT->getCols();
 }
 
 void mxSetN(mxArray *ptr, int N)
 {
-  mxArray *mxNew;
-  int i,m,new_,size;
-  int *headernew;
-  double *valueold, *valuenew;
-  int *header = Header(ptr);
-  switch (header[0]) {
-  case STRINGMATRIX:
-    m=header[1];
-    /* oldN = header[5]-header[4];  */
-    for (i=0; i<m; ++i) {
-      header[5+i]=header[4+i]+N;
-      /* to be done: compress header[5+m]  */
+    types::InternalType* pIT = (types::InternalType*)ptr;
+    if(pIT == NULL)
+    {
+        return;
     }
-    break;
-  case DOUBLEMATRIX: case INTMATRIX:
-    /* make ptr a reference */
-    size=2+header[1]*N*(header[3]+1);  /*  oldM=header[1] */
-    mxNew = mxCreateData(size);
-    headernew = (int *) stkptr((long int) mxNew);
-    headernew[0]=header[0];
-    headernew[1]=header[1];
-    headernew[2]=N;
-    headernew[3]=header[3];
-    new_ = Nbvars;
-    valueold = (double *) &header[4]; valuenew = (double *) &headernew[4];
-    memcpy(valuenew, valueold, header[1]*N*(header[3]+1)*sizeof(double));
-    ChangeToRef(arr2num(ptr),new_);
-    break;
-  case SPARSEMATRIX:
-    /* TO BE DONE */
-    break;
-  default:
-    break;
-  }
+
+    types::GenericType* pGT = pIT->getAs<types::GenericType>();
+    if(pGT == NULL)
+    {
+        return;
+    }
+
+    pGT->resize(pGT->getRows(), N);
 }
 
 
 bool mxIsString(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  if (header[0] == STRINGMATRIX)
-    return 1;
-  else return 0;
+    return mxGetClassID(ptr)==mxCHAR_CLASS;
 }
 
 bool mxIsChar(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  switch (header[0]) {
-  case STRINGMATRIX:
-    return 1;
-  case MLIST:
-    switch (header[6+2*(header[4]-1)]){
+    int *header = Header(ptr);
+    switch (header[0]) {
     case STRINGMATRIX:
-      return 1;
+        return 1;
+    case MLIST:
+        switch (header[6+2*(header[4]-1)]){
+        case STRINGMATRIX:
+            return 1;
+        default:
+            return 0;
+        }
     default:
-      return 0;
+        return 0;
     }
-  default:
-    return 0;
-  }
 }
 
 bool mxIsNumeric(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  if (header[0] != STRINGMATRIX)
-    return 1;
-  else
-    return 0;
+    int *header = Header(ptr);
+    if (header[0] != STRINGMATRIX)
+        return 1;
+    else
+        return 0;
 }
 
 bool mxIsDouble(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  if ((header[0] == DOUBLEMATRIX) | (header[0] == SPARSEMATRIX) | ( (header[0] == MLIST) && (header[6+2*(header[4]-1)] == DOUBLEMATRIX)))
-    return 1;
-  else
-    return 0;
+    int *header = Header(ptr);
+    if ((header[0] == DOUBLEMATRIX) | (header[0] == SPARSEMATRIX) | ( (header[0] == MLIST) && (header[6+2*(header[4]-1)] == DOUBLEMATRIX)))
+        return 1;
+    else
+        return 0;
 }
 
 bool mxIsSingle(const mxArray *ptr)
 {
-  mexPrintf(_("Routine mxIsSingle not implemented.\n"));
-  exit(1);  /* TO BE DONE */
-  return 0;
+    return mxGetClassID(ptr)==mxSINGLE_CLASS;
 }
 
 bool mxIsEmpty(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  if (header[1]*header[2]==0) return 1;
-  return 0;
+    types::InternalType* pIT = (types::InternalType*)ptr;
+    if(pIT == NULL)
+    {//true or false, whatever ;)
+        return true;
+    }
+
+    switch(pIT->getType())
+    {
+    case types::InternalType::RealDouble :
+        {
+            types::Double* pD = pIT->getAs<types::Double>();
+            return pD->getSize() == 0;
+        }
+    case types::InternalType::RealCell : 
+        {
+            types::Cell* pC = pIT->getAs<types::Cell>();
+            return pC->getSize() == 0;
+        }
+    case types::InternalType::RealContainer : 
+    case types::InternalType::RealList : 
+    case types::InternalType::RealMList : 
+    case types::InternalType::RealTList : 
+        {
+            types::Container* pC = pIT->getAs<types::Container>();
+            return pC->getSize() == 0;
+        }
+    default : 
+        {//other type can not be empty
+            return false;
+        }
+    }
 }
 
 bool mxIsFull(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  if ( header[0] != SPARSEMATRIX)
-    return 1;
-  else
-    return 0;
+    return !mxIsSparse(ptr);
 }
 
 bool mxIsSparse(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  if (header[0] == SPARSEMATRIX)
-    return 1;
-  else
-    return 0;
+    int *header = Header(ptr);
+    if (header[0] == SPARSEMATRIX)
+        return 1;
+    else
+        return 0;
 }
 
 bool mxIsLogical(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  /*     TO BE DONE ND Array */
-  if (header[0] == LOGICAL)
-    return 1;
-  else
-    return 0;
+    types::InternalType* pIT = (types::InternalType*)ptr;
+    if(pIT == NULL)
+    {
+        return false;
+    }
+
+    return pIT->isBool();
 }
 
 void mxSetLogical(mxArray *ptr)
 {
-  int *header = Header(ptr);
-  header[0] = LOGICAL;
+    int *header = Header(ptr);
+    header[0] = LOGICAL;
 }
 
 void mxClearLogical(mxArray *ptr)
 {
-  int *header = Header(ptr);
-  if (header[0] != LOGICAL)
-    mexErrMsgTxt(_("Variable is not logical."));
-  header[0] = DOUBLEMATRIX;
+    int *header = Header(ptr);
+    if (header[0] != LOGICAL)
+        mexErrMsgTxt(_("Variable is not logical."));
+    header[0] = DOUBLEMATRIX;
 }
 
 bool mxIsComplex(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  switch (header[0]) {
-  case DOUBLEMATRIX:
-    return header[3];
-  case MLIST:
-    if (header[6+2*(header[4]-1)] == DOUBLEMATRIX) {
-      return header[6+2*(header[4]-1)+3];
+    int *header = Header(ptr);
+    switch (header[0]) {
+    case DOUBLEMATRIX:
+        return header[3];
+    case MLIST:
+        if (header[6+2*(header[4]-1)] == DOUBLEMATRIX) {
+            return header[6+2*(header[4]-1)+3];
+        }
+    default:
+        return 0;
     }
-  default:
-    return 0;
-  }
 }
 
 double mxGetScalar(const mxArray *ptr)
 {
-  double *value;
-  int *header = Header(ptr);
-  value = (double *) header;
-  if (header[0] == DOUBLEMATRIX) {
-    return  value[2];
-  }
-  else if (header[0] == SPARSEMATRIX) {
-    /* nnz = header[4];    N = header[2]; */
-    return value[ i2sadr(5+header[2]+header[4]) ];
-  }
-  else {
-    return 0;
-  }
+    types::InternalType* pIT = (types::InternalType*)ptr;
+    if(pIT == NULL)
+    {//true or false, whatever ;)
+        return 0;
+    }
+
+    switch(pIT->getType())
+    {
+    case types::InternalType::RealDouble :
+        {
+            types::Double* pD = pIT->getAs<types::Double>();
+            return pD->get(0);
+        }
+    case types::InternalType::RealBool :
+        {
+            types::Bool* pB = pIT->getAs<types::Bool>();
+            return (double)pB->get(0);
+        }
+    case types::InternalType::RealInt8 :
+        {
+            types::Int8* pI = pIT->getAs<types::Int8>();
+            return (double)pI->get(0);
+        }
+    case types::InternalType::RealUInt8 :
+        {
+            types::UInt8* pI = pIT->getAs<types::UInt8>();
+            return (double)pI->get(0);
+        }
+    case types::InternalType::RealInt16 :
+        {
+            types::Int16* pI = pIT->getAs<types::Int16>();
+            return (double)pI->get(0);
+        }
+    case types::InternalType::RealUInt16 :
+        {
+            types::UInt16* pI = pIT->getAs<types::UInt16>();
+            return (double)pI->get(0);
+        }
+    case types::InternalType::RealInt32 :
+        {
+            types::Int32* pI = pIT->getAs<types::Int32>();
+            return (double)pI->get(0);
+        }
+    case types::InternalType::RealUInt32 :
+        {
+            types::UInt32* pI = pIT->getAs<types::UInt32>();
+            return (double)pI->get(0);
+        }
+    case types::InternalType::RealInt64 :
+        {
+            types::Int64* pI = pIT->getAs<types::Int64>();
+            return (double)pI->get(0);
+        }
+    case types::InternalType::RealUInt64 :
+        {
+            types::UInt64* pI = pIT->getAs<types::UInt64>();
+            return (double)pI->get(0);
+        }
+    default :
+        return 0;
+    }
 }
 
 void *mxGetData(const mxArray *ptr)
 {
-  return mxGetPr(ptr);
+    return mxGetPr(ptr);
 }
 
 void *mxGetImagData(const mxArray *ptr)
 {
-  return mxGetPi(ptr);
+    return mxGetPi(ptr);
 }
 
 void mexErrMsgTxt(const char *error_msg)
 {
-  cerro((char *)error_msg);
-  errjump();
+    cerro((char *)error_msg);
+    errjump();
 }
 
 void mxAssert(int expr, char *error_message)
 {
-  if (!expr) mexErrMsgTxt(error_message);
+    if (!expr) mexErrMsgTxt(error_message);
 }
 
-mxArray *mxCreateDoubleMatrix (int m, int n, mxComplexity it)
+mxArray *mxCreateDoubleMatrix (int m, int n, mxComplexity complexFlag)
 {
-  static int lw, lr, lc;
-  int k;
-  lw = Nbvars + 1;
-  if (! C2F(createcvar)(&lw, "d", (int *) &it, &m, &n, &lr, &lc, 1L)) {
-    mexErrMsgTxt(_("No more memory available: increase stacksize."));
-  }
-  for ( k=0; k<m*n*(it+1); k++ ) {
-   *stk(lr+k)=0;
-  }
-   return (mxArray *) C2F(vstk).lstk[lw + Top - Rhs - 1];  /* C2F(intersci).iwhere[lw-1]);  */
+    types::Double *ptr = new types::Double(m, n, complexFlag == mxCOMPLEX);
+    return (mxArray *) ptr;
 }
 
 mxArray *mxCreateDoubleScalar(double value)
 {
-  mxArray *pa;
-  pa = mxCreateDoubleMatrix(1, 1, mxREAL);
-  *mxGetPr(pa) = value;
-  return (mxArray *) pa;
+    mxArray *ptr = mxCreateDoubleMatrix(1, 1, mxREAL);
+    ((types::Double *) ptr)->set(0, value);
+    return ptr;
 }
 
 bool mxIsClass(const mxArray *ptr, const char *name)
 {
-  int *header = Header(ptr);
-  switch (header[0]) {
-  case DOUBLEMATRIX:
-    if ( strcmp(name,"double") == 0) return 1;
-    break;
-  case MLIST:
-    switch (header[6+2*(header[4]-1)]){
+    int *header = Header(ptr);
+    switch (header[0]) {
     case DOUBLEMATRIX:
-      if ( strcmp(name,"double") == 0) return 1;
-      break;
-    case INTMATRIX:
-      if ( strcmp(name,"double") == 0) return 1;
-      break;
+        if ( strcmp(name,"double") == 0) return 1;
+        break;
+    case MLIST:
+        switch (header[6+2*(header[4]-1)]){
+        case DOUBLEMATRIX:
+            if ( strcmp(name,"double") == 0) return 1;
+            break;
+        case INTMATRIX:
+            if ( strcmp(name,"double") == 0) return 1;
+            break;
+        }
+        break;
+    case STRINGMATRIX:
+        if ( strcmp(name,"char") == 0) return 1;
+        break;
+    case SPARSEMATRIX:
+        if ( strcmp(name,"sparse") == 0) return 1;
+        break;
+    default:
+        return 0;
     }
-    break;
-  case STRINGMATRIX:
-    if ( strcmp(name,"char") == 0) return 1;
-    break;
-  case SPARSEMATRIX:
-    if ( strcmp(name,"sparse") == 0) return 1;
-    break;
-  default:
     return 0;
-  }
-  return 0;
 }
 
 mxArray *mxCreateStructArray(int ndim, const int *dims, int nfields, const char **field_names)
 {
-  static int lw,lw1;
-  int retval;
-  Nbvars++;
-  lw = Nbvars;
-  lw1 = lw + Top - Rhs;
-  C2F(stcreate)(&lw1, &ndim, (int *) dims, &nfields, (char **) field_names, &retval);
-  if( !retval) {
-    return (mxArray *) 0;
-  }
-  C2F(intersci).ntypes[lw-1]=AsIs;
-  return (mxArray *) C2F(vstk).lstk[lw + Top - Rhs - 1 ];
+    static int lw,lw1;
+    int retval;
+    Nbvars++;
+    lw = Nbvars;
+    lw1 = lw + Top - Rhs;
+    C2F(stcreate)(&lw1, &ndim, (int *) dims, &nfields, (char **) field_names, &retval);
+    if( !retval) {
+        return (mxArray *) 0;
+    }
+    C2F(intersci).ntypes[lw-1]=AsIs;
+    return (mxArray *) C2F(vstk).lstk[lw + Top - Rhs - 1 ];
 }
 
 mxArray *mxCreateStructMatrix(int m, int n, int nfields, const char **field_names)
 {
-  static int lw,lw1;
-  int ndim;
-  int retval;
-  int dims[2];
+    static int lw,lw1;
+    int ndim;
+    int retval;
+    int dims[2];
 
-  dims[0] = m; dims[1] = n;
+    dims[0] = m; dims[1] = n;
 
-  Nbvars++;
-  lw = Nbvars;
-  lw1 = lw + Top - Rhs;
-  C2F(stcreate)(&lw1, (ndim=2, &ndim), dims, &nfields, (char **) field_names, &retval);
-  if( !retval) {
-    return (mxArray *) 0;
-  }
-  C2F(intersci).ntypes[lw-1]=AsIs;
-  return (mxArray *) C2F(vstk).lstk[lw + Top - Rhs - 1 ];
+    Nbvars++;
+    lw = Nbvars;
+    lw1 = lw + Top - Rhs;
+    C2F(stcreate)(&lw1, (ndim=2, &ndim), dims, &nfields, (char **) field_names, &retval);
+    if( !retval) {
+        return (mxArray *) 0;
+    }
+    C2F(intersci).ntypes[lw-1]=AsIs;
+    return (mxArray *) C2F(vstk).lstk[lw + Top - Rhs - 1 ];
 }
 
 void mxSetFieldByNumber(mxArray *array_ptr, int lindex, int field_number, mxArray *value)
 {
-  int pointed, point_ed;int proddims,k;int is1x1;
-  int *headerobj; int *headervalue;
-  int *header = Header(array_ptr);
-  int *headerdims = listentry(header,2);
-
-  proddims=1;
-  for (k=0; k<headerdims[1]*headerdims[2]; k++) {
-    proddims=proddims*headerdims[4+k];
-  }
-  is1x1= (int) proddims==1;
-
-  if (is1x1) {
-    headerobj = listentry( header, field_number+3);}
-  else {
-    headerobj = listentry( listentry(header, field_number+3)  ,lindex+1);}
-  if (IsReference(value))
+    int pointed, point_ed;int proddims,k;int is1x1;
+    int *headerobj; int *headervalue;
+    int *header = Header(array_ptr);
+    int *headerdims = listentry(header,2);
+
+    proddims=1;
+    for (k=0; k<headerdims[1]*headerdims[2]; k++) {
+        proddims=proddims*headerdims[4+k];
+    }
+    is1x1= (int) proddims==1;
+
+    if (is1x1) {
+        headerobj = listentry( header, field_number+3);}
+    else {
+        headerobj = listentry( listentry(header, field_number+3)  ,lindex+1);}
+    if (IsReference(value))
     {
-      headervalue = RawHeader(value);
-      headerobj[0] = headervalue[0];
-      headerobj[1] = headervalue[1];
-      headerobj[2] = headervalue[2];
-      headerobj[3] = headervalue[3];
+        headervalue = RawHeader(value);
+        headerobj[0] = headervalue[0];
+        headerobj[1] = headervalue[1];
+        headerobj[2] = headervalue[2];
+        headerobj[3] = headervalue[3];
     }
-  else
+    else
     {
-      pointed = arr2num(value);
-      point_ed = Top - Rhs + pointed;
-      headerobj[0]= - *istk( iadr(*Lstk( point_ed )) );  /* reference : 1st entry (type) is opposite */
-      headerobj[1]= *Lstk(point_ed);  /* pointed adress */
-      headerobj[2]= pointed; /* pointed variable */
-      headerobj[3]= *Lstk(point_ed + 1) - *Lstk(point_ed);  /* size of pointed variable */
+        pointed = arr2num(value);
+        point_ed = Top - Rhs + pointed;
+        headerobj[0]= - *istk( iadr(*Lstk( point_ed )) );  /* reference : 1st entry (type) is opposite */
+        headerobj[1]= *Lstk(point_ed);  /* pointed adress */
+        headerobj[2]= pointed; /* pointed variable */
+        headerobj[3]= *Lstk(point_ed + 1) - *Lstk(point_ed);  /* size of pointed variable */
     }
 }
 
 void mxSetField(mxArray *array_ptr, int lindex, const char *field_name, mxArray *value)
 {
-  int field_num;
-  field_num = mxGetFieldNumber(array_ptr, field_name);
-  mxSetFieldByNumber(array_ptr, lindex, field_num, value);
+    int field_num;
+    field_num = mxGetFieldNumber(array_ptr, field_name);
+    mxSetFieldByNumber(array_ptr, lindex, field_num, value);
 }
 
 const char *mxGetFieldNameByNumber(const mxArray *array_ptr, int field_number)
 {
-  int k, longueur, istart, nf, job;
-  int *headerstr;
-  int *header = Header(array_ptr);
-  char *str = (char *) mxMalloc_m(25*sizeof(char));
-  headerstr = listentry(header,1);
-  nf=headerstr[1]*headerstr[2]-2;  /* number of fields */
-  k=field_number;
-  if (k>nf) return (char *) 0;  /*  ?  */
-  longueur=Min(headerstr[7+k]-headerstr[6+k],nlgh);  /* size of kth fieldname */
-  istart=6+nf+headerstr[6+k];    /* start of kth fieldname code */
-  C2F(cvstr)(&longueur, &headerstr[istart], str, (job=1, &job),longueur);
-  str[longueur]='\0';
-  return str;
+    int k, longueur, istart, nf, job;
+    int *headerstr;
+    int *header = Header(array_ptr);
+    char *str = (char *) mxMalloc_m(25*sizeof(char));
+    headerstr = listentry(header,1);
+    nf=headerstr[1]*headerstr[2]-2;  /* number of fields */
+    k=field_number;
+    if (k>nf) return (char *) 0;  /*  ?  */
+    longueur=Min(headerstr[7+k]-headerstr[6+k],nlgh);  /* size of kth fieldname */
+    istart=6+nf+headerstr[6+k];    /* start of kth fieldname code */
+    C2F(cvstr)(&longueur, &headerstr[istart], str, (job=1, &job),longueur);
+    str[longueur]='\0';
+    return str;
 }
 
 /*
 mxCHAR *mxGetChars(mxArray *array_ptr)
 {
-  mexPrintf("%Not yet implemented\n");
+mexPrintf("%Not yet implemented\n");
 }  */
 
 
 int IsReference(mxArray *array_ptr)
 {
-  if ((int) RawHeader(array_ptr)[0]<0)
-    return 1;
-  else
-    return 0;
+    if ((int) RawHeader(array_ptr)[0]<0)
+        return 1;
+    else
+        return 0;
 }
 
-mxArray *mxCreateNumericArray(int ndim, const int *dims, mxClassID CLASS, mxComplexity cmplx)
-{
-  static int lw,lw1;
-  int retval;
-  if (ndim < 3) return mxCreateNumericMatrix(dims[0],dims[1], CLASS, cmplx);
-  Nbvars++;
-  lw = Nbvars;
-  lw1 = lw + Top - Rhs;
-  C2F(hmcreate)(&lw1, &ndim, (int *) dims, (int *) &CLASS, (int *) &cmplx,&retval);
-  if( !retval) {
-    return (mxArray *) 0;
-  }
-  C2F(intersci).ntypes[lw-1]=AsIs;
-  return (mxArray *) C2F(vstk).lstk[lw + Top - Rhs - 1 ];
-}
-
-mxArray *mxCreateNumericMatrix(int m, int n, mxClassID CLASS, int cmplx)
-{
-  static int lw,lw1;
-  int it;int lr;
-  switch (CLASS) {
-  case mxDOUBLE_CLASS:
-    return mxCreateDoubleMatrix(m, n, (mxComplexity)cmplx);
-  case mxINT8_CLASS:
-    Nbvars++;lw = Nbvars;  lw1 = lw + Top - Rhs;
-    if (! C2F(creimat)("  ", &lw1, (it=1, &it), &m, &n, &lr, 4L)) return (mxArray *) 0;
-    break;
-  case mxINT16_CLASS:
-    Nbvars++;lw = Nbvars;  lw1 = lw + Top - Rhs;
-    if (! C2F(creimat)("  ", &lw1, (it=2, &it), &m, &n, &lr, 4L)) return (mxArray *) 0;
-    break;
-  case mxINT32_CLASS:
-    Nbvars++;lw = Nbvars;  lw1 = lw + Top - Rhs;
-    if (! C2F(creimat)("  ", &lw1, (it=4, &it), &m, &n, &lr, 4L)) return (mxArray *) 0;
-    break;
-  case mxUINT8_CLASS:
-    Nbvars++;lw = Nbvars;  lw1 = lw + Top - Rhs;
-    if (! C2F(creimat)("  ", &lw1, (it=11, &it), &m, &n, &lr, 4L)) return (mxArray *) 0;
-    break;
-  case mxUINT16_CLASS:
-    Nbvars++;lw = Nbvars;  lw1 = lw + Top - Rhs;
-    if (! C2F(creimat)("  ", &lw1, (it=12, &it), &m, &n, &lr, 4L)) return (mxArray *) 0;
-    break;
-  case mxUINT32_CLASS:
-    Nbvars++;lw = Nbvars;  lw1 = lw + Top - Rhs;
-    if (! C2F(creimat)("  ", &lw1, (it=14, &it), &m, &n, &lr, 4L)) return (mxArray *) 0;
-    break;
-  default:
-    return (mxArray *) 0;
-  }
-  C2F(intersci).ntypes[lw-1]=AsIs;
-  return (mxArray *) C2F(vstk).lstk[lw + Top - Rhs - 1 ];
+mxArray *mxCreateNumericArray(int ndim, const int *dims, mxClassID CLASS, mxComplexity complexFlag)
+{
+    types::GenericType *ptr;
+
+    switch(CLASS)
+    {
+    case mxDOUBLE_CLASS : 
+        ptr = new types::Double(ndim, (int *) dims, complexFlag == mxCOMPLEX);
+        break;
+    case mxINT8_CLASS : 
+        ptr = new types::Int8(ndim, (int *) dims);
+        break;
+    case mxUINT8_CLASS : 
+        ptr = new types::UInt8(ndim, (int *) dims);
+        break;
+    case mxINT16_CLASS : 
+        ptr = new types::Int16(ndim, (int *) dims);
+        break;
+    case mxUINT16_CLASS : 
+        ptr = new types::UInt16(ndim, (int *) dims);
+        break;
+    case mxINT32_CLASS : 
+        ptr = new types::Int32(ndim, (int *) dims);
+        break;
+    case mxUINT32_CLASS : 
+        ptr = new types::UInt32(ndim, (int *) dims);
+        break;
+    case mxINT64_CLASS : 
+        ptr = new types::Int64(ndim, (int *) dims);
+        break;
+    case mxUINT64_CLASS : 
+        ptr = new types::UInt64(ndim, (int *) dims);
+        break;
+    default : 
+        return NULL;
+    }
+    return (mxArray *) ptr;
+}
+
+mxArray *mxCreateNumericMatrix(int m, int n, mxClassID CLASS, mxComplexity complexFlag)
+{
+    int dims[2] = {m, n};
+    return mxCreateNumericArray(2, dims, CLASS, complexFlag);
 }
 
 
 mxArray *mxCreateCharArray(int ndim, const int *dims)
 {
-  static int lw,lw1, CLASS, cmplx;
-  int retval;
-  Nbvars++;
-  lw = Nbvars;
-  lw1 = lw + Top - Rhs;
-  C2F(hmcreate)(&lw1, &ndim, (int *) dims, (CLASS=11, &CLASS),(cmplx=0, &cmplx),&retval);
-  if( !retval) {
-    return (mxArray *) 0;
-  }
-  C2F(intersci).ntypes[lw-1]=AsIs;
-  return (mxArray *) C2F(vstk).lstk[lw+ Top - Rhs - 1];  /* C2F(intersci).iwhere[lw-1])  */
+    static int lw,lw1, CLASS, cmplx;
+    int retval;
+    Nbvars++;
+    lw = Nbvars;
+    lw1 = lw + Top - Rhs;
+    C2F(hmcreate)(&lw1, &ndim, (int *) dims, (CLASS=11, &CLASS),(cmplx=0, &cmplx),&retval);
+    if( !retval) {
+        return (mxArray *) 0;
+    }
+    C2F(intersci).ntypes[lw-1]=AsIs;
+    return (mxArray *) C2F(vstk).lstk[lw+ Top - Rhs - 1];  /* C2F(intersci).iwhere[lw-1])  */
 }
 
 mxArray *mxCreateCellArray(int ndim, const int *dims)
 {
-  static int lw,lw1;
-  int retval;int *header;
-  int nfields;char *field_names[] = {"entries"};
-  Nbvars++;
-  lw = Nbvars;
-  lw1 = lw + Top - Rhs;
-  C2F(stcreate)(&lw1, &ndim, (int *) dims, (nfields=1,&nfields), field_names , &retval);
-  if( !retval) {
-    return (mxArray *) 0;
-  }
-  header =  (int *) stk(C2F(vstk).lstk[lw + Top - Rhs - 1 ]);
-  header[14]=12;header[15]=14; /*  "st" <-- "ce"  */
-  C2F(intersci).ntypes[lw-1]=AsIs;
-  return (mxArray *) C2F(vstk).lstk[lw + Top - Rhs - 1 ];
+    static int lw,lw1;
+    int retval;int *header;
+    int nfields;char *field_names[] = {"entries"};
+    Nbvars++;
+    lw = Nbvars;
+    lw1 = lw + Top - Rhs;
+    C2F(stcreate)(&lw1, &ndim, (int *) dims, (nfields=1,&nfields), field_names , &retval);
+    if( !retval) {
+        return (mxArray *) 0;
+    }
+    header =  (int *) stk(C2F(vstk).lstk[lw + Top - Rhs - 1 ]);
+    header[14]=12;header[15]=14; /*  "st" <-- "ce"  */
+    C2F(intersci).ntypes[lw-1]=AsIs;
+    return (mxArray *) C2F(vstk).lstk[lw + Top - Rhs - 1 ];
 }
 
 mxArray *mxCreateCellMatrix(int nrows, int ncols)
 {
-  int two=2;int dims[2];
-  dims[0] = nrows; dims[1] = ncols;
-  return mxCreateCellArray(two, dims);
+    int two=2;int dims[2];
+    dims[0] = nrows; dims[1] = ncols;
+    return mxCreateCellArray(two, dims);
 }
 
 mxArray *mxGetCell(const mxArray *ptr, int lindex)
 {
-  int kk,lw,isize;int proddims,k;int is1x1;
-  int *headerlist,*headerobj,*headerobjcopy;
-  int *header = Header(ptr);
-  int *headerdims = listentry(header,2);
-
-  proddims=1;
-  for (k=0; k<headerdims[1]*headerdims[2]; k++) {
-    proddims=proddims*headerdims[4+k];
-  }
-  is1x1= (int) proddims==1;
-
-  if (is1x1) {
-    headerobj = listentry( header, lindex+1);
-    isize = header[5]- header[4];
-  }
-  else {
-    headerlist = listentry(header,3);
-    headerobj = listentry(headerlist,lindex+1);
-    isize=headerlist[lindex+3]-headerlist[lindex+2];
-  }
-  Nbvars++;  lw=Nbvars;
-  CreateData(lw,isize*sizeof(double));
-  headerobjcopy=(int *) GetData(lw);
-  for (kk = 0; kk < 2*isize; ++kk) headerobjcopy[kk]=headerobj[kk];
-  C2F(intersci).ntypes[lw-1]=AsIs;
-  C2F(intersci).iwhere[lw-1]=C2F(vstk).lstk[lw+ Top - Rhs - 1];
-  return (mxArray *) C2F(intersci).iwhere[lw-1];
+    int kk,lw,isize;int proddims,k;int is1x1;
+    int *headerlist,*headerobj,*headerobjcopy;
+    int *header = Header(ptr);
+    int *headerdims = listentry(header,2);
+
+    proddims=1;
+    for (k=0; k<headerdims[1]*headerdims[2]; k++) {
+        proddims=proddims*headerdims[4+k];
+    }
+    is1x1= (int) proddims==1;
+
+    if (is1x1) {
+        headerobj = listentry( header, lindex+1);
+        isize = header[5]- header[4];
+    }
+    else {
+        headerlist = listentry(header,3);
+        headerobj = listentry(headerlist,lindex+1);
+        isize=headerlist[lindex+3]-headerlist[lindex+2];
+    }
+    Nbvars++;  lw=Nbvars;
+    CreateData(lw,isize*sizeof(double));
+    headerobjcopy=(int *) GetData(lw);
+    for (kk = 0; kk < 2*isize; ++kk) headerobjcopy[kk]=headerobj[kk];
+    C2F(intersci).ntypes[lw-1]=AsIs;
+    C2F(intersci).iwhere[lw-1]=C2F(vstk).lstk[lw+ Top - Rhs - 1];
+    return (mxArray *) C2F(intersci).iwhere[lw-1];
 }
 
 int mxGetFieldNumber(const mxArray *ptr, const char *string)
 {
-  int nf, longueur, istart, k, ilocal, retval;
-  int *headerstr;
-  static char str[nlgh];
-  int *header = Header(ptr);
-  headerstr = listentry(header,1);
-  nf=headerstr[1]*headerstr[2]-2;  /* number of fields */
-  retval=-1;
-  for (k=0; k<nf; k++) {
-    longueur=Min(headerstr[7+k]-headerstr[6+k],nlgh);  /* size of kth fieldname */
-    istart=6+nf+headerstr[6+k];    /* start of kth fieldname code */
-    /*    istart=8+headerstr[4+nf+k]; */
-    C2F(cvstr)(&longueur, &headerstr[istart], str, (ilocal=1, &ilocal),longueur);
-    str[longueur]='\0';
-    if (strcmp(string, str) == 0) {
-      retval=k;
-      break;}
-  }
-  return retval;
+    int nf, longueur, istart, k, ilocal, retval;
+    int *headerstr;
+    static char str[nlgh];
+    int *header = Header(ptr);
+    headerstr = listentry(header,1);
+    nf=headerstr[1]*headerstr[2]-2;  /* number of fields */
+    retval=-1;
+    for (k=0; k<nf; k++) {
+        longueur=Min(headerstr[7+k]-headerstr[6+k],nlgh);  /* size of kth fieldname */
+        istart=6+nf+headerstr[6+k];    /* start of kth fieldname code */
+        /*    istart=8+headerstr[4+nf+k]; */
+        C2F(cvstr)(&longueur, &headerstr[istart], str, (ilocal=1, &ilocal),longueur);
+        str[longueur]='\0';
+        if (strcmp(string, str) == 0) {
+            retval=k;
+            break;}
+    }
+    return retval;
 }
 
 mxArray *mxGetField(const mxArray *ptr, int lindex, const char *string)
 {
-  int kk,lw,isize,fieldnum;int proddims,k;int is1x1;
-  int *headerlist, *headerobj, *headerobjcopy;
-  int *header = Header(ptr);
-  int *headerdims = listentry(header,2);
-
-  fieldnum=mxGetFieldNumber(ptr, string);
-  if (fieldnum==-1) return (mxArray *) 0;
-
-  proddims=1;
-  for (k=0; k<headerdims[1]*headerdims[2]; k++) {
-    proddims=proddims*headerdims[4+k];
-  }
-  is1x1= (int) proddims==1;
-
-  if (is1x1) {
-    headerobj = listentry( header, 3+fieldnum);
-    isize = header[5+fieldnum]- header[4+fieldnum];
-  }
-  else {
-    headerlist = listentry(header,3+fieldnum);
-    headerobj = listentry(headerlist,lindex+1);
-    isize=headerlist[lindex+3]-headerlist[lindex+2];
-  }
-
-  Nbvars++; lw=Nbvars;
-  CreateData(lw,isize*sizeof(double));
-  headerobjcopy=(int *) GetData(lw);
-  for (kk = 0; kk < 2*isize; ++kk) headerobjcopy[kk]=headerobj[kk];
-  C2F(intersci).ntypes[lw-1]=AsIs;
-  C2F(intersci).iwhere[lw-1]=C2F(vstk).lstk[lw+ Top - Rhs - 1];
-  return (mxArray *) C2F(intersci).iwhere[lw-1];
+    int kk,lw,isize,fieldnum;int proddims,k;int is1x1;
+    int *headerlist, *headerobj, *headerobjcopy;
+    int *header = Header(ptr);
+    int *headerdims = listentry(header,2);
+
+    fieldnum=mxGetFieldNumber(ptr, string);
+    if (fieldnum==-1) return (mxArray *) 0;
+
+    proddims=1;
+    for (k=0; k<headerdims[1]*headerdims[2]; k++) {
+        proddims=proddims*headerdims[4+k];
+    }
+    is1x1= (int) proddims==1;
+
+    if (is1x1) {
+        headerobj = listentry( header, 3+fieldnum);
+        isize = header[5+fieldnum]- header[4+fieldnum];
+    }
+    else {
+        headerlist = listentry(header,3+fieldnum);
+        headerobj = listentry(headerlist,lindex+1);
+        isize=headerlist[lindex+3]-headerlist[lindex+2];
+    }
+
+    Nbvars++; lw=Nbvars;
+    CreateData(lw,isize*sizeof(double));
+    headerobjcopy=(int *) GetData(lw);
+    for (kk = 0; kk < 2*isize; ++kk) headerobjcopy[kk]=headerobj[kk];
+    C2F(intersci).ntypes[lw-1]=AsIs;
+    C2F(intersci).iwhere[lw-1]=C2F(vstk).lstk[lw+ Top - Rhs - 1];
+    return (mxArray *) C2F(intersci).iwhere[lw-1];
 }
 
 mxArray *mxGetFieldByNumber(const mxArray *ptr, int lindex, int field_number)
 {
-  int kk,lw,isize,fieldnum;int proddims,k;int is1x1;
-  int maxfieldnum, maxindex;
-  int *headerlist, *headerobj, *headerobjcopy;
-  int *header = Header(ptr);
-  int *headerdims = listentry(header,2);
-
-  fieldnum = field_number;
-  maxfieldnum = mxGetNumberOfFields(ptr)-1;
-  maxindex = mxGetNumberOfElements(ptr)-1;
-  if (maxfieldnum < fieldnum) return (mxArray *) NULL;
-  if (maxindex < lindex) return (mxArray *) NULL;
-
-  proddims=1;
-  for (k=0; k<headerdims[1]*headerdims[2]; k++) {
-    proddims=proddims*headerdims[4+k];
-  }
-  is1x1= (int) proddims==1;
-
-  if (is1x1) {
-    headerobj = listentry( header, 3+fieldnum);
-    isize = header[5+fieldnum]- header[4+fieldnum];
-  }
-  else {
-    headerlist = listentry(header,3+fieldnum);
-    headerobj = listentry(headerlist,lindex+1);
-    isize=headerlist[lindex+3]-headerlist[lindex+2];
-  }
-  if (isize==2) return (mxArray *) NULL; /* empty field */
-  Nbvars++; lw=Nbvars;
-  CreateData(lw,isize*sizeof(double));
-  headerobjcopy=(int *)GetData(lw);
-  for (kk = 0; kk < 2*isize; ++kk) headerobjcopy[kk]=headerobj[kk];
-  C2F(intersci).ntypes[lw-1]=AsIs;
-  C2F(intersci).iwhere[lw-1]=C2F(vstk).lstk[lw+ Top - Rhs - 1];
-  return (mxArray *) C2F(intersci).iwhere[lw-1];
+    int kk,lw,isize,fieldnum;int proddims,k;int is1x1;
+    int maxfieldnum, maxindex;
+    int *headerlist, *headerobj, *headerobjcopy;
+    int *header = Header(ptr);
+    int *headerdims = listentry(header,2);
+
+    fieldnum = field_number;
+    maxfieldnum = mxGetNumberOfFields(ptr)-1;
+    maxindex = mxGetNumberOfElements(ptr)-1;
+    if (maxfieldnum < fieldnum) return (mxArray *) NULL;
+    if (maxindex < lindex) return (mxArray *) NULL;
+
+    proddims=1;
+    for (k=0; k<headerdims[1]*headerdims[2]; k++) {
+        proddims=proddims*headerdims[4+k];
+    }
+    is1x1= (int) proddims==1;
+
+    if (is1x1) {
+        headerobj = listentry( header, 3+fieldnum);
+        isize = header[5+fieldnum]- header[4+fieldnum];
+    }
+    else {
+        headerlist = listentry(header,3+fieldnum);
+        headerobj = listentry(headerlist,lindex+1);
+        isize=headerlist[lindex+3]-headerlist[lindex+2];
+    }
+    if (isize==2) return (mxArray *) NULL; /* empty field */
+    Nbvars++; lw=Nbvars;
+    CreateData(lw,isize*sizeof(double));
+    headerobjcopy=(int *)GetData(lw);
+    for (kk = 0; kk < 2*isize; ++kk) headerobjcopy[kk]=headerobj[kk];
+    C2F(intersci).ntypes[lw-1]=AsIs;
+    C2F(intersci).iwhere[lw-1]=C2F(vstk).lstk[lw+ Top - Rhs - 1];
+    return (mxArray *) C2F(intersci).iwhere[lw-1];
 }
 
 int mxGetNumberOfFields(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  if (header[0]==MLIST) return header[1]-2;
-  else return 0;
+    int *header = Header(ptr);
+    if (header[0]==MLIST) return header[1]-2;
+    else return 0;
 }
 
 /*----------------------------------------------------
- * mxCalloc is supposed to initialize data to 0
- * but what does it means since size can be anythink
- * we initialize to zero for double and int data types
- *----------------------------------------------------*/
+* mxCalloc is supposed to initialize data to 0
+* but what does it means since size can be anythink
+* we initialize to zero for double and int data types
+*----------------------------------------------------*/
 
 
 void *mxRealloc(void *ptr, size_t nsize)
 {
-  int m;  vraiptrst lrd=(vraiptrst)NULL;
-  m = (int) ((nsize) /sizeof(double) + 1);
-  mxFree((void *) lrd);
-  if (! C2F(createstkptr)( &m, &lrd)) return 0;
-  memcpy((void *) lrd, ptr, nsize);
-  return (void *) lrd;
+    int m;  vraiptrst lrd=(vraiptrst)NULL;
+    m = (int) ((nsize) /sizeof(double) + 1);
+    mxFree((void *) lrd);
+    if (! C2F(createstkptr)( &m, &lrd)) return 0;
+    memcpy((void *) lrd, ptr, nsize);
+    return (void *) lrd;
 }
 
 void *mxCalloc(size_t n, size_t size)
 {
-  int m;  vraiptrst lrd;
-  static int one=1; int N;
-  static double zero = 0.0;
-  int nsize;
-  nsize=(int)(n*size);
-  m = nsize /sizeof(double) + 1;
-  if (! C2F(createstkptr)( &m, &lrd)) {
-    return 0;
-  }
-  if ( size ==  sizeof(double))
+    int m;  vraiptrst lrd;
+    static int one=1; int N;
+    static double zero = 0.0;
+    int nsize;
+    nsize=(int)(n*size);
+    m = nsize /sizeof(double) + 1;
+    if (! C2F(createstkptr)( &m, &lrd)) {
+        return 0;
+    }
+    if ( size ==  sizeof(double))
     {
-      N=(int) n; C2F(dset)(&N, &zero, (double *) lrd,&one);
+        N=(int) n; C2F(dset)(&N, &zero, (double *) lrd,&one);
     }
-  else
+    else
     {
-      int i;
-      for (i=0; i < nsize ; i++) ((char *) lrd)[i]=0;
+        int i;
+        for (i=0; i < nsize ; i++) ((char *) lrd)[i]=0;
     }
-  return (void *) lrd;
+    return (void *) lrd;
 }
 
 /*  void *mxMalloc(unsigned int nsize)  */
 void *mxMalloc(size_t nsize)
 {
-  int m;  vraiptrst lrd;
-  m = (int)((nsize) /sizeof(double) + 1);
-  if (! C2F(createstkptr)( &m, &lrd)) {
-    return 0;
-  }
-  return (void *) lrd;
+    int m;  vraiptrst lrd;
+    m = (int)((nsize) /sizeof(double) + 1);
+    if (! C2F(createstkptr)( &m, &lrd)) {
+        return 0;
+    }
+    return (void *) lrd;
 }
 
 /* a version which make use of malloc */
 
 typedef struct _rec_calloc {
-  void *adr;
-  int  keep; /* 0: free 1: allocated 2: allocated and must be preserved */
+    void *adr;
+    int  keep; /* 0: free 1: allocated 2: allocated and must be preserved */
 } rec_calloc;
 
 #define rec_size 512
@@ -1378,137 +1334,109 @@ static rec_calloc calloc_table[rec_size]={{0,0}};
 
 void *mxCalloc_m(unsigned int n, unsigned int size)
 {
-  void *loc = CALLOC(n,size);
-  if ( loc != NULL) {
-    int i;
-    for ( i = 0 ; i < rec_size ; i++)
-      {
-       if (calloc_table[i].keep == 0 )
-         {
-           /* sciprint("calloc installed at position %d\n",i); */
-           calloc_table[i].adr = loc;
-           calloc_table[i].keep = 1;
-           return loc ;
-         }
-      }
-    FREE(loc);
+    void *loc = CALLOC(n,size);
+    if ( loc != NULL) {
+        int i;
+        for ( i = 0 ; i < rec_size ; i++)
+        {
+            if (calloc_table[i].keep == 0 )
+            {
+                /* sciprint("calloc installed at position %d\n",i); */
+                calloc_table[i].adr = loc;
+                calloc_table[i].keep = 1;
+                return loc ;
+            }
+        }
+        FREE(loc);
+        return NULL;
+    }
     return NULL;
-  }
-  return NULL;
 }
 
 void *mxMalloc_m(unsigned int n)
 {
-  void *loc = MALLOC(n);
-  if ( loc != NULL) {
-    int i;
-    for ( i = 0 ; i < rec_size ; i++)
-      {
-       if (calloc_table[i].keep == 0 )
-         {
-           /* sciprint("malloc installed at position %d\n",i); */
-           calloc_table[i].adr = loc;
-           calloc_table[i].keep = 1;
-           return loc ;
-         }
-      }
-    FREE(loc);
+    void *loc = MALLOC(n);
+    if ( loc != NULL) {
+        int i;
+        for ( i = 0 ; i < rec_size ; i++)
+        {
+            if (calloc_table[i].keep == 0 )
+            {
+                /* sciprint("malloc installed at position %d\n",i); */
+                calloc_table[i].adr = loc;
+                calloc_table[i].keep = 1;
+                return loc ;
+            }
+        }
+        FREE(loc);
+        return NULL;
+    }
     return NULL;
-  }
-  return NULL;
 }
 
 
 void mexMakeMemoryPersistent(void *ptr) {
-  int i;
-  for ( i = 0 ; i < rec_size ; i++) {
-    if (calloc_table[i].adr == ptr)
-      {
-       if  (calloc_table[i].keep == 1 )
-         {
-           calloc_table[i].keep = 2;
-         }
-      }
-  }
+    int i;
+    for ( i = 0 ; i < rec_size ; i++) {
+        if (calloc_table[i].adr == ptr)
+        {
+            if  (calloc_table[i].keep == 1 )
+            {
+                calloc_table[i].keep = 2;
+            }
+        }
+    }
 }
 
 /* free : explicit free of a mxCalloc_m allocated space
- *        except if space is protected
- */
+*        except if space is protected
+*/
 
 void mxFree_m(void *ptr){
-  int i;
-
-  for ( i = 0 ; i < rec_size ; i++) {
-    if (calloc_table[i].adr == ptr)
-      {
-       /* allocated and preserved */
-       if  (calloc_table[i].keep != 0 )
-         {
-           /* sciprint("mxFree position %d\n",i); */
-           FREE(ptr);
-           calloc_table[i].keep = 0;
-           calloc_table[i].adr = NULL;
-           return;
-         }
-      }
-  }
+    int i;
+
+    for ( i = 0 ; i < rec_size ; i++) {
+        if (calloc_table[i].adr == ptr)
+        {
+            /* allocated and preserved */
+            if  (calloc_table[i].keep != 0 )
+            {
+                /* sciprint("mxFree position %d\n",i); */
+                FREE(ptr);
+                calloc_table[i].keep = 0;
+                calloc_table[i].adr = NULL;
+                return;
+            }
+        }
+    }
 }
 
 /* free : explicit free of all mxCalloc_m allocated space
- *        except if space is protected
- */
+*        except if space is protected
+*/
 
 static void mxFree_m_all() {
-  int i;
-  for ( i = 0 ; i < rec_size ; i++) {
-    if  (calloc_table[i].keep == 1 )
-      {
-       /* sciprint("mxFree all position %d\n",i); */
-        FREE(calloc_table[i].adr);
-       calloc_table[i].keep = 0;
-       calloc_table[i].adr = NULL;
-      }
-  }
+    int i;
+    for ( i = 0 ; i < rec_size ; i++) {
+        if  (calloc_table[i].keep == 1 )
+        {
+            /* sciprint("mxFree all position %d\n",i); */
+            FREE(calloc_table[i].adr);
+            calloc_table[i].keep = 0;
+            calloc_table[i].adr = NULL;
+        }
+    }
 }
 
 
-/*----------------------------------------------------
- * mxCalloc is supposed to initialize data to 0
- * but what does it means since size can be anythink
- * we initialize to zero for double and int data types
- *----------------------------------------------------*/
-
 bool mxIsCell(const mxArray *ptr)
 {
-  int *header1; int l;
-  int *header = Header(ptr);
-
-  /* mlist(["ce","dims","entries"],[d1,..,dk],list(...)) */
-  if (header[0]==MLIST) {
-    header1 = (int *) listentry(header,1);
-    l = 8;
-  /*  "c"=12,  "e"=14   */
-    if (header1[0]==STRINGMATRIX && header1[l]==12 && header1[l+1]==14) return 1;
-    else return 0;
-      }
-  else return 0;
+    return mxGetClassID(ptr)==mxCELL_CLASS;
 }
 
 bool mxIsStruct(const mxArray *ptr)
 {
-  int *header1; int nfplus2, l;
-  int *header = Header(ptr);
-  /* mlist(["st","dims","field1",...,"fieldp"],[d1,..,dk],list1(...),listp(...)) */
-  if (header[0]==MLIST) {
-    header1 = (int *) listentry(header,1);
-    nfplus2 = header1[1]*header1[2];
-    l = 5 + nfplus2;
-  /*  "s"=28,  "t"=29   */
-    if (header1[0]==STRINGMATRIX && header1[l]==28 && header1[l+1]==29) return 1;
-    else return 0;
-  }
-  else return 0;
+    return mxGetClassID(ptr)==mxSTRUCT_CLASS;
 }
 
 int IsstOrce(mxArray *ptr)
@@ -1541,1271 +1469,1185 @@ int IsstOrce(mxArray *ptr)
 }
 
 /***************************************************************
- * Return in str at most strl characters from first element of
- * string Matrix pointed to by ptr ( ptr is assumed to be a String Matrix )
- **************************************************************/
+* Return in str at most strl characters from first element of
+* string Matrix pointed to by ptr ( ptr is assumed to be a String Matrix )
+**************************************************************/
 
 int mxGetString(const mxArray *ptr, char *str, int strl)
 {
-  int commonrowlength, totallength, firstchain, nrows;
-  int *header = Header(ptr);
+    int commonrowlength, totallength, firstchain, nrows;
+    int *header = Header(ptr);
 
-  /*  int ncols = header[2]; This is 1 */
+    /*  int ncols = header[2]; This is 1 */
 
-  if (header[0] != STRINGMATRIX) return 1;
-  nrows = header[1];
-  commonrowlength=header[5]-header[4];
-  totallength=nrows*commonrowlength;
-  firstchain=5+nrows;
-  C2F(in2str)(&totallength, &header[firstchain], str,0L);
-  if (strl < totallength) return 1;
-  return 0;
+    if (header[0] != STRINGMATRIX) return 1;
+    nrows = header[1];
+    commonrowlength=header[5]-header[4];
+    totallength=nrows*commonrowlength;
+    firstchain=5+nrows;
+    C2F(in2str)(&totallength, &header[firstchain], str,0L);
+    if (strl < totallength) return 1;
+    return 0;
 }
 
 char *mxArrayToString(const mxArray *array_ptr)
 {
-  int commonrowlength, nrows, buflen;
-  char *buf;
-  int *header = Header(array_ptr);
+    int commonrowlength, nrows, buflen;
+    char *buf;
+    int *header = Header(array_ptr);
 
-  nrows = header[1];
-  commonrowlength=header[5]-header[4];
-  buflen=nrows*commonrowlength;
-  buf = (char *) mxCalloc(buflen, sizeof(char));
-  if (mxGetString(array_ptr, buf, buflen) == 0) return (char *) buf;
-  return (char *) 0;
+    nrows = header[1];
+    commonrowlength=header[5]-header[4];
+    buflen=nrows*commonrowlength;
+    buf = (char *) mxCalloc(buflen, sizeof(char));
+    if (mxGetString(array_ptr, buf, buflen) == 0) return (char *) buf;
+    return (char *) 0;
 }
 
 /*-------------------------------------------------
- * mxFreeMatrix :
- * mxFreeMatrix will do something only if it is called
- * in the reverse order of variable allocation
- * Thus after calling mexCallScilab in order to
- * free the stack, one has to call mxFree as in the
- * following example :
- *
- * int nlhs = 3; int nrhs = 2;
- * rhs[0] = mxCreateString(filename);
- * rhs[1] = mxCreateFull(1,1,REAL);
- * mexCallMATLAB(nlhs, lhs, nrhs, rhs, "gm_ifile");
- *  free space in reverse order
- * for (i= nlhs -1 ; i >=0 ; i--) mxFreeMatrix(lhs[i]);
- * for (i= rhs -1 ; i >=0 ; i--) mxFreeMatrix(rhs[i]);
- *-------------------------------------------------*/
+* mxFreeMatrix :
+* mxFreeMatrix will do something only if it is called
+* in the reverse order of variable allocation
+* Thus after calling mexCallScilab in order to
+* free the stack, one has to call mxFree as in the
+* following example :
+*
+* int nlhs = 3; int nrhs = 2;
+* rhs[0] = mxCreateString(filename);
+* rhs[1] = mxCreateFull(1,1,REAL);
+* mexCallMATLAB(nlhs, lhs, nrhs, rhs, "gm_ifile");
+*  free space in reverse order
+* for (i= nlhs -1 ; i >=0 ; i--) mxFreeMatrix(lhs[i]);
+* for (i= rhs -1 ; i >=0 ; i--) mxFreeMatrix(rhs[i]);
+*-------------------------------------------------*/
 
 void mxFreeMatrix(mxArray *ptr)
 {
-  /* If we free the last stored object we can decrement Nbvars */
-  if ( (long)ptr == C2F(vstk).lstk[Top - Rhs + Nbvars - 1]) {
-    /* sciprint("XXXX OK %dvar %d\n",(int)ptr,Nbvars); */
-    Nbvars--;
-  }
-  else {
-    /* sciprint("XXXX Fail %d var %d\n",(int)ptr,Nbvars); */
-  }
-  /* Automatically freed when return from mexfunction */
-  return ;
+    /* If we free the last stored object we can decrement Nbvars */
+    if ( (long)ptr == C2F(vstk).lstk[Top - Rhs + Nbvars - 1]) {
+        /* sciprint("XXXX OK %dvar %d\n",(int)ptr,Nbvars); */
+        Nbvars--;
+    }
+    else {
+        /* sciprint("XXXX Fail %d var %d\n",(int)ptr,Nbvars); */
+    }
+    /* Automatically freed when return from mexfunction */
+    return ;
 }
 
 void  numberandsize(const mxArray  *ptr, int *number, int *size)
-     /* utility fct : its number as scilab variable
-      * and its size in Scilab double stack */
-{
-  int kk;
-  long lst_k;
-  lst_k=(long) ptr;
-  if (lst_k < *Lstk(Bot)) {
-    *number=0;*size=0;
-  for (kk = 1; kk <= Nbvars; kk++)
-    {
-      *number=kk;
-      if (lst_k == C2F(vstk).lstk[kk+ Top - Rhs -1]) break;
-    }
-  *size = C2F(vstk).lstk[*number+ Top - Rhs] - lst_k;
-  } else
-    {
-    *number=0;
-  for (kk = Bot; kk <  C2F(vstk).isiz; kk++)
+    /* utility fct : its number as scilab variable
+    * and its size in Scilab double stack */
+{
+    int kk;
+    long lst_k;
+    lst_k=(long) ptr;
+    if (lst_k < *Lstk(Bot)) {
+        *number=0;*size=0;
+        for (kk = 1; kk <= Nbvars; kk++)
+        {
+            *number=kk;
+            if (lst_k == C2F(vstk).lstk[kk+ Top - Rhs -1]) break;
+        }
+        *size = C2F(vstk).lstk[*number+ Top - Rhs] - lst_k;
+    } else
     {
-      *number=kk;
-      if (lst_k == C2F(vstk).lstk[kk-1]) break;
-    }
-  *size = C2F(vstk).lstk[*number] - lst_k;
+        *number=0;
+        for (kk = Bot; kk <  C2F(vstk).isiz; kk++)
+        {
+            *number=kk;
+            if (lst_k == C2F(vstk).lstk[kk-1]) break;
+        }
+        *size = C2F(vstk).lstk[*number] - lst_k;
     }
 }
 
 
 int arr2num( mxArray  *ptr )
 {
-  int kk,number;
-  long lst_k;
-  lst_k=(long) ptr;
-  if (lst_k < *Lstk(Bot)) {
-    number=0;
-  for (kk = 1; kk <= Nbvars; kk++)
-    {
-      number=kk;
-      if (lst_k == C2F(vstk).lstk[kk+ Top - Rhs -1]) break;
-    }
-  return number;
-  } else
-    {
-    number=0;
-  for (kk = Bot; kk <  C2F(vstk).isiz; kk++)
+    int kk,number;
+    long lst_k;
+    lst_k=(long) ptr;
+    if (lst_k < *Lstk(Bot)) {
+        number=0;
+        for (kk = 1; kk <= Nbvars; kk++)
+        {
+            number=kk;
+            if (lst_k == C2F(vstk).lstk[kk+ Top - Rhs -1]) break;
+        }
+        return number;
+    } else
     {
-      number=kk;
-      if (lst_k == C2F(vstk).lstk[kk-1]) break;
-    }
-  return number;
+        number=0;
+        for (kk = Bot; kk <  C2F(vstk).isiz; kk++)
+        {
+            number=kk;
+            if (lst_k == C2F(vstk).lstk[kk-1]) break;
+        }
+        return number;
     }
 }
 
 int arr2numcst(const mxArray  *ptr )
 {
-  int kk,number;
-  long lst_k;
-  lst_k=(long) ptr;
-  if (lst_k < *Lstk(Bot)) {
-    number=0;
-  for (kk = 1; kk <= Nbvars; kk++)
-    {
-      number=kk;
-      if (lst_k == C2F(vstk).lstk[kk+ Top - Rhs -1]) break;
-    }
-  return number;
-  } else
-    {
-    number=0;
-  for (kk = Bot; kk <  C2F(vstk).isiz; kk++)
+    int kk,number;
+    long lst_k;
+    lst_k=(long) ptr;
+    if (lst_k < *Lstk(Bot)) {
+        number=0;
+        for (kk = 1; kk <= Nbvars; kk++)
+        {
+            number=kk;
+            if (lst_k == C2F(vstk).lstk[kk+ Top - Rhs -1]) break;
+        }
+        return number;
+    } else
     {
-      number=kk;
-      if (lst_k == C2F(vstk).lstk[kk-1]) break;
-    }
-  return number;
+        number=0;
+        for (kk = Bot; kk <  C2F(vstk).isiz; kk++)
+        {
+            number=kk;
+            if (lst_k == C2F(vstk).lstk[kk-1]) break;
+        }
+        return number;
     }
 }
 
 bool mexIsGlobal(const mxArray *ptr)
 {
-  int pointed;
-  int ret_val;
-  int *header;int *rheader;
-  header=(int *) Header(ptr);
-  rheader=(int *) RawHeader(ptr);
-  pointed = arr2numcst(ptr);
-  /*  A FINIR si interface par reference OK
-      printf("POINTED %i Infstk(pointed) %i\n", pointed, *Infstk(pointed));
-      printf("header[2] %i Infstk(pointed) %i\n", header[2], *Infstk(header[2])); */
-  pointed=header[2];
-  if (*Infstk(pointed) == 2)
-   ret_val = 1;
-  else
-   ret_val = 0;
-  return ret_val;
+    int pointed;
+    int ret_val;
+    int *header;int *rheader;
+    header=(int *) Header(ptr);
+    rheader=(int *) RawHeader(ptr);
+    pointed = arr2numcst(ptr);
+    /*  A FINIR si interface par reference OK
+    printf("POINTED %i Infstk(pointed) %i\n", pointed, *Infstk(pointed));
+    printf("header[2] %i Infstk(pointed) %i\n", header[2], *Infstk(header[2])); */
+    pointed=header[2];
+    if (*Infstk(pointed) == 2)
+        ret_val = 1;
+    else
+        ret_val = 0;
+    return ret_val;
 }
 
 
 mxArray *mxDuplicateArray(const mxArray *ptr)
 {
-  long start_in;
-  int lw, number, size, k;
-  double *old , *data;
-  start_in = (long) ptr;
-  if ( istk( iadr(start_in) )[0] < 0 ) {
-    /*   variable is a reference : the reference is copied */
-    size = istk( iadr(start_in) )[2];
-    old = stk( istk(iadr(start_in))[1] );
-  }
-  else {
-    numberandsize(ptr, &number, &size);
-    old = stk(start_in);
-  }
-  Nbvars++; lw = Nbvars;
-  CreateData(lw, size*sizeof(double));
-  data = (double *) GetRawData(lw);
-  for (k = 0; k <size; ++k)
-    data[k]=old[k];
-  return (mxArray *) C2F(vstk).lstk[lw+ Top - Rhs - 1];
+    types::InternalType* pIT = (types::InternalType*)ptr;
+    if(pIT == NULL)
+    {
+        return 0;
+    }
+
+    return (mxArray *) pIT->clone();
 }
 
 mxArray *UnrefStruct(mxArray *ptr)
 {
-  /*   Unreference objects in a struct or cell */
-  int number, k;
-  int list, lindex, offset; int sizeobj;
-  int nb, nbobj, suite, newbot;
-
-  int oldsize, newsize;
-
-  int *header, *headernew;
-  int *headerlist, *headerlistnew;
-  int *headerobj, *headerobjnew;
-  int *headerdims; int proddims;int obj;
-
-  mxArray *mxNew;
-  header = Header(ptr);   /* RawHeader ?  */
-  mxNew = mxDuplicateArray(ptr);
-  headernew = Header(mxNew);   /* RawHeader ?  */
-
-  offset = Top - Rhs;
-  newsize=header[4];   /* Initialize */
-  nb=header[1]-2;      /* Number of fields  */
-  headerdims = listentry(header,2);
-  proddims=1;
-  for (k=0; k<headerdims[1]*headerdims[2]; k++) {
-    proddims=proddims*headerdims[4+k];
-  }
-  if (!(proddims==1)) {
-    suite=0;
-    for (list=0; list<nb; list++) {
-      headerlist= listentry(header, list+3);  /* pointing to the field list */
-      nbobj=headerlist[1];   /* number of objects in the field */
-      for (lindex=0; lindex < nbobj; lindex++)
-       {
-         headerobj = listentry( headerlist,lindex+1);
-         /* pointing to the object in the field */
-         if (headerobj[0] < 0)
-           sizeobj=headerobj[3];
-         else
-           sizeobj=headerlist[lindex+3]-headerlist[lindex+2];
-         newsize += sizeobj;   /* update size of the field */
-       }
-      suite++;
-      newsize += (2+nbobj/2);   /* size of list = size of inside + ... */
-      headernew[4+suite] = newsize;
-    }
-    numberandsize( mxNew, &number, &oldsize);
-    newsize += 3;   /* taking account begining of list */
-    newbot=*Lstk(number+offset)+newsize+1;
-    if( (newbot - *Lstk(Bot)) > 0)
-      {SciError(17); return 0;}
-    *Lstk(number+offset+1)=newbot;
-    for (list=0; list<nb; list++) {
-      headerlist= listentry(header, list+3);
-      headerlistnew=listentry(headernew, list+3);
-      nbobj=headerlist[1];
-      headerlistnew[0]= 15;
-      headerlistnew[1]= nbobj;
-      headerlistnew[2]= 1;
-      for (lindex=0; lindex < nbobj; lindex++)
-       {       headerobj = listentry( headerlist,lindex+1);
-       if (headerobj[0] < 0)
-         sizeobj=headerobj[3];  /* reference (size of ) */
-       else
-         sizeobj=headerlist[lindex+3]-headerlist[lindex+2];
-       headerlistnew[3+lindex]=headerlistnew[2+lindex]+sizeobj;
-       }
-    }
-    for (list=0; list<nb; list++) {
-      headerlist= listentry(header, list+3);
-      headerlistnew=listentry(headernew, list+3);
-      nbobj=headerlist[1];
-      for (lindex=0; lindex < nbobj; lindex++)
-       {
-         headerobj = listentry( headerlist,lindex+1);
-         headerobjnew = listentry( headerlistnew,lindex+1);
-         if (headerobj[0] < 0)   /* reference */
-           {
-             sizeobj=headerobj[3];
-             headerobj = (int *) stk(headerobj[1]);   /* dereference */
-           }
-         else
-           {
-             sizeobj=headerlist[lindex+3]-headerlist[lindex+2];
-           }
-         for (k=0; k<2*sizeobj; k++)
-           headerobjnew[k]=headerobj[k];  /* OUF! */
-       }
-    }
-  }
-  else {
-    /*   1 x 1 x ... x 1 struct */
-    suite=0;
-    for (obj=0; obj<nb; obj++) {
-      headerobj = listentry(header,3+obj);
-      if (headerobj[0] < 0)
-       sizeobj=headerobj[3];
-      else
-       sizeobj = header[5+obj] - header[4+obj];
-      newsize += sizeobj;
-    suite++;
-    newsize += sizeobj;
-    headernew[4+suite]=newsize;
-    }
-    numberandsize( mxNew, &number, &oldsize);
-    newsize +=3;
-    newbot = *Lstk(number+offset)+newsize+1;
-    if ( (newbot - *Lstk(Bot)) > 0)
-      {SciError(17); return 0;}
-    *Lstk(number+offset+1)=newbot;
-    for (obj=0; obj<nb; obj++)
-      {
-       headerobj = listentry(header, 3+obj);
-       headerobjnew = listentry(headernew, 3+obj);
-       if (headerobj[0] < 0)
-         {
-           sizeobj=headerobj[3];
-           headerobj = (int *) stk(headerobj[1]);
-         }
-       else
-         {
-           sizeobj=header[5+obj]-header[4+obj];
-         }
-       for (k=0; k<2*sizeobj; k++)
-         headerobjnew[k]=headerobj[k];
-      }
-  }
-  return mxNew;
+    /*   Unreference objects in a struct or cell */
+    int number, k;
+    int list, lindex, offset; int sizeobj;
+    int nb, nbobj, suite, newbot;
+
+    int oldsize, newsize;
+
+    int *header, *headernew;
+    int *headerlist, *headerlistnew;
+    int *headerobj, *headerobjnew;
+    int *headerdims; int proddims;int obj;
+
+    mxArray *mxNew;
+    header = Header(ptr);   /* RawHeader ?  */
+    mxNew = mxDuplicateArray(ptr);
+    headernew = Header(mxNew);   /* RawHeader ?  */
+
+    offset = Top - Rhs;
+    newsize=header[4];   /* Initialize */
+    nb=header[1]-2;      /* Number of fields  */
+    headerdims = listentry(header,2);
+    proddims=1;
+    for (k=0; k<headerdims[1]*headerdims[2]; k++) {
+        proddims=proddims*headerdims[4+k];
+    }
+    if (!(proddims==1)) {
+        suite=0;
+        for (list=0; list<nb; list++) {
+            headerlist= listentry(header, list+3);  /* pointing to the field list */
+            nbobj=headerlist[1];   /* number of objects in the field */
+            for (lindex=0; lindex < nbobj; lindex++)
+            {
+                headerobj = listentry( headerlist,lindex+1);
+                /* pointing to the object in the field */
+                if (headerobj[0] < 0)
+                    sizeobj=headerobj[3];
+                else
+                    sizeobj=headerlist[lindex+3]-headerlist[lindex+2];
+                newsize += sizeobj;   /* update size of the field */
+            }
+            suite++;
+            newsize += (2+nbobj/2);   /* size of list = size of inside + ... */
+            headernew[4+suite] = newsize;
+        }
+        numberandsize( mxNew, &number, &oldsize);
+        newsize += 3;   /* taking account begining of list */
+        newbot=*Lstk(number+offset)+newsize+1;
+        if( (newbot - *Lstk(Bot)) > 0)
+        {SciError(17); return 0;}
+        *Lstk(number+offset+1)=newbot;
+        for (list=0; list<nb; list++) {
+            headerlist= listentry(header, list+3);
+            headerlistnew=listentry(headernew, list+3);
+            nbobj=headerlist[1];
+            headerlistnew[0]= 15;
+            headerlistnew[1]= nbobj;
+            headerlistnew[2]= 1;
+            for (lindex=0; lindex < nbobj; lindex++)
+            {  headerobj = listentry( headerlist,lindex+1);
+            if (headerobj[0] < 0)
+                sizeobj=headerobj[3];  /* reference (size of ) */
+            else
+                sizeobj=headerlist[lindex+3]-headerlist[lindex+2];
+            headerlistnew[3+lindex]=headerlistnew[2+lindex]+sizeobj;
+            }
+        }
+        for (list=0; list<nb; list++) {
+            headerlist= listentry(header, list+3);
+            headerlistnew=listentry(headernew, list+3);
+            nbobj=headerlist[1];
+            for (lindex=0; lindex < nbobj; lindex++)
+            {
+                headerobj = listentry( headerlist,lindex+1);
+                headerobjnew = listentry( headerlistnew,lindex+1);
+                if (headerobj[0] < 0)   /* reference */
+                {
+                    sizeobj=headerobj[3];
+                    headerobj = (int *) stk(headerobj[1]);   /* dereference */
+                }
+                else
+                {
+                    sizeobj=headerlist[lindex+3]-headerlist[lindex+2];
+                }
+                for (k=0; k<2*sizeobj; k++)
+                    headerobjnew[k]=headerobj[k];  /* OUF! */
+            }
+        }
+    }
+    else {
+        /*   1 x 1 x ... x 1 struct */
+        suite=0;
+        for (obj=0; obj<nb; obj++) {
+            headerobj = listentry(header,3+obj);
+            if (headerobj[0] < 0)
+                sizeobj=headerobj[3];
+            else
+                sizeobj = header[5+obj] - header[4+obj];
+            newsize += sizeobj;
+            suite++;
+            newsize += sizeobj;
+            headernew[4+suite]=newsize;
+        }
+        numberandsize( mxNew, &number, &oldsize);
+        newsize +=3;
+        newbot = *Lstk(number+offset)+newsize+1;
+        if ( (newbot - *Lstk(Bot)) > 0)
+        {SciError(17); return 0;}
+        *Lstk(number+offset+1)=newbot;
+        for (obj=0; obj<nb; obj++)
+        {
+            headerobj = listentry(header, 3+obj);
+            headerobjnew = listentry(headernew, 3+obj);
+            if (headerobj[0] < 0)
+            {
+                sizeobj=headerobj[3];
+                headerobj = (int *) stk(headerobj[1]);
+            }
+            else
+            {
+                sizeobj=header[5+obj]-header[4+obj];
+            }
+            for (k=0; k<2*sizeobj; k++)
+                headerobjnew[k]=headerobj[k];
+        }
+    }
+    return mxNew;
 }
 
 void mxDestroyArray(mxArray *ptr)
 {   /* No need */
-  return;
+    return;
 }
 
 void mxFree(void *ptr)
 {
-  double *header;int *iheader;
-  /* If we free the last stored object we can decrement Nbvars */
-  if ( Nbvars >= 1) {
-    iheader = istk(iadr(C2F(intersci).iwhere[Nbvars-1] ) );
-    /*  printf("MxFree iheader,%i %i %i %i\n", iheader[0],iheader[1],iheader[2],iheader[3]);   */
-    if ( !(iheader[0]==1) ) return;
-    header=stk(C2F(intersci).iwhere[Nbvars-1]);
-    /*    if ( !(C2F(locptr)(stk(C2F(intersci).lad[Nbvars - 1])) == C2F(locptr)((&header[2])))) return;  */
-    if ( (vraiptrst) ptr ==  C2F(locptr)(&header[2]))
-      {
-       /* sciprint("XXXX mxfree OK  %d\n",Nbvars); */
-       Nbvars--;
-      }
-    else
-      {
-       /* sciprint("XXXX mxfree NOTOK %d\n",Nbvars); */
-      }
-  }
-  return ;
+    double *header;int *iheader;
+    /* If we free the last stored object we can decrement Nbvars */
+    if ( Nbvars >= 1) {
+        iheader = istk(iadr(C2F(intersci).iwhere[Nbvars-1] ) );
+        /*  printf("MxFree iheader,%i %i %i %i\n", iheader[0],iheader[1],iheader[2],iheader[3]);   */
+        if ( !(iheader[0]==1) ) return;
+        header=stk(C2F(intersci).iwhere[Nbvars-1]);
+        /*    if ( !(C2F(locptr)(stk(C2F(intersci).lad[Nbvars - 1])) == C2F(locptr)((&header[2])))) return;  */
+        if ( (vraiptrst) ptr ==  C2F(locptr)(&header[2]))
+        {
+            /* sciprint("XXXX mxfree OK  %d\n",Nbvars); */
+            Nbvars--;
+        }
+        else
+        {
+            /* sciprint("XXXX mxfree NOTOK %d\n",Nbvars); */
+        }
+    }
+    return ;
 }
 
 int mexAtExit(mxArray *ptr)
 {
-  /* XXXXX To be done....*/
-  return 0;
+    /* XXXXX To be done....*/
+    return 0;
 }
 
 mxArray *mxCreateSparse(int m, int n, int nzmax, mxComplexity cmplx)
 {
-  static int lw, iprov;
-  Nbvars++;
-  lw=Nbvars;
-  iprov = lw + Top - Rhs;
-  if( ! C2F(mspcreate)(&iprov, &m, &n, &nzmax, (int *) &cmplx)) {
-    return (mxArray *) 0;
-  }
-  C2F(intersci).ntypes[lw-1]=AsIs;
-  return (mxArray *) C2F(vstk).lstk[lw + Top - Rhs - 1];     /* C2F(intersci).iwhere[lw-1])  */
+    static int lw, iprov;
+    Nbvars++;
+    lw=Nbvars;
+    iprov = lw + Top - Rhs;
+    if( ! C2F(mspcreate)(&iprov, &m, &n, &nzmax, (int *) &cmplx)) {
+        return (mxArray *) 0;
+    }
+    C2F(intersci).ntypes[lw-1]=AsIs;
+    return (mxArray *) C2F(vstk).lstk[lw + Top - Rhs - 1];     /* C2F(intersci).iwhere[lw-1])  */
 }
 
 
 /***************************************************************
- * Create on Scilab Stack a 1x1 string matrix filled with string
- **************************************************************/
+* Create on Scilab Stack a 1x1 string matrix filled with string
+**************************************************************/
 
 mxArray *mxCreateString(const char *string)
 {
-  static int i, lw;
-  static int one=1;
-  i = (int)strlen(string);
-  lw=Nbvars+1;
-  /* we do not increment Nbvars since it is done inside createvar */
-  if ( ! C2F(createvarfromptr)(&lw, STRING_DATATYPE, &one, &i, (double *) &string, 1L) ) {
-    return (mxArray *) 0;
-  }
-  /* back conversion to Scilab coding */
-  Convert2Sci(lw);
-  C2F(intersci).ntypes[lw-1]=AsIs;
-  return (mxArray *) C2F(vstk).lstk[lw + Top - Rhs - 1];
+    types::String *ptr = new types::String(string);
+    return (mxArray *) ptr;
 }
 
 mxArray *mxCreateLogicalMatrix(int m, int n)
 {
-  int new_, k; int *header;
-  Nbvars++;
-  new_=Nbvars;
-  CreateData(new_, (3+m*n)*sizeof(int));
-  header =  (int *) GetData(new_);
-  header[0]=LOGICAL;
-  header[1]= m;
-  header[2]= n;
-  for (k=0; k<m*n; k++)
-    header[3+k]= 0;
-  return (mxArray *) C2F(intersci).iwhere[new_-1];
+    types::Bool *ptr = new types::Bool(m, n);
+    return (mxArray *) ptr;
 }
 
-mxArray *mxCreateLogicalScalar(mxLOGICAL *value)
+mxArray *mxCreateLogicalScalar(mxLOGICAL value)
 {
-  mxArray *pa;long *header;
-  pa = mxCreateLogicalMatrix(1, 1);
-  header = (long *) stkptr((long int) pa);
-  header[3]=(long) value;
-  return (mxArray *) pa;
+    mxArray *ptr = mxCreateLogicalMatrix(1, 1);
+    ((types::Bool *) ptr)->set(0, (bool) value);
+    return ptr;
 }
 
 bool mxIsLogicalScalarTrue(mxArray *pa)
 {
-  bool retval;
-  retval = mxIsLogical(pa) && mxGetNumberOfElements(pa) == 1 && *mxGetLogicals(pa) == 1;
-  return retval;
+    return mxIsLogicalScalar(pa) && *mxGetLogicals(pa) != 0;
 }
 
 
 bool mxIsLogicalScalar(mxArray *pa)
 {
-  bool retval;
-  retval = mxIsLogical(pa) && mxGetNumberOfElements(pa) == 1;
-  return retval;
+    return mxIsLogical(pa) && mxGetNumberOfElements(pa) == 1;
 }
 /*
-  Print function which prints (format,args,....)
-  in Scilab window
+Print function which prints (format,args,....)
+in Scilab window
 */
 
 void mexPrintf (const char *fmt,...)
 {
-  va_list args;
-  char buf[2048];
+    va_list args;
+    char buf[2048];
 
-  va_start(args,fmt);
-  (void ) vsprintf(buf, fmt, args );
-  sciprint("%s",buf);
-  va_end(args);
+    va_start(args,fmt);
+    (void ) vsprintf(buf, fmt, args );
+    sciprint("%s",buf);
+    va_end(args);
 }
 
 
 void mexWarnMsgTxt(const char *error_msg)
 {
-  mexPrintf(_("Warning: "));
-  mexPrintf(error_msg);
-  mexPrintf("\n\n");
-  /*  mexPrintf(strcat(_("Warning: "),error_msg)); */
+    mexPrintf(_("Warning: "));
+    mexPrintf(error_msg);
+    mexPrintf("\n\n");
 }
 
 /* 1 is returned in case of failure */
 
 static int mexCallSCI(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, char *name,int jumpflag)
 {
-  static int i1, i2;
-  static int k, kk, nv;
-  nv = Nbvars;
-  for (k = 1; k <= nrhs; ++k)
+    static int i1, i2;
+    static int k, kk, nv;
+    nv = Nbvars;
+    for (k = 1; k <= nrhs; ++k)
     {
-      for (kk = 1; kk <= nv; ++kk)
-       if ((long) prhs[k-1] == C2F(vstk).lstk[kk + Top - Rhs - 1]) break;
-      if (kk == nv + 1)
-       {
-         mexErrMsgTxt(_("mexCallSCILAB: invalid pointer passed to called function."));
-         return 1;
-       }
-      else
-       {
-         ++Nbvars;
-         i1 = Top - Rhs + kk;
-         i2 = Top - Rhs + Nbvars;
-         C2F(vcopyobj)("mexCallSCILAB", &i1, &i2, 13L);
-       }
-    }
-  i1 = nv + 1;
-  if (! C2F(scistring)(&i1, name, &nlhs, &nrhs,(unsigned long) strlen(name) )) {
-    if ( jumpflag == 1)
-      {
-       mexErrMsgTxt(_("mexCallSCILAB: evaluation failed. "));
-      }
-    return 1;
-    /* return 0;  */
-  }
-  for (k = 1; k <= nlhs; ++k) {
-    plhs[k-1] = (mxArray *) C2F(vstk).lstk[nv + k + Top - Rhs - 1];
-  }
-  Nbvars = nv+nlhs;
-  return 0;
+        for (kk = 1; kk <= nv; ++kk)
+            if ((long) prhs[k-1] == C2F(vstk).lstk[kk + Top - Rhs - 1]) break;
+        if (kk == nv + 1)
+        {
+            mexErrMsgTxt(_("mexCallSCILAB: invalid pointer passed to called function."));
+            return 1;
+        }
+        else
+        {
+            ++Nbvars;
+            i1 = Top - Rhs + kk;
+            i2 = Top - Rhs + Nbvars;
+            C2F(vcopyobj)("mexCallSCILAB", &i1, &i2, 13L);
+        }
+    }
+    i1 = nv + 1;
+    if (! C2F(scistring)(&i1, name, &nlhs, &nrhs,(unsigned long) strlen(name) )) {
+        if ( jumpflag == 1)
+        {
+            mexErrMsgTxt(_("mexCallSCILAB: evaluation failed. "));
+        }
+        return 1;
+        /*     return 0;  */
+    }
+    for (k = 1; k <= nlhs; ++k) {
+        plhs[k-1] = (mxArray *) C2F(vstk).lstk[nv + k + Top - Rhs - 1];
+    }
+    Nbvars = nv+nlhs;
+    return 0;
 }
 
 
 int mexCallSCILAB(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name) {
-  return mexCallSCI(nlhs,plhs,nrhs,prhs,(char *) name,1);
+    return mexCallSCI(nlhs,plhs,nrhs,prhs,(char *) name,1);
 }
 
 int mexCallMATLAB(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name) {
-  return mexCallSCI(nlhs,plhs,nrhs,prhs,(char *) name,1);
+    return mexCallSCI(nlhs,plhs,nrhs,prhs,(char *) name,1);
 }
 
 int mxCalcSingleSubscript(const mxArray *ptr, int nsubs, const int *subs)
 {
-  int k, retval, coeff;
-  int *dims = mxGetDimensions(ptr);
-  retval=0;coeff=1;
-  for  (k=0; k<nsubs; k++) {
-    retval=retval+subs[k]*coeff;
-    coeff=coeff*dims[k];
-  }
-  return retval;
+    int k, retval, coeff;
+    int *dims = mxGetDimensions(ptr);
+    retval=0;coeff=1;
+    for  (k=0; k<nsubs; k++) {
+        retval=retval+subs[k]*coeff;
+        coeff=coeff*dims[k];
+    }
+    return retval;
 }
 
 int C2F(mexcallscilab)(int *nlhs, mxArray **plhs, int *nrhs, mxArray **prhs, char *name, int namelen)
 {
-  return mexCallSCILAB(*nlhs, plhs, *nrhs, prhs, name);
+    return mexCallSCILAB(*nlhs, plhs, *nrhs, prhs, name);
 }
 
 /** generic mex interface **/
-const char *mexFunctionName(void) { return the_current_mex_name;}
+const char *mexFunctionName(void)
+{
+    return the_current_mex_name;
+}
 
 int mex_gateway(char *fname, GatefuncH F)
 {
-  int nlhs,nrhs;
-  mxArray * plhs[intersiz];  mxArray * prhs[intersiz];
-  the_current_mex_name=fname;
-  C2F(initmex)(&nlhs, plhs, &nrhs, prhs);
-  (*F)(nlhs, plhs, nrhs, prhs);
-  C2F(endmex)(&nlhs, plhs, &nrhs, prhs);
-  return 0;
+    int nlhs,nrhs;
+    mxArray * plhs[intersiz];  mxArray * prhs[intersiz];
+    the_current_mex_name=fname;
+    C2F(initmex)(&nlhs, plhs, &nrhs, prhs);
+    (*F)(nlhs, plhs, nrhs, prhs);
+    C2F(endmex)(&nlhs, plhs, &nrhs, prhs);
+    return 0;
 }
 
 int fortran_mex_gateway(char *fname, FGatefuncH F)
 {
-  int nlhs,nrhs;
-  mxArray * plhs[intersiz];  mxArray * prhs[intersiz];
-  C2F(initmex)(&nlhs, plhs, &nrhs, prhs);
-  (*F)( &nlhs, plhs, &nrhs, prhs);
-  C2F(endmex)(&nlhs, plhs, &nrhs, prhs);
-  return 0;
+    int nlhs,nrhs;
+    mxArray * plhs[intersiz];  mxArray * prhs[intersiz];
+    C2F(initmex)(&nlhs, plhs, &nrhs, prhs);
+    (*F)( &nlhs, plhs, &nrhs, prhs);
+    C2F(endmex)(&nlhs, plhs, &nrhs, prhs);
+    return 0;
 }
 
 
 
 int mxGetElementSize(const mxArray *ptr)
 { int k, it;
- int *header = Header(ptr);
- switch (header[0]) {
- case DOUBLEMATRIX: case SPARSEMATRIX:
-   return sizeof(double);
- case STRINGMATRIX:
-   return 2*sizeof(char);    /* ? Matlab returns 2 */
- case MLIST:
-   k=header[4];
-   /*   header[6+2*(k-1)]  =  1 if double matrix, 8 if int  */
-   if (header[6+2*(k-1)]==DOUBLEMATRIX)  return sizeof(double);
-   if (header[6+2*(k-1)]==INTMATRIX) {
-     it= header[6+2*(k-1)+3]; return( it%10 );
-   }
-   break;
- case INTMATRIX:
-   /*[8,m,n,it] it=01    02   04    11     12    14
-                  int8 int16 int32 uint8 uint16 uint32    */
-   it=header[3];
-   return( it%10 );
- default:
-   mexErrMsgTxt(_("GetElementSize error."));
-   return 0;
- }
- return 0;
+int *header = Header(ptr);
+switch (header[0]) {
+case DOUBLEMATRIX: case SPARSEMATRIX:
+    return sizeof(double);
+case STRINGMATRIX:
+    return 2*sizeof(char);    /* ? Matlab returns 2 */
+case MLIST:
+    k=header[4];
+    /*   header[6+2*(k-1)]  =  1 if double matrix, 8 if int  */
+    if (header[6+2*(k-1)]==DOUBLEMATRIX)  return sizeof(double);
+    if (header[6+2*(k-1)]==INTMATRIX) {
+        it= header[6+2*(k-1)+3]; return( it%10 );
+    }
+    break;
+case INTMATRIX:
+    /*[8,m,n,it] it=01    02   04    11     12    14
+    int8 int16 int32 uint8 uint16 uint32    */
+    it=header[3];
+    return( it%10 );
+default:
+    mexErrMsgTxt(_("GetElementSize error."));
+    return 0;
+}
+return 0;
 }
 
 mxArray *mxCreateCharMatrixFromStrings(int m, const char **str)
 {
-  static int i, lr1, lw, ilocal, n, k,kk, nmax;
-  nmax = (int)strlen(str[0]);
-  for (k=1; k<m; ++k) {
-    n=(int)strlen(str[k]);
-    if (n > nmax) nmax=n;
-  }
-  Nbvars++;
-  lw = Nbvars + Top -Rhs;
-  /*      logical function cresmat3(fname,lw,m,n,nchar,lr) */
-  if( ! C2F(cresmat4)("mxCreateString:", &lw, &m, &nmax, &lr1, 15L)) {
-    return (mxArray *) 0;
-  }
-  /*    Convert string to int code    */
-  /*   subroutine cvstr(n,line,str,job) */
-  for (k=0; k<m; ++k) {
-    n=(int)strlen(str[k]);
-    /* fill with blanks (40) if n<nmax !!*/
-    C2F(cvstr)(&n, istk(lr1), (char *) str[k], (ilocal=0, &ilocal),i);
-    if (nmax>n) {
-      for (kk=0; kk<nmax-n; ++kk) *istk(lr1+n+kk)=40;
-    };
-    lr1=lr1+nmax;
-  }
-  C2F(intersci).ntypes[lw-1]=AsIs;
-  return (mxArray *) C2F(vstk).lstk[lw - 1];
+    static int i, lr1, lw, ilocal, n, k,kk, nmax;
+    nmax = (int)strlen(str[0]);
+    for (k=1; k<m; ++k) {
+        n=(int)strlen(str[k]);
+        if (n > nmax) nmax=n;
+    }
+    Nbvars++;
+    lw = Nbvars + Top -Rhs;
+    /*      logical function cresmat3(fname,lw,m,n,nchar,lr) */
+    if( ! C2F(cresmat4)("mxCreateString:", &lw, &m, &nmax, &lr1, 15L)) {
+        return (mxArray *) 0;
+    }
+    /*    Convert string to int code    */
+    /*   subroutine cvstr(n,line,str,job) */
+    for (k=0; k<m; ++k) {
+        n=(int)strlen(str[k]);
+        /* fill with blanks (40) if n<nmax !!*/
+        C2F(cvstr)(&n, istk(lr1), (char *) str[k], (ilocal=0, &ilocal),i);
+        if (nmax>n) {
+            for (kk=0; kk<nmax-n; ++kk) *istk(lr1+n+kk)=40;
+        };
+        lr1=lr1+nmax;
+    }
+    C2F(intersci).ntypes[lw-1]=AsIs;
+    return (mxArray *) C2F(vstk).lstk[lw - 1];
 }
 
 int mexEvalString(const char *name)
 {
-  double *val ;
-  int rep;
-  mxArray *ppr[3];mxArray *ppl[1];
-  int nlhs;     int nrhs;
-  ppr[0] = mxCreateString(name);
-  ppr[1] = mxCreateString("errcatch");
-  ppr[2] = mxCreateString("m");
-  nrhs=3;nlhs=1;
-  rep = mexCallSCI(nlhs, ppl, nrhs, ppr, "execstr",0);
-  /* check returned value */
-  val = mxGetPr(ppl[0]);
-  mxFreeMatrix(ppl[0]);
-  mxFreeMatrix(ppr[2]);
-  mxFreeMatrix(ppr[1]);
-  mxFreeMatrix(ppr[0]);
-  if ( rep == 1 || (int) (*val) != 0 )
+    double *val ;
+    int rep;
+    mxArray *ppr[3];mxArray *ppl[1];
+    int nlhs;     int nrhs;
+    ppr[0] = mxCreateString(name);
+    ppr[1] = mxCreateString("errcatch");
+    ppr[2] = mxCreateString("m");
+    nrhs=3;nlhs=1;
+    rep = mexCallSCI(nlhs, ppl, nrhs, ppr, "execstr",0);
+    /* check returned value */
+    val = mxGetPr(ppl[0]);
+    mxFreeMatrix(ppl[0]);
+    mxFreeMatrix(ppr[2]);
+    mxFreeMatrix(ppr[1]);
+    mxFreeMatrix(ppr[0]);
+    if ( rep == 1 || (int) (*val) != 0 )
     {
-      errjump();
+        errjump();
     }
-  return rep;
+    return rep;
 }
 
 mxArray *mexGetArray(char *name, char *workspace)
 {
-  int lw, fin, new_ ; int *header;
-  /* mxArray *mxPointed; */
-  if (C2F(objptr)(name,&lw,&fin,(unsigned long)strlen(name))) {
-    /*    mxPointed = (mxArray *) lw;   */
-    Nbvars++; new_=Nbvars;
-    CreateData(new_, 4*sizeof(int));
-    header =  (int *) GetRawData(new_);
-    header[0]=- *istk( iadr(*Lstk(fin)));
-    header[1]= lw;
-    header[2]= fin;
-    header[3]= *Lstk(fin+1) -*Lstk(fin) ;
-    /*    C2F(intersci).ntypes[new-1]=45;  */
-    return (mxArray *) C2F(intersci).iwhere[new_-1]; }
-  else
-    return (mxArray *) 0;
+    int lw, fin, new_ ; int *header;
+    /* mxArray *mxPointed; */
+    if (C2F(objptr)(name,&lw,&fin,(unsigned long)strlen(name))) {
+        /*    mxPointed = (mxArray *) lw;   */
+        Nbvars++; new_=Nbvars;
+        CreateData(new_, 4*sizeof(int));
+        header =  (int *) GetRawData(new_);
+        header[0]=- *istk( iadr(*Lstk(fin)));
+        header[1]= lw;
+        header[2]= fin;
+        header[3]= *Lstk(fin+1) -*Lstk(fin) ;
+        /*    C2F(intersci).ntypes[new-1]=45;  */
+        return (mxArray *) C2F(intersci).iwhere[new_-1]; }
+    else
+        return (mxArray *) 0;
 }
 
 const mxArray *mexGetVariablePtr(const char *workspace, const char *var_name)
 {
-  int lw, fin, new_ ; int *header;
-  /* mxArray *mxPointed; */
-  if (C2F(objptr)((char*)var_name,&lw,&fin,(unsigned long)strlen(var_name)))
+    int lw, fin, new_ ; int *header;
+    /* mxArray *mxPointed; */
+    if (C2F(objptr)((char*)var_name,&lw,&fin,(unsigned long)strlen(var_name)))
     {
-    /*    mxPointed = (mxArray *) lw;   */
-    Nbvars++; new_=Nbvars;
-    CreateData(new_, 4*sizeof(int));
-    header =  (int *) GetRawData(new_);
-    header[0]=- *istk( iadr(*Lstk(fin)));
-    header[1]= lw;
-    header[2]= fin;
-    header[3]= *Lstk(fin+1) -*Lstk(fin) ;
-    return (mxArray *) C2F(intersci).iwhere[new_-1];
+        /*    mxPointed = (mxArray *) lw;   */
+        Nbvars++; new_=Nbvars;
+        CreateData(new_, 4*sizeof(int));
+        header =  (int *) GetRawData(new_);
+        header[0]=- *istk( iadr(*Lstk(fin)));
+        header[1]= lw;
+        header[2]= fin;
+        header[3]= *Lstk(fin+1) -*Lstk(fin) ;
+        return (mxArray *) C2F(intersci).iwhere[new_-1];
     }
-  else
-    return (mxArray *) 0;
+    else
+        return (mxArray *) 0;
 }
 
 mxArray *mexGetVariable(const char *workspace, const char *name)
 {
-  int lw, fin, new_ ; int *header;
-  /* mxArray *mxPointed; */
-  if (C2F(objptr)((char*)name,&lw,&fin,(unsigned long)strlen(name))) {
-    /*    mxPointed = (mxArray *) lw;   */
-    Nbvars++; new_=Nbvars;
-    CreateData(new_, 4*sizeof(int));
-    header =  (int *) GetData(new_);
-    header[0]=- *istk( iadr(*Lstk(fin)));
-    header[1]= lw;
-    header[2]= fin;
-    header[3]= *Lstk(fin+1) -*Lstk(fin) ;
-    /*    C2F(intersci).ntypes[new-1]=45;  */
-    return (mxArray *) C2F(intersci).iwhere[new_-1]; }
-  else
-    return (mxArray *) 0;
+    int lw, fin, new_ ; int *header;
+    /* mxArray *mxPointed; */
+    if (C2F(objptr)((char*)name,&lw,&fin,(unsigned long)strlen(name))) {
+        /*    mxPointed = (mxArray *) lw;   */
+        Nbvars++; new_=Nbvars;
+        CreateData(new_, 4*sizeof(int));
+        header =  (int *) GetData(new_);
+        header[0]=- *istk( iadr(*Lstk(fin)));
+        header[1]= lw;
+        header[2]= fin;
+        header[3]= *Lstk(fin+1) -*Lstk(fin) ;
+        /*    C2F(intersci).ntypes[new-1]=45;  */
+        return (mxArray *) C2F(intersci).iwhere[new_-1]; }
+    else
+        return (mxArray *) 0;
 }
 
 int mexPutArray(mxArray *array_ptr, char *workspace)
 {
-  /* TO BE DONE obsolete ?  */
-  mexPrintf( _("Function mexPutArray is obsolete, use mexPutVariable!\n"));
-  return 1;
+    /* TO BE DONE obsolete ?  */
+    mexPrintf( _("Function mexPutArray is obsolete, use mexPutVariable!\n"));
+    return 1;
 }
 
 int mexPutVariable(const char *workspace, char *var_name, mxArray *array_ptr)
 {
-  /*  workspace ignored: to be done .... */
-  PutVar( arr2num( array_ptr) , var_name);
-  return 0;  /* CHECK THIS !!!!!! */
+    /*  workspace ignored: to be done .... */
+    PutVar( arr2num( array_ptr) , var_name);
+    return 0;  /* CHECK THIS !!!!!! */
 }
 
 void mxSetName(mxArray *array_ptr, const char *name)
 {
-  mexErrMsgTxt(_("Routine mxSetName not implemented !\n"));
-  exit(1);  /* TO BE DONE */
+    mexErrMsgTxt(_("Routine mxSetName not implemented !\n"));
+    exit(1);  /* TO BE DONE */
 }
 
 void mxSetData(mxArray *array_ptr, void *data_ptr)
 {
-  mexErrMsgTxt(_("Routine mxSetData not implemented.\n"));
-  exit(1);  /* TO BE DONE */
+    mexErrMsgTxt(_("Routine mxSetData not implemented.\n"));
+    exit(1);  /* TO BE DONE */
 }
 
-void mxSetPr(mxArray *array_ptr, double *pr_data)
+void mxSetPr(mxArray *ptr, double *pr)
 {
-  double *start_of_pr = mxGetPr(array_ptr);
-  unsigned long mem_size;
-  unsigned long mn = mxGetM(array_ptr) * mxGetN(array_ptr);
-  static int warn_cnt = 0; /* Number of times to warn for memcpy overwrite. */
-  static int warn_cnt2 = 0; /* Number of times to warn for oversized NZMAX. */
+    ((types::Double *) ptr)->set(pr);
+}
 
-  if(mxIsSparse(array_ptr)){
-    int *header = Header(array_ptr);
-    int NZMAX = header[4];
-    if( (unsigned long)NZMAX <= mn ){
-      mem_size = NZMAX * sizeof(double);
-    }
-    else{ /* Can't hold more than M*N elements so truncate and warn. */
-      mem_size = mn * sizeof(double);
-      if(warn_cnt2){
-       char *prefix = --warn_cnt2 == 0 ? _("Last warning") : _("Warning");
-       fprintf(stderr, "%s: mxSetPr (NZMAX=%i) > (M*N=%i).\n", prefix, (int)NZMAX, (int)mn);
-      }
-    }
-  }
-  else{ /* Full Matrix */
-    mem_size = mn * sizeof(double);
-  }
-  if(warn_cnt){
-    int overwrite = (int)(mem_size - sizeof(double)*(pr_data - start_of_pr));
-    if(overwrite > 0){
-      char *prefix = --warn_cnt == 0 ? _("Last warning") : _("Warning");
-      fprintf(stderr, _("%s: mxSetPr overwriting destination by %i bytes.\n"), prefix, overwrite);
-    }
-  }
-  memcpy(start_of_pr, pr_data, mem_size);
-}
-
-void mxSetPi(mxArray *array_ptr, double *pi_data)
-{
-  double *start_of_pi = mxGetPi(array_ptr);
-  unsigned long mem_size;
-  unsigned long mn = mxGetM(array_ptr) * mxGetN(array_ptr);
-  static int warn_cnt = 0; /* Number of times to warn for memcpy overwrite.*/
-  static int warn_cnt2 = 0; /* Number of times to warn for oversized NZMAX.*/
-
-  if(mxIsSparse(array_ptr)){
-    int *header = Header(array_ptr);
-    int NZMAX = header[4];
-    if( (unsigned long)NZMAX <= mn ){
-      mem_size = NZMAX * sizeof(double);
-    }
-    else{ /* Can't hold more than M*N elements so truncate and warn. */
-      mem_size = mn * sizeof(double);
-      if(warn_cnt2){
-       char *prefix = --warn_cnt2 == 0 ? _("Last warning") : _("Warning");
-       fprintf(stderr, "%s: mxSetPi (NZMAX=%i) > (M*N=%i).\n", prefix, (int)NZMAX, (int)mn);
-      }
-    }
-  }
-  else{ /* Full Matrix */
-    mem_size = mn * sizeof(double);
-  }
-  if(warn_cnt){
-    int overwrite = (int)(mem_size - sizeof(double)*(pi_data - start_of_pi));
-    if(overwrite > 0){
-      char *prefix = --warn_cnt == 0 ? _("Last warning") : _("Warning");
-      fprintf(stderr, _("%s: mxSetPi overwriting destination by %i bytes.\n"), prefix, overwrite);
-    }
-  }
-  memcpy(start_of_pi, pi_data, mem_size);
+void mxSetPi(mxArray *ptr, double *pi)
+{
+    ((types::Double *) ptr)->setImg(pi);
 }
 
 const char *mxGetName(const mxArray *array_ptr)
 {
     mexPrintf(_("Routine mxGetName not implemented.\n"));
     exit(1);
-       return 0;
+    return 0;
 }
 
 int mxSetDimensions(mxArray *array_ptr, const int *dims, int ndim)
 {
-  mexPrintf(_("Routine mxSetDimensions not implemented.\n"));
-  exit(1);  /* TO BE DONE */
-  return 0;
+    mexPrintf(_("Routine mxSetDimensions not implemented.\n"));
+    exit(1);  /* TO BE DONE */
+    return 0;
 }
 
 const char *mxGetClassName(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  switch (header[0]) {
-  case DOUBLEMATRIX:
-    return "double";
-  case STRINGMATRIX:
-    return "char";
-  case SPARSEMATRIX:
-    return "sparse";
-  case INTMATRIX:
-    /*[8,m,n,it] it=01    02   04    11     12    14
-                   int8 int16 int32 uint8 uint16 uint32    */
-    switch (header[3]){
-    case 1:
-      return "int8";
-    case 2:
-      return "int16";
-    case 4:
-      return "int32";
-    case 11:
-      return "uint8";
-    case 12:
-      return "uint16";
-    case 14:
-      return "uint32";
-    default:
-      return "unknown";
-    }
-  case MLIST:
-    /* to be done return mxCELL_CLASS or mxCHAR_CLASS or mxSTRUCT_CLASS */
-    /* header[6+2*(header[4]-1)]   ( = 1, 10, 8)  */
-    switch (theMLIST(header)) {
-    case CELL:
-      return "cell";
-    case STRUCT:
-      return "struct";
-    case NDARRAY:
-    switch (header[6+2*(header[4]-1)]) {
-      /* listentry(header,3) */
+    int *header = Header(ptr);
+    switch (header[0]) {
     case DOUBLEMATRIX:
-      return "double";
+        return "double";
     case STRINGMATRIX:
-      return "char";
+        return "char";
+    case SPARSEMATRIX:
+        return "sparse";
     case INTMATRIX:
-      switch (header[6+2*(header[4]-1)+3]) {
-      case 1:
-       return "int8";
-      case 2:
-       return "int16";
-      case 4:
-       return "int32";
-      case 11:
-       return "uint8";
-      case 12:
-       return "uint16";
-      case 14:
-       return "uint32";
-      default:
-       return "unknown";
-      }
-    }
-    default:
-      return "unknown";
+        /*[8,m,n,it] it=01    02   04    11     12    14
+        int8 int16 int32 uint8 uint16 uint32    */
+        switch (header[3]){
+        case 1:
+            return "int8";
+        case 2:
+            return "int16";
+        case 4:
+            return "int32";
+        case 11:
+            return "uint8";
+        case 12:
+            return "uint16";
+        case 14:
+            return "uint32";
+        default:
+            return "unknown";
+        }
+    case MLIST:
+        /* to be done return mxCELL_CLASS or mxCHAR_CLASS or mxSTRUCT_CLASS */
+        /* header[6+2*(header[4]-1)]   ( = 1, 10, 8)  */
+        switch (theMLIST(header)) {
+        case CELL:
+            return "cell";
+        case STRUCT:
+            return "struct";
+        case NDARRAY:
+            switch (header[6+2*(header[4]-1)]) {
+                /* listentry(header,3) */
+            case DOUBLEMATRIX:
+                return "double";
+            case STRINGMATRIX:
+                return "char";
+            case INTMATRIX:
+                switch (header[6+2*(header[4]-1)+3]) {
+                case 1:
+                    return "int8";
+                case 2:
+                    return "int16";
+                case 4:
+                    return "int32";
+                case 11:
+                    return "uint8";
+                case 12:
+                    return "uint16";
+                case 14:
+                    return "uint32";
+                default:
+                    return "unknown";
+                }
+            }
+        default:
+            return "unknown";
+        }
     }
-  }
-  return "unknown";
+    return "unknown";
 }
 
 void mxSetCell(mxArray *array_ptr, int lindex, mxArray *value)
 {
-  mxSetFieldByNumber(array_ptr, lindex, 0 , value);
-  return;
+    mxSetFieldByNumber(array_ptr, lindex, 0 , value);
+    return;
 }
 
 int mxGetNzmax(const mxArray *ptr)
 {
-  int *header = Header(ptr);
-  /* ... N=header[2],  nzmax=header[4]; then Jc,  then Ir   */
-  return header[4];
+    int *header = Header(ptr);
+    /* ... N=header[2],  nzmax=header[4]; then Jc,  then Ir   */
+    return header[4];
 }
 
-mxLOGICAL *mxGetLogicals(const mxArray *array_ptr)
+mxLOGICAL *mxGetLogicals(const mxArray *ptr)
 {
-  int *header = Header(array_ptr);
-  /*  TO BE DONE : ND Arrays  */
-  if (header[0] != LOGICAL) return  NULL;
-  return (mxLOGICAL *) &header[3];
+    types::InternalType* pIT = (types::InternalType*)ptr;
+    if(pIT == NULL)
+    {
+        return NULL;
+    }
+
+    types::Bool* pB = pIT->getAs<types::Bool>();
+    if(pB == NULL)
+    {
+        return NULL;
+    }
+
+    return (mxLOGICAL*)pB->get();
 }
 
 int C2F(initmex)(int *nlhs, mxArray **plhs, int *nrhs, mxArray **prhs)
 {
-  int *header;int *header1;
-  static int output, k, RhsVar;
-  static int m, commonlength, line;
-  if (Rhs==-1) Rhs++;
-  Nbvars = 0;
-  *nlhs = Lhs;  *nrhs = Rhs;
-  for (output = 1; output <= *nlhs ; ++output) plhs[output-1]=0;
-  for (k = 1; k <= *nrhs ; ++k)
+    int *header;int *header1;
+    static int output, k, RhsVar;
+    static int m, commonlength, line;
+    if (Rhs==-1) Rhs++;
+    Nbvars = 0;
+    *nlhs = Lhs;  *nrhs = Rhs;
+    for (output = 1; output <= *nlhs ; ++output) plhs[output-1]=0;
+    for (k = 1; k <= *nrhs ; ++k)
     {
-      RhsVar = k  + Top - Rhs;
-      prhs[k-1] = (mxArray *) C2F(vstk).lstk[RhsVar - 1];
-      C2F(intersci).ntypes[k-1]=AsIs;
-      header = (int *) stkptr((long int)prhs[k-1]);
-      /*
-       Indirect
-       */
-      if (header[0] < 0) header = (int *) stk(header[1]);
-      switch (header[0]) {
-      case DOUBLEMATRIX: case INTMATRIX: case SPARSEMATRIX:
-       break;
-      case STRINGMATRIX:
-       if (header[2] !=1) mexErrMsgTxt(_("Invalid string matrix (at most one column!)"));
-       m=header[1];
-       commonlength=header[5]-header[4];
-       if (m > 1) {
-         for (line = 1; line < m; line++)
-           {
-             if (header[5+line] - header[4+line] != commonlength)
-               mexErrMsgTxt(_("Column length of string matrix must agree!"));
-           }
-       }
-       break;
-      case 5:
-       mexErrMsgTxt(_("Use mtlb_sparse(sparse( ))!"));
-       /*   scilab sparse  should be matlabified  */
-       return 0;
-      case MLIST:
-       header1 = (int *) listentry(header,2);
-       /* m = header1[1]*header1[2]; */
-       /* C2F(entier)(&m, (double *) &header1[4], &header1[4]); */
-       break;
-      case LOGICAL :
-       break;
-      default:
-       mexErrMsgTxt(_("Invalid input"));
-       return 0;
-      }
-    }
-  Nbvars = Rhs ;
-  return 0;
+        RhsVar = k  + Top - Rhs;
+        prhs[k-1] = (mxArray *) C2F(vstk).lstk[RhsVar - 1];
+        C2F(intersci).ntypes[k-1]=AsIs;
+        header = (int *) stkptr((long int)prhs[k-1]);
+        /*
+        Indirect
+        */
+        if (header[0] < 0) header = (int *) stk(header[1]);
+        switch (header[0]) {
+        case DOUBLEMATRIX: case INTMATRIX: case SPARSEMATRIX:
+            break;
+        case STRINGMATRIX:
+            if (header[2] !=1) mexErrMsgTxt(_("Invalid string matrix (at most one column!)"));
+            m=header[1];
+            commonlength=header[5]-header[4];
+            if (m > 1) {
+                for (line = 1; line < m; line++)
+                {
+                    if (header[5+line] - header[4+line] != commonlength)
+                        mexErrMsgTxt(_("Column length of string matrix must agree!"));
+                }
+            }
+            break;
+        case 5:
+            mexErrMsgTxt(_("Use mtlb_sparse(sparse( ))!"));
+            /*   scilab sparse  should be matlabified  */
+            return 0;
+        case MLIST:
+            header1 = (int *) listentry(header,2);
+            /* m = header1[1]*header1[2]; */
+            /* C2F(entier)(&m, (double *) &header1[4], &header1[4]); */
+            break;
+        case LOGICAL :
+            break;
+        default:
+            mexErrMsgTxt(_("Invalid input"));
+            return 0;
+        }
+    }
+    Nbvars = Rhs ;
+    return 0;
 }
 
 
 /****************************************************
- * A set of utility functions
- ****************************************************/
+* A set of utility functions
+****************************************************/
 
 vraiptrst C2F(locptr)(void * x)
 {
-  return((vraiptrst) x);
+    return((vraiptrst) x);
 }
 
 int C2F(createstkptr)(int *m, vraiptrst *ptr)
 {
-  int lr, n=1, lw;
-  Nbvars++;
-  lw = Nbvars;
-  if (! C2F(createvar)(&lw, "d", m, &n, &lr, 1L)) {
-    return 0;
-  }
-  *ptr = C2F(locptr)(stk(lr));
-  return 1;
+    int lr, n=1, lw;
+    Nbvars++;
+    lw = Nbvars;
+    if (! C2F(createvar)(&lw, "d", m, &n, &lr, 1L)) {
+        return 0;
+    }
+    *ptr = C2F(locptr)(stk(lr));
+    return 1;
 }
 
 int C2F(createptr)(char *type, int *m, int *n, int *it, int *lr, int *ptr, long int type_len)
 {
-  static int lc, lw;
-  Nbvars++;
-  lw = Nbvars;
-  /* sciprint("createptr XXXX  %d\n",lw); */
-  if (! C2F(createcvar)(&lw, type, it, m, n, lr, &lc, 1L)) {
-    return 0;
-  }
-  *ptr = C2F(vstk).lstk[lw + Top - Rhs - 1];
-  return 1;
+    static int lc, lw;
+    Nbvars++;
+    lw = Nbvars;
+    /* sciprint("createptr XXXX  %d\n",lw); */
+    if (! C2F(createcvar)(&lw, type, it, m, n, lr, &lc, 1L)) {
+        return 0;
+    }
+    *ptr = C2F(vstk).lstk[lw + Top - Rhs - 1];
+    return 1;
 }
 
 int C2F(endmex)(int *nlhs, mxArray **plhs, int *nrhs, mxArray **prhs)
 {
-  int nv,kk,k;
-  long plhsk;
-  for (k = 1; k <= *nlhs; k++) {
-    if (IsstOrce(plhs[k-1])) plhs[k-1]=UnrefStruct(plhs[k-1]);
-  }
-  nv=Nbvars;
-  for (k = 1; k <= *nlhs; k++)
+    int nv,kk,k;
+    long plhsk;
+    for (k = 1; k <= *nlhs; k++) {
+        if (IsstOrce(plhs[k-1])) plhs[k-1]=UnrefStruct(plhs[k-1]);
+    }
+    nv=Nbvars;
+    for (k = 1; k <= *nlhs; k++)
     {
-      plhsk = (long) plhs[k-1];
-      LhsVar(k) = 0;
-      for (kk = 1; kk <= nv; kk++)
-       {
-         if (plhsk == C2F(vstk).lstk[kk+ Top - Rhs -1])
-           {
-             LhsVar(k) = kk;
-             break;
-           }
-       }
-    }
-  C2F(putlhsvar)();
-  /** clear mxMalloc_m and and mxCalloc_m  **/
-  mxFree_m_all();
-  return 0;
+        plhsk = (long) plhs[k-1];
+        LhsVar(k) = 0;
+        for (kk = 1; kk <= nv; kk++)
+        {
+            if (plhsk == C2F(vstk).lstk[kk+ Top - Rhs -1])
+            {
+                LhsVar(k) = kk;
+                break;
+            }
+        }
+    }
+    C2F(putlhsvar)();
+    /** clear mxMalloc_m and and mxCalloc_m  **/
+    mxFree_m_all();
+    return 0;
 }
 
 /* a utility function to recover available Vars position */
 
 void clear_mex(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs)
 {
-  int nv=Nbvars ,k;
-  long max = (long) plhs[0] ;
-  for (k = 1; k <= nlhs; k++)
-    if (  (long)plhs[k-1] > max ) max =  (long)plhs[k-1];
-  for (k = 1; k <= nrhs; k++)
-    if ( (long)  prhs[k-1] > max ) max =  (long) prhs[k-1];
-  for (k = 1; k <= nv; k++)
-    if ( max <  C2F(vstk).lstk[k + Top - Rhs -1]) Nbvars--;
+    int nv=Nbvars ,k;
+    long max = (long) plhs[0] ;
+    for (k = 1; k <= nlhs; k++)
+        if (  (long)plhs[k-1] > max ) max =  (long)plhs[k-1];
+    for (k = 1; k <= nrhs; k++)
+        if ( (long)  prhs[k-1] > max ) max =  (long) prhs[k-1];
+    for (k = 1; k <= nv; k++)
+        if ( max <  C2F(vstk).lstk[k + Top - Rhs -1]) Nbvars--;
 }
 
 void mexInfo(char *str) {
-  fprintf(stderr,"%s %d\n",str,Nbvars);
-  fflush(stderr);
+    fprintf(stderr,"%s %d\n",str,Nbvars);
+    fflush(stderr);
 }
 
 int mexCheck(char *str,int nbvars) {
-  if ( nbvars != -1 && Nbvars != nbvars)
-    fprintf(stderr,"%s %d %d\n",str,Nbvars,nbvars);
-  return Nbvars ;
+    if ( nbvars != -1 && Nbvars != nbvars)
+        fprintf(stderr,"%s %d %d\n",str,Nbvars,nbvars);
+    return Nbvars ;
 }
 
 
 /****************************************************
- * C functions for Fortran  mexfunctions
- ****************************************************/
+* C functions for Fortran  mexfunctions
+****************************************************/
 
 double * C2F(mxgetpr)(mxArray *ptr)
 {
-  /*  double *value = (double *) stkptr(*ptr); */
-  double *value;
-  int *header = (int *) stkptr(*ptr);
-  if (header[0] < 0) header = (int *) stk(header[1]);
-  value = (double *) header;
-  if (header[0]==DOUBLEMATRIX) {
-    return &value[2];
-  }
-  else if ( header[0]==SPARSEMATRIX ) {
-    /*    nnz = header[4];  N = header[2];  */
-    return &value[ i2sadr(5+header[2]+header[4]) ];
-  }
-  else {
-    return 0;
-  }
+    /*  double *value = (double *) stkptr(*ptr); */
+    double *value;
+    int *header = (int *) stkptr(*ptr);
+    if (header[0] < 0) header = (int *) stk(header[1]);
+    value = (double *) header;
+    if (header[0]==DOUBLEMATRIX) {
+        return &value[2];
+    }
+    else if ( header[0]==SPARSEMATRIX ) {
+        /*    nnz = header[4];  N = header[2];  */
+        return &value[ i2sadr(5+header[2]+header[4]) ];
+    }
+    else {
+        return 0;
+    }
 }
 
 
 double * C2F(mxgetpi)(mxArray *ptr)
 {
-  /*  double *value = (double *) stkptr(*ptr); */
-  double *value;
-  int *header = (int *) stkptr(*ptr);
-  if (header[0] < 0) header = (int *) stk(header[1]);
-  value = (double *) header;
-  return &value[2 +  C2F(mxgetm)(ptr) *  C2F(mxgetn)(ptr)];
+    /*  double *value = (double *) stkptr(*ptr); */
+    double *value;
+    int *header = (int *) stkptr(*ptr);
+    if (header[0] < 0) header = (int *) stk(header[1]);
+    value = (double *) header;
+    return &value[2 +  C2F(mxgetm)(ptr) *  C2F(mxgetn)(ptr)];
 }
 
 int  C2F(mxgetm)(mxArray *ptr)
 {
-  int *header = (int *) stkptr(*ptr);
-  if (header[0] < 0) header = (int *) stk(header[1]);
-  return header[1] ;
+    int *header = (int *) stkptr(*ptr);
+    if (header[0] < 0) header = (int *) stk(header[1]);
+    return header[1] ;
 }
 
 int  C2F(mxgetn)(mxArray *ptr)
 {
-  int *header = (int *) stkptr(*ptr);
-  if (header[0] < 0) header = (int *) stk(header[1]);
-  if ( header[0] == STRINGMATRIX) {
-    return header[5]-1;
-  }
-  return header[2] ;
+    int *header = (int *) stkptr(*ptr);
+    if (header[0] < 0) header = (int *) stk(header[1]);
+    if ( header[0] == STRINGMATRIX) {
+        return header[5]-1;
+    }
+    return header[2] ;
 }
 
 int  C2F(mxisstring)(mxArray *ptr)
 {
-  int *header = (int *) stkptr(*ptr);
-  if (header[0] < 0) header = (int *) stk(header[1]);
-  if (header[0] == STRINGMATRIX)
-    return 1;
-  else return 0;
+    int *header = (int *) stkptr(*ptr);
+    if (header[0] < 0) header = (int *) stk(header[1]);
+    if (header[0] == STRINGMATRIX)
+        return 1;
+    else return 0;
 }
 
 int  C2F(mxisnumeric)(mxArray *ptr)
 {
-  int *header = (int *) stkptr(*ptr);
-  if (header[0] < 0) header = (int *) stk(header[1]);
-  if ( header[0] == DOUBLEMATRIX)
-    return 1;
-  else
-    return 0;
+    int *header = (int *) stkptr(*ptr);
+    if (header[0] < 0) header = (int *) stk(header[1]);
+    if ( header[0] == DOUBLEMATRIX)
+        return 1;
+    else
+        return 0;
 }
 
 int  C2F(mxisfull)(mxArray *ptr)
 {
-  int *header = (int *) stkptr(*ptr);
-  if (header[0] < 0) header = (int *) stk(header[1]);
-  if ( header[0] == DOUBLEMATRIX) {
-    return 1;
-  }
-  return 0;
+    int *header = (int *) stkptr(*ptr);
+    if (header[0] < 0) header = (int *) stk(header[1]);
+    if ( header[0] == DOUBLEMATRIX) {
+        return 1;
+    }
+    return 0;
 }
 
 int  C2F(mxissparse)(mxArray *ptr)
 {
-  int *header = (int *) stkptr(*ptr);
-  if (header[0] < 0) header = (int *) stk(header[1]);
-  if (header[0] == SPARSEMATRIX) {
-    return 1;
-  }
-  return 0;
+    int *header = (int *) stkptr(*ptr);
+    if (header[0] < 0) header = (int *) stk(header[1]);
+    if (header[0] == SPARSEMATRIX) {
+        return 1;
+    }
+    return 0;
 }
 
 
 int  C2F(mxiscomplex)(mxArray *ptr)
 {
-  int *header = (int *) stkptr(*ptr);
-  if (header[0] < 0) header = (int *) stk(header[1]);
-  if (header[3] == DOUBLEMATRIX) {
-    return 1;
-  }
-  return 0;
+    int *header = (int *) stkptr(*ptr);
+    if (header[0] < 0) header = (int *) stk(header[1]);
+    if (header[3] == DOUBLEMATRIX) {
+        return 1;
+    }
+    return 0;
 }
 
 double  C2F(mxgetscalar)(mxArray *ptr)
 {
-  static int N,nnz;
-  double *value;
-  int *header = (int *) stkptr(*ptr);
-  if (header[0] < 0) header = (int *) stk(header[1]);
-  value = (double *) header;
- if (header[0] == DOUBLEMATRIX) {
-   return  value[2];
- }
- else if (header[0] == SPARSEMATRIX) {
-   nnz = header[4];   N = header[2];
-   return value[(5+nnz+N)/2+1];
- }
- else {
-   return 0;
- }
+    static int N,nnz;
+    double *value;
+    int *header = (int *) stkptr(*ptr);
+    if (header[0] < 0) header = (int *) stk(header[1]);
+    value = (double *) header;
+    if (header[0] == DOUBLEMATRIX) {
+        return  value[2];
+    }
+    else if (header[0] == SPARSEMATRIX) {
+        nnz = header[4];   N = header[2];
+        return value[(5+nnz+N)/2+1];
+    }
+    else {
+        return 0;
+    }
 }
 
 void  C2F(mexprintf)(char *error_msg, int len)
 {
-  char * buf;
-  if ((buf = (char *)MALLOC((unsigned)sizeof(char)*(len+1))) == NULL) {
-    cerro((char *)_("No more memory"));
-    return;
-  }
-  buf[len]='\0';
-  strncpy(buf, error_msg, (size_t)len);
-  sciprint("%s\n",buf);
-  FREE(buf);
+    char * buf;
+    if ((buf = (char *)MALLOC((unsigned)sizeof(char)*(len+1))) == NULL) {
+        cerro((char *)_("No more memory"));
+        return;
+    }
+    buf[len]='\0';
+    strncpy(buf, error_msg, (size_t)len);
+    sciprint("%s\n",buf);
+    FREE(buf);
 }
 
 void C2F(mexerrmsgtxt)(char *error_msg, int len)
 {
-  C2F(erro)(error_msg,len);
-  errjump();
+    C2F(erro)(error_msg,len);
+    errjump();
 }
 
 mxArray *C2F(mxcreatefull)(int *m, int *n, int *it)
 {
-  static int lr1;
-  int lrd;
-  if (! C2F(createptr)("d", m, n, it, &lr1, &lrd,1L)) {
-    return  (mxArray *) 0;
-  }
-  return (mxArray *) lrd ;
+    static int lr1;
+    int lrd;
+    if (! C2F(createptr)("d", m, n, it, &lr1, &lrd,1L)) {
+        return  (mxArray *) 0;
+    }
+    return (mxArray *) lrd ;
 }
 
 mxArray *C2F(mxcreatedoublematrix)(int *m, int *n, int *it)
 {
-  return (mxArray *) mxCreateDoubleMatrix(*m, *n, (mxComplexity)*it);
+    return (mxArray *) mxCreateDoubleMatrix(*m, *n, (mxComplexity)*it);
 }
 
 
 unsigned long int C2F(mxcalloc)(unsigned int *n, unsigned int *size)
 {
-  int m;
-  vraiptrst lrd;
-  m = (*n * *size) /sizeof(double) + 1;
-  if (! C2F(createstkptr)(&m, &lrd)) {
-    return 0;
-  }
-  return (unsigned long int) lrd;
+    int m;
+    vraiptrst lrd;
+    m = (*n * *size) /sizeof(double) + 1;
+    if (! C2F(createstkptr)(&m, &lrd)) {
+        return 0;
+    }
+    return (unsigned long int) lrd;
 }
 
 int  C2F(mxgetstring)(mxArray *ptr, char *str, int *strl)
 {
-  int commonlength; int nrows;
-  int *header = (int *) stkptr(*ptr);
-  if (header[0] < 0) header = (int *) stk(header[1]);
-  nrows = header[1];
-  /*  int ncols = value[2]; This is 1 */
-  commonlength=nrows*(header[5]-header[4]);
-  C2F(in2str)(&commonlength, &header[5+nrows], str,0L);
-  *strl = Min(*strl,commonlength);
-  return 0;
+    int commonlength; int nrows;
+    int *header = (int *) stkptr(*ptr);
+    if (header[0] < 0) header = (int *) stk(header[1]);
+    nrows = header[1];
+    /*  int ncols = value[2]; This is 1 */
+    commonlength=nrows*(header[5]-header[4]);
+    C2F(in2str)(&commonlength, &header[5+nrows], str,0L);
+    *strl = Min(*strl,commonlength);
+    return 0;
 }
 
 void C2F(mxfreematrix)(mxArray *ptr)
 {
-  return ;
+    return ;
 }
 
 
 mxArray * C2F(mxcreatestring)(char *string, long int l)
 {
-  static int i, lr1, lw, iprov, ilocal;
-  /** i = strlen(string); **/
-  i= l;
-  Nbvars++;
-  lw=Nbvars;
-  iprov = lw + Top -Rhs;
-  if( ! C2F(cresmat2)("mxCreateString:", &iprov, &i, &lr1, 15L)) {
-    return (mxArray *) 0;
-  }
-  C2F(cvstr)(&i, istk(lr1), string, (ilocal=0, &ilocal),l);
-  C2F(intersci).ntypes[lw-1]=36;
-  return (mxArray *) C2F(vstk).lstk[Top -Rhs + lw - 1];
+    static int i, lr1, lw, iprov, ilocal;
+    /** i = strlen(string); **/
+    i= l;
+    Nbvars++;
+    lw=Nbvars;
+    iprov = lw + Top -Rhs;
+    if( ! C2F(cresmat2)("mxCreateString:", &iprov, &i, &lr1, 15L)) {
+        return (mxArray *) 0;
+    }
+    C2F(cvstr)(&i, istk(lr1), string, (ilocal=0, &ilocal),l);
+    C2F(intersci).ntypes[lw-1]=36;
+    return (mxArray *) C2F(vstk).lstk[Top -Rhs + lw - 1];
 }
 
 
 int C2F(mxcopyreal8toptr)(double *y, mxArray *ptr, int *n)
 {
-  int one=1;
-  double *value = ((double *) *ptr);
-  C2F(dcopy)(n,y,&one,value,&one);
-  return 0;
+    int one=1;
+    double *value = ((double *) *ptr);
+    C2F(dcopy)(n,y,&one,value,&one);
+    return 0;
 }
 
 int C2F(mxcopycomplex16toptr)(double *y, mxArray *ptr, mxArray *pti, int *n)
 {
-  int one=1; int two=2;
-  double *value = ((double *) *ptr);
-  double *headerm = ((double *) *pti);
-  C2F(dcopy)(n,y,&two,value,&one);
-  C2F(dcopy)(n,++y,&two,headerm,&one);
-  return 0;
+    int one=1; int two=2;
+    double *value = ((double *) *ptr);
+    double *headerm = ((double *) *pti);
+    C2F(dcopy)(n,y,&two,value,&one);
+    C2F(dcopy)(n,++y,&two,headerm,&one);
+    return 0;
 }
 
 int C2F(mxcopyptrtoreal8)(mxArray *ptr, double *y, int *n)
 {
-  int one=1;
-  double *value = ((double *) *ptr);
-  C2F(dcopy)(n,value,&one,y,&one);
-  return 0;
+    int one=1;
+    double *value = ((double *) *ptr);
+    C2F(dcopy)(n,value,&one,y,&one);
+    return 0;
 }
 
 int C2F(mxcopyptrtocomplex16)(mxArray *ptr, mxArray *pti, double *y, int *n)
 {
-  int one=1; int two=2;
-  double *value = ((double *) *ptr);
-  double *headerm = ((double *) *pti);
-  C2F(dcopy)(n,value,&one,y,&two);
-  C2F(dcopy)(n,headerm,&one,++y,&two);
-  return 0;
+    int one=1; int two=2;
+    double *value = ((double *) *ptr);
+    double *headerm = ((double *) *pti);
+    C2F(dcopy)(n,value,&one,y,&two);
+    C2F(dcopy)(n,headerm,&one,++y,&two);
+    return 0;
 }
 
 /* mxCreateLogicalArray
- * mxIsLogicalScalarTrue */
+* mxIsLogicalScalarTrue */
 
 /* *mxRealloc(void *ptr, size_t size);
-    mxArray *mxCreateStringFromNChars(const char *str, int n);
-    int mxSetClassName(mxArray *pa, const char *classname);
-    int mxAddField(mxArray *pa, const char *fieldname);
-    void mxRemoveField(mxArray *pa, int field);
-    void mxSetCopyInCell(mxArray *pa, int i, mxArray *value);  */
+mxArray *mxCreateStringFromNChars(const char *str, int n);
+int mxSetClassName(mxArray *pa, const char *classname);
+int mxAddField(mxArray *pa, const char *fieldname);
+void mxRemoveField(mxArray *pa, int field);
+void mxSetCopyInCell(mxArray *pa, int i, mxArray *value);  */
index f91413d..b5c8d78 100644 (file)
@@ -135,7 +135,7 @@ mxArray *mxCreateLogicalMatrix(int m, int n);
  * @param value
  * @return
  */
-mxArray *mxCreateLogicalScalar(mxLOGICAL *value);
+mxArray *mxCreateLogicalScalar(mxLOGICAL value);
 
 /**
  * TODO : comment
index 55b090f..90829af 100644 (file)
@@ -74,7 +74,7 @@
     <ClCompile>
       <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>true</MinimalRebuild>
       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
@@ -119,7 +119,7 @@ del libmattemp.def &gt;nul
     </Midl>
     <ClCompile>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>true</MinimalRebuild>
       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
@@ -162,7 +162,7 @@ del libmattemp.def &gt;nul
     <ClCompile>
       <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <Optimization>MaxSpeed</Optimization>
-      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
@@ -207,7 +207,7 @@ del libmattemp.def &gt;nul
     </Midl>
     <ClCompile>
       <Optimization>MaxSpeed</Optimization>
-      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
@@ -296,6 +296,12 @@ del libmattemp.def &gt;nul
       <Project>{8d45767a-9b03-4905-97f6-d2f3f79141ea}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\symbol\symbol.vcxproj">
+      <Project>{2c60033b-0dbd-4ca4-80d3-176c9be9ce2f}</Project>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\types\types.vcxproj">
+      <Project>{64e090da-dcb5-4f4d-93d7-e88ddec9c2ef}</Project>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\cpp\mexlib.cpp" />
index 6261304..9b12e6e 100644 (file)
@@ -75,7 +75,7 @@
     <ClCompile>
       <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>true</MinimalRebuild>
       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
@@ -120,7 +120,7 @@ del libmextemp.def &gt;nul
     </Midl>
     <ClCompile>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>true</MinimalRebuild>
       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
@@ -163,7 +163,7 @@ del libmextemp.def &gt;nul
     <ClCompile>
       <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <Optimization>MaxSpeed</Optimization>
-      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
@@ -206,7 +206,7 @@ del libmextemp.def &gt;nul
     </Midl>
     <ClCompile>
       <Optimization>MaxSpeed</Optimization>
-      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
@@ -301,6 +301,12 @@ del libmextemp.def &gt;nul
       <Project>{8d45767a-9b03-4905-97f6-d2f3f79141ea}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\symbol\symbol.vcxproj">
+      <Project>{2c60033b-0dbd-4ca4-80d3-176c9be9ce2f}</Project>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\types\types.vcxproj">
+      <Project>{64e090da-dcb5-4f4d-93d7-e88ddec9c2ef}</Project>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
index ae7cbf4..c5786d3 100644 (file)
@@ -75,7 +75,7 @@
     <ClCompile>
       <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>true</MinimalRebuild>
       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
@@ -120,7 +120,7 @@ del libmxtemp.def &gt;nul
     </Midl>
     <ClCompile>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>true</MinimalRebuild>
       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
@@ -163,7 +163,7 @@ del libmxtemp.def &gt;nul
     <ClCompile>
       <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <Optimization>MaxSpeed</Optimization>
-      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
@@ -208,7 +208,7 @@ del libmxtemp.def &gt;nul
     </Midl>
     <ClCompile>
       <Optimization>MaxSpeed</Optimization>
-      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../core/includes;../../../string/includes;../../../elementary_functions/includes;../../../output_stream/includes;../../../call_scilab/includes;../../../localization/includes;../../includes;../../../../libs/MALLOC/includes;../../../../libs/intl;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
@@ -297,6 +297,12 @@ del libmxtemp.def &gt;nul
       <Project>{8d45767a-9b03-4905-97f6-d2f3f79141ea}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\symbol\symbol.vcxproj">
+      <Project>{2c60033b-0dbd-4ca4-80d3-176c9be9ce2f}</Project>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\types\types.vcxproj">
+      <Project>{64e090da-dcb5-4f4d-93d7-e88ddec9c2ef}</Project>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\cpp\mexlib.cpp" />
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateDouble.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateDouble.linux.dia.ref
new file mode 100644 (file)
index 0000000..7494bda
--- /dev/null
@@ -0,0 +1,81 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateDoubleMatrix, mxCreateDoubleScalar mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int i = 0;';
+        '   double dblM = 0;';
+        '   double dblN = 0;';
+        '   double *pdbl = NULL;';
+        '   mxArray* pOut1 = NULL;';
+        '   mxArray* pOut2 = NULL;';
+        '';
+        '   if(nrhs != 2 || nlhs != 2 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   dblM = mxGetScalar(prhs[0]);';
+        '   dblN = mxGetScalar(prhs[1]);';
+        '   pOut1 = mxCreateDoubleMatrix((int)dblM, (int)dblN, mxREAL);';
+        '   pOut2 = mxCreateDoubleScalar(dblM * dblN);';
+        '   pdbl = mxGetPr(pOut1);';
+        '   for(i = 0 ; i < dblM * dblN ; i++)';
+        '   {';
+        '       pdbl[i] = i+1;';
+        '   }';
+        '';
+        '   plhs[0] = pOut1;';
+        '   plhs[1] = pOut2;';
+        '}'],'mexCreateDoubleScalar.c');
+
+ilib_mex_build('libmex',['createDouble','mexCreateDoubleScalar','cmex'],'mexCreateDoubleScalar.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile
+   ilib_gen_Make: Copy compilation files (Makefile*, libtool...) to TMPDIR
+   ilib_gen_Make: Copy mexCreateDoubleScalar.c to TMPDIR
+   ilib_gen_Make: Copy libmex.c to TMPDIR
+   ilib_gen_Make: configure : Generate Makefile.
+   ilib_gen_Make: Modification of the Makefile in TMPDIR.
+   Running the makefile
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+m = 3;
+
+n = 4;
+
+[a,b] = createDouble(m, n);
+
+if b <> m*n then pause end
+
+if or(a(:)' <>  (1:m*n)) then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateDouble.tst b/scilab/modules/mexlib/tests/unit_tests/mxCreateDouble.tst
new file mode 100644 (file)
index 0000000..063b8b4
--- /dev/null
@@ -0,0 +1,51 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxCreateDoubleMatrix, mxCreateDoubleScalar mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int i = 0;';
+        '   double dblM = 0;';
+        '   double dblN = 0;';
+        '   double *pdbl = NULL;';
+        '   mxArray* pOut1 = NULL;';
+        '   mxArray* pOut2 = NULL;';
+        '';
+        '   if(nrhs != 2 || nlhs != 2 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   dblM = mxGetScalar(prhs[0]);';
+        '   dblN = mxGetScalar(prhs[1]);';
+        '   pOut1 = mxCreateDoubleMatrix((int)dblM, (int)dblN, mxREAL);';
+        '   pOut2 = mxCreateDoubleScalar(dblM * dblN);';
+        '   pdbl = mxGetPr(pOut1);';
+        '   for(i = 0 ; i < dblM * dblN ; i++)';
+        '   {';
+        '       pdbl[i] = i+1;';
+        '   }';
+        '';
+        '   plhs[0] = pOut1;';
+        '   plhs[1] = pOut2;';
+        '}'],'mexCreateDoubleScalar.c');
+ilib_mex_build('libmex',['createDouble','mexCreateDoubleScalar','cmex'],'mexCreateDoubleScalar.c',[],'Makelib','','','');
+exec('loader.sce');
+
+m = 3;
+n = 4;
+[a,b] = createDouble(m, n);
+if b <> m*n then pause end
+if or(a(:)' <>  (1:m*n)) then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateDouble.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateDouble.win.dia.ref
new file mode 100644 (file)
index 0000000..b89883d
--- /dev/null
@@ -0,0 +1,78 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateDoubleMatrix, mxCreateDoubleScalar mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int i = 0;';
+        '   double dblM = 0;';
+        '   double dblN = 0;';
+        '   double *pdbl = NULL;';
+        '   mxArray* pOut1 = NULL;';
+        '   mxArray* pOut2 = NULL;';
+        '';
+        '   if(nrhs != 2 || nlhs != 2 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   dblM = mxGetScalar(prhs[0]);';
+        '   dblN = mxGetScalar(prhs[1]);';
+        '   pOut1 = mxCreateDoubleMatrix((int)dblM, (int)dblN, mxREAL);';
+        '   pOut2 = mxCreateDoubleScalar(dblM * dblN);';
+        '   pdbl = mxGetPr(pOut1);';
+        '   for(i = 0 ; i < dblM * dblN ; i++)';
+        '   {';
+        '       pdbl[i] = i+1;';
+        '   }';
+        '';
+        '   plhs[0] = pOut1;';
+        '   plhs[1] = pOut2;';
+        '}'],'mexCreateDoubleScalar.c');
+
+ilib_mex_build('libmex',['createDouble','mexCreateDoubleScalar','cmex'],'mexCreateDoubleScalar.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexCreateDoubleScalar.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+m = 3;
+
+n = 4;
+
+[a,b] = createDouble(m, n);
+
+if b <> m*n then pause end
+
+if or(a(:)' <>  (1:m*n)) then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalMatrix.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalMatrix.linux.dia.ref
new file mode 100644 (file)
index 0000000..ea2fbd5
--- /dev/null
@@ -0,0 +1,66 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateLogicalMatrix mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   double* pdblM = NULL;';
+        '   double* pdblN = NULL;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 2 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   pdblM = mxGetPr(prhs[0]);';
+        '   pdblN = mxGetPr(prhs[1]);';
+        '   pOut = mxCreateLogicalMatrix((int)pdblM[0], (int)pdblN[0]);';
+        '   plhs[0] = pOut;';
+        '}'],'mexCreateLogicalMatrix.c');
+
+ilib_mex_build('libmex',['createLogicalMatrix', 'mexCreateLogicalMatrix', 'cmex'], 'mexCreateLogicalMatrix.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile
+   ilib_gen_Make: Copy compilation files (Makefile*, libtool...) to TMPDIR
+   ilib_gen_Make: Copy mexCreateLogicalMatrix.c to TMPDIR
+   ilib_gen_Make: Copy libmex.c to TMPDIR
+   ilib_gen_Make: configure : Generate Makefile.
+   ilib_gen_Make: Modification of the Makefile in TMPDIR.
+   Running the makefile
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = createLogicalMatrix(4,3);
+
+if size(a, "*") <> 12 then pause end
+
+if typeof(a) <> "boolean" then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalMatrix.tst b/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalMatrix.tst
new file mode 100644 (file)
index 0000000..3af642f
--- /dev/null
@@ -0,0 +1,38 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxCreateLogicalMatrix mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   double* pdblM = NULL;';
+        '   double* pdblN = NULL;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 2 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   pdblM = mxGetPr(prhs[0]);';
+        '   pdblN = mxGetPr(prhs[1]);';
+        '   pOut = mxCreateLogicalMatrix((int)pdblM[0], (int)pdblN[0]);';
+        '   plhs[0] = pOut;';
+        '}'],'mexCreateLogicalMatrix.c');
+ilib_mex_build('libmex',['createLogicalMatrix', 'mexCreateLogicalMatrix', 'cmex'], 'mexCreateLogicalMatrix.c', [], 'Makelib', '', '', '');
+exec('loader.sce');
+
+a = createLogicalMatrix(4,3);
+if size(a, "*") <> 12 then pause end
+if typeof(a) <> "boolean" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalMatrix.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalMatrix.win.dia.ref
new file mode 100644 (file)
index 0000000..23f1361
--- /dev/null
@@ -0,0 +1,63 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateLogicalMatrix mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   double* pdblM = NULL;';
+        '   double* pdblN = NULL;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 2 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   pdblM = mxGetPr(prhs[0]);';
+        '   pdblN = mxGetPr(prhs[1]);';
+        '   pOut = mxCreateLogicalMatrix((int)pdblM[0], (int)pdblN[0]);';
+        '   plhs[0] = pOut;';
+        '}'],'mexCreateLogicalMatrix.c');
+
+ilib_mex_build('libmex',['createLogicalMatrix', 'mexCreateLogicalMatrix', 'cmex'], 'mexCreateLogicalMatrix.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexCreateLogicalMatrix.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = createLogicalMatrix(4,3);
+
+if size(a, "*") <> 12 then pause end
+
+if typeof(a) <> "boolean" then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalScalar.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalScalar.linux.dia.ref
new file mode 100644 (file)
index 0000000..d768fcc
--- /dev/null
@@ -0,0 +1,71 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateLogicalScalar mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int bIn1 = 0;';
+        '   int bIn2 = 0;';
+        '   mxArray* pOut1 = NULL;';
+        '   mxArray* pOut2 = NULL;';
+        '';
+        '   if(nrhs != 2 || nlhs != 2/*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   bIn1 = mxIsLogicalScalarTrue(prhs[0]);';
+        '   bIn2 = mxIsLogicalScalarTrue(prhs[1]);';
+        '';
+        '   pOut1 = mxCreateLogicalScalar(!bIn1);';
+        '   pOut2 = mxCreateLogicalScalar(!bIn2);';
+        '';
+        '   plhs[0] = pOut1;';
+        '   plhs[1] = pOut2;';
+        '}'],'mexCreateLogicalScalar.c');
+
+ilib_mex_build('libmex', ['createLogicalScalar', 'mexCreateLogicalScalar', 'cmex'], 'mexCreateLogicalScalar.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile
+   ilib_gen_Make: Copy compilation files (Makefile*, libtool...) to TMPDIR
+   ilib_gen_Make: Copy mexCreateLogicalScalar.c to TMPDIR
+   ilib_gen_Make: Copy libmex.c to TMPDIR
+   ilib_gen_Make: configure : Generate Makefile.
+   ilib_gen_Make: Modification of the Makefile in TMPDIR.
+   Running the makefile
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+[out1, out2] = createLogicalScalar(%t, %f);
+
+if out1 <> %f then pause end
+
+if out2 <> %t then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalScalar.tst b/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalScalar.tst
new file mode 100644 (file)
index 0000000..8e699d3
--- /dev/null
@@ -0,0 +1,45 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxCreateLogicalScalar mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int bIn1 = 0;';
+        '   int bIn2 = 0;';
+        '   mxArray* pOut1 = NULL;';
+        '   mxArray* pOut2 = NULL;';
+        '';
+        '   if(nrhs != 2 || nlhs != 2/*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   bIn1 = mxIsLogicalScalarTrue(prhs[0]);';
+        '   bIn2 = mxIsLogicalScalarTrue(prhs[1]);';
+        '';
+        '   pOut1 = mxCreateLogicalScalar(!bIn1);';
+        '   pOut2 = mxCreateLogicalScalar(!bIn2);';
+        '';
+        '   plhs[0] = pOut1;';
+        '   plhs[1] = pOut2;';
+        '}'],'mexCreateLogicalScalar.c');
+ilib_mex_build('libmex', ['createLogicalScalar', 'mexCreateLogicalScalar', 'cmex'], 'mexCreateLogicalScalar.c', [], 'Makelib', '', '', '');
+exec('loader.sce');
+
+[out1, out2] = createLogicalScalar(%t, %f);
+
+if out1 <> %f then pause end
+if out2 <> %t then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalScalar.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalScalar.win.dia.ref
new file mode 100644 (file)
index 0000000..2ab903f
--- /dev/null
@@ -0,0 +1,68 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateLogicalScalar mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int bIn1 = 0;';
+        '   int bIn2 = 0;';
+        '   mxArray* pOut1 = NULL;';
+        '   mxArray* pOut2 = NULL;';
+        '';
+        '   if(nrhs != 2 || nlhs != 2/*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   bIn1 = mxIsLogicalScalarTrue(prhs[0]);';
+        '   bIn2 = mxIsLogicalScalarTrue(prhs[1]);';
+        '';
+        '   pOut1 = mxCreateLogicalScalar(!bIn1);';
+        '   pOut2 = mxCreateLogicalScalar(!bIn2);';
+        '';
+        '   plhs[0] = pOut1;';
+        '   plhs[1] = pOut2;';
+        '}'],'mexCreateLogicalScalar.c');
+
+ilib_mex_build('libmex', ['createLogicalScalar', 'mexCreateLogicalScalar', 'cmex'], 'mexCreateLogicalScalar.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexCreateLogicalScalar.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+[out1, out2] = createLogicalScalar(%t, %f);
+
+if out1 <> %f then pause end
+
+if out2 <> %t then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateNumericArray.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateNumericArray.linux.dia.ref
new file mode 100644 (file)
index 0000000..6a021eb
--- /dev/null
@@ -0,0 +1,125 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateNumericArray mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int piDims[3] = {4,3,2};';
+        '   int iDims = 3;';
+        '   mxClassID CLASS = 0;';
+        '   double* pdblType = NULL;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   pdblType = mxGetPr(prhs[0]);';
+        '   pOut = mxCreateNumericArray(iDims, piDims, (mxClassID)pdblType[0], mxREAL);';
+        '   plhs[0] = pOut;';
+        '}'],'mexCreateNumericArray.c');
+
+ilib_mex_build('libmex',['createNumericArray','mexCreateNumericArray','cmex'], 'mexCreateNumericArray.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile
+   ilib_gen_Make: Copy compilation files (Makefile*, libtool...) to TMPDIR
+   ilib_gen_Make: Copy mexCreateNumericArray.c to TMPDIR
+   ilib_gen_Make: Copy libmex.c to TMPDIR
+   ilib_gen_Make: configure : Generate Makefile.
+   ilib_gen_Make: Modification of the Makefile in TMPDIR.
+   Running the makefile
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+ref_int8 = int8(1);
+
+ref_int8(4,3,2) = int8(1);
+
+ref_int8(:) = int8(0);
+
+ref_uint8 = uint8(1);
+
+ref_uint8(4,3,2) = uint8(1);
+
+ref_uint8(:) = uint8(0);
+
+ref_int16 = int16(1);
+
+ref_int16(4,3,2) = int16(1);
+
+ref_int16(:) = int16(0);
+
+ref_uint16 = uint16(1);
+
+ref_uint16(4,3,2) = uint16(1);
+
+ref_uint16(:) = uint16(0);
+
+ref_int32 = int32(1);
+
+ref_int32(4,3,2) = int32(1);
+
+ref_int32(:) = int32(0);
+
+ref_uint32 = uint32(1);
+
+ref_uint32(4,3,2) = uint32(1);
+
+ref_uint32(:) = uint32(0);
+
+ref_int64 = int64(1);
+
+ref_int64(4,3,2) = int64(1);
+
+ref_int64(:) = int64(0);
+
+ref_uint64 = uint64(1);
+
+ref_uint64(4,3,2) = uint64(1);
+
+ref_uint64(:) = uint64(0);
+
+ret8 = createNumericArray(8);
+
+retU8 = createNumericArray(9);
+
+ret16 = createNumericArray(10);
+
+retU16 = createNumericArray(11);
+
+ret32 = createNumericArray(12);
+
+retU32 = createNumericArray(13);
+
+ret64 = createNumericArray(14);
+
+retU64 = createNumericArray(15);
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateNumericArray.tst b/scilab/modules/mexlib/tests/unit_tests/mxCreateNumericArray.tst
new file mode 100644 (file)
index 0000000..b5e10f5
--- /dev/null
@@ -0,0 +1,76 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxCreateNumericArray mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int piDims[3] = {4,3,2};';
+        '   int iDims = 3;';
+        '   mxClassID CLASS = 0;';
+        '   double* pdblType = NULL;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   pdblType = mxGetPr(prhs[0]);';
+        '   pOut = mxCreateNumericArray(iDims, piDims, (mxClassID)pdblType[0], mxREAL);';
+        '   plhs[0] = pOut;';
+        '}'],'mexCreateNumericArray.c');
+ilib_mex_build('libmex',['createNumericArray','mexCreateNumericArray','cmex'], 'mexCreateNumericArray.c',[],'Makelib','','','');
+exec('loader.sce');
+
+ref_int8 = int8(1);
+ref_int8(4,3,2) = int8(1);
+ref_int8(:) = int8(0);
+
+ref_uint8 = uint8(1);
+ref_uint8(4,3,2) = uint8(1);
+ref_uint8(:) = uint8(0);
+
+ref_int16 = int16(1);
+ref_int16(4,3,2) = int16(1);
+ref_int16(:) = int16(0);
+
+ref_uint16 = uint16(1);
+ref_uint16(4,3,2) = uint16(1);
+ref_uint16(:) = uint16(0);
+
+ref_int32 = int32(1);
+ref_int32(4,3,2) = int32(1);
+ref_int32(:) = int32(0);
+
+ref_uint32 = uint32(1);
+ref_uint32(4,3,2) = uint32(1);
+ref_uint32(:) = uint32(0);
+
+ref_int64 = int64(1);
+ref_int64(4,3,2) = int64(1);
+ref_int64(:) = int64(0);
+
+ref_uint64 = uint64(1);
+ref_uint64(4,3,2) = uint64(1);
+ref_uint64(:) = uint64(0);
+
+ret8 = createNumericArray(8);
+retU8 = createNumericArray(9);
+ret16 = createNumericArray(10);
+retU16 = createNumericArray(11);
+ret32 = createNumericArray(12);
+retU32 = createNumericArray(13);
+ret64 = createNumericArray(14);
+retU64 = createNumericArray(15);
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateNumericArray.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateNumericArray.win.dia.ref
new file mode 100644 (file)
index 0000000..872672d
--- /dev/null
@@ -0,0 +1,122 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateNumericArray mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int piDims[3] = {4,3,2};';
+        '   int iDims = 3;';
+        '   mxClassID CLASS = 0;';
+        '   double* pdblType = NULL;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   pdblType = mxGetPr(prhs[0]);';
+        '   pOut = mxCreateNumericArray(iDims, piDims, (mxClassID)pdblType[0], mxREAL);';
+        '   plhs[0] = pOut;';
+        '}'],'mexCreateNumericArray.c');
+
+ilib_mex_build('libmex',['createNumericArray','mexCreateNumericArray','cmex'], 'mexCreateNumericArray.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexCreateNumericArray.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+ref_int8 = int8(1);
+
+ref_int8(4,3,2) = int8(1);
+
+ref_int8(:) = int8(0);
+
+ref_uint8 = uint8(1);
+
+ref_uint8(4,3,2) = uint8(1);
+
+ref_uint8(:) = uint8(0);
+
+ref_int16 = int16(1);
+
+ref_int16(4,3,2) = int16(1);
+
+ref_int16(:) = int16(0);
+
+ref_uint16 = uint16(1);
+
+ref_uint16(4,3,2) = uint16(1);
+
+ref_uint16(:) = uint16(0);
+
+ref_int32 = int32(1);
+
+ref_int32(4,3,2) = int32(1);
+
+ref_int32(:) = int32(0);
+
+ref_uint32 = uint32(1);
+
+ref_uint32(4,3,2) = uint32(1);
+
+ref_uint32(:) = uint32(0);
+
+ref_int64 = int64(1);
+
+ref_int64(4,3,2) = int64(1);
+
+ref_int64(:) = int64(0);
+
+ref_uint64 = uint64(1);
+
+ref_uint64(4,3,2) = uint64(1);
+
+ref_uint64(:) = uint64(0);
+
+ret8 = createNumericArray(8);
+
+retU8 = createNumericArray(9);
+
+ret16 = createNumericArray(10);
+
+retU16 = createNumericArray(11);
+
+ret32 = createNumericArray(12);
+
+retU32 = createNumericArray(13);
+
+ret64 = createNumericArray(14);
+
+retU64 = createNumericArray(15);
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateString.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateString.linux.dia.ref
new file mode 100644 (file)
index 0000000..f892092
--- /dev/null
@@ -0,0 +1,62 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateString mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 0 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   pOut = mxCreateString(""Create new String"");';
+        '   plhs[0] = pOut;';
+        '}'],'mexCreateString.c');
+
+ilib_mex_build('libmex',['createString','mexCreateString','cmex'], 'mexCreateString.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile
+   ilib_gen_Make: Copy compilation files (Makefile*, libtool...) to TMPDIR
+   ilib_gen_Make: Copy mexCreateString.c to TMPDIR
+   ilib_gen_Make: Copy libmex.c to TMPDIR
+   ilib_gen_Make: configure : Generate Makefile.
+   ilib_gen_Make: Modification of the Makefile in TMPDIR.
+   Running the makefile
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+ref = "Create new String";
+
+a = createString();
+
+if a <> ref then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateString.tst b/scilab/modules/mexlib/tests/unit_tests/mxCreateString.tst
new file mode 100644 (file)
index 0000000..1541e17
--- /dev/null
@@ -0,0 +1,34 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxCreateString mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 0 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   pOut = mxCreateString(""Create new String"");';
+        '   plhs[0] = pOut;';
+        '}'],'mexCreateString.c');
+ilib_mex_build('libmex',['createString','mexCreateString','cmex'], 'mexCreateString.c',[],'Makelib','','','');
+exec('loader.sce');
+
+ref = "Create new String";
+a = createString();
+if a <> ref then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateString.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateString.win.dia.ref
new file mode 100644 (file)
index 0000000..0fee151
--- /dev/null
@@ -0,0 +1,59 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateString mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 0 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   pOut = mxCreateString(""Create new String"");';
+        '   plhs[0] = pOut;';
+        '}'],'mexCreateString.c');
+
+ilib_mex_build('libmex',['createString','mexCreateString','cmex'], 'mexCreateString.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexCreateString.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+ref = "Create new String";
+
+a = createString();
+
+if a <> ref then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxDuplicateArray.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxDuplicateArray.linux.dia.ref
new file mode 100644 (file)
index 0000000..55f2f39
--- /dev/null
@@ -0,0 +1,62 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxDuplicateArray mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   pOut = mxDuplicateArray(prhs[0]);';
+        '   plhs[0] = pOut;';
+        '}'],'mexDuplicateArray.c');
+
+ilib_mex_build('libmex',['duplicateArray','mexDuplicateArray','cmex'], 'mexDuplicateArray.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile
+   ilib_gen_Make: Copy compilation files (Makefile*, libtool...) to TMPDIR
+   ilib_gen_Make: Copy mexDuplicateArray.c to TMPDIR
+   ilib_gen_Make: Copy libmex.c to TMPDIR
+   ilib_gen_Make: configure : Generate Makefile.
+   ilib_gen_Make: Modification of the Makefile in TMPDIR.
+   Running the makefile
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = rand(4,3);
+
+b = duplicateArray(a);
+
+if a <> b then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxDuplicateArray.tst b/scilab/modules/mexlib/tests/unit_tests/mxDuplicateArray.tst
new file mode 100644 (file)
index 0000000..46e71a1
--- /dev/null
@@ -0,0 +1,34 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxDuplicateArray mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   pOut = mxDuplicateArray(prhs[0]);';
+        '   plhs[0] = pOut;';
+        '}'],'mexDuplicateArray.c');
+ilib_mex_build('libmex',['duplicateArray','mexDuplicateArray','cmex'], 'mexDuplicateArray.c',[],'Makelib','','','');
+exec('loader.sce');
+
+a = rand(4,3);
+b = duplicateArray(a);
+if a <> b then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxDuplicateArray.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxDuplicateArray.win.dia.ref
new file mode 100644 (file)
index 0000000..c063d6f
--- /dev/null
@@ -0,0 +1,59 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxDuplicateArray mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   pOut = mxDuplicateArray(prhs[0]);';
+        '   plhs[0] = pOut;';
+        '}'],'mexDuplicateArray.c');
+
+ilib_mex_build('libmex',['duplicateArray','mexDuplicateArray','cmex'], 'mexDuplicateArray.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexDuplicateArray.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = rand(4,3);
+
+b = duplicateArray(a);
+
+if a <> b then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetEps.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetEps.linux.dia.ref
new file mode 100644 (file)
index 0000000..edfaecb
--- /dev/null
@@ -0,0 +1,52 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetEps mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    double dblEps = mxGetEps();';
+       '    mxArray* pOut = mxCreateDoubleScalar(dblEps);';
+       '    plhs[0] = pOut;';
+       '}'],'mexgetEps.c');
+
+ilib_mex_build('libmex',['getEps','mexgetEps','cmex'], 'mexgetEps.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile
+   ilib_gen_Make: Copy compilation files (Makefile*, libtool...) to TMPDIR
+   ilib_gen_Make: Copy mexgetEps.c to TMPDIR
+   ilib_gen_Make: Copy libmex.c to TMPDIR
+   ilib_gen_Make: configure : Generate Makefile.
+   ilib_gen_Make: Modification of the Makefile in TMPDIR.
+   Running the makefile
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = getEps();
+
+if a <> %eps then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetEps.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetEps.tst
new file mode 100644 (file)
index 0000000..bee1aae
--- /dev/null
@@ -0,0 +1,26 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetEps mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    double dblEps = mxGetEps();';
+       '    mxArray* pOut = mxCreateDoubleScalar(dblEps);';
+       '    plhs[0] = pOut;';
+       '}'],'mexgetEps.c');
+ilib_mex_build('libmex',['getEps','mexgetEps','cmex'], 'mexgetEps.c',[],'Makelib','','','');
+exec('loader.sce');
+
+a = getEps();
+if a <> %eps then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetEps.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetEps.win.dia.ref
new file mode 100644 (file)
index 0000000..5b7fe3c
--- /dev/null
@@ -0,0 +1,49 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetEps mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    double dblEps = mxGetEps();';
+       '    mxArray* pOut = mxCreateDoubleScalar(dblEps);';
+       '    plhs[0] = pOut;';
+       '}'],'mexgetEps.c');
+
+ilib_mex_build('libmex',['getEps','mexgetEps','cmex'], 'mexgetEps.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetEps.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = getEps();
+
+if a <> %eps then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfDimensions.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfDimensions.linux.dia.ref
new file mode 100644 (file)
index 0000000..ef98213
--- /dev/null
@@ -0,0 +1,63 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetNumberOfDimensions mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int iDims = 0;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number of input argument"");';
+        '   }';
+        '';
+        '   iDims = mxGetNumberOfDimensions(prhs[0]);';
+        '   pOut = mxCreateDoubleScalar((double)iDims);';
+        '   plhs[0] = pOut;';
+        '}'],'mexGetNumberOfDimensions.c');
+
+ilib_mex_build('libmex',['getDims','mexGetNumberOfDimensions','cmex'], 'mexGetNumberOfDimensions.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile
+   ilib_gen_Make: Copy compilation files (Makefile*, libtool...) to TMPDIR
+   ilib_gen_Make: Copy mexGetNumberOfDimensions.c to TMPDIR
+   ilib_gen_Make: Copy libmex.c to TMPDIR
+   ilib_gen_Make: configure : Generate Makefile.
+   ilib_gen_Make: Modification of the Makefile in TMPDIR.
+   Running the makefile
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = ones(5,4,3,2);
+
+iDims = getDims(a);
+
+if iDims <> 4 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfDimensions.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfDimensions.tst
new file mode 100644 (file)
index 0000000..e362058
--- /dev/null
@@ -0,0 +1,37 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetNumberOfDimensions mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int iDims = 0;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number of input argument"");';
+        '   }';
+        '';
+        '   iDims = mxGetNumberOfDimensions(prhs[0]);';
+        '   pOut = mxCreateDoubleScalar((double)iDims);';
+        '   plhs[0] = pOut;';
+        '}'],'mexGetNumberOfDimensions.c');
+ilib_mex_build('libmex',['getDims','mexGetNumberOfDimensions','cmex'], 'mexGetNumberOfDimensions.c',[],'Makelib','','','');
+exec('loader.sce');
+
+a = ones(5,4,3,2);
+iDims = getDims(a);
+if iDims <> 4 then pause end
+
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfDimensions.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfDimensions.win.dia.ref
new file mode 100644 (file)
index 0000000..cda91ae
--- /dev/null
@@ -0,0 +1,60 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetNumberOfDimensions mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int iDims = 0;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number of input argument"");';
+        '   }';
+        '';
+        '   iDims = mxGetNumberOfDimensions(prhs[0]);';
+        '   pOut = mxCreateDoubleScalar((double)iDims);';
+        '   plhs[0] = pOut;';
+        '}'],'mexGetNumberOfDimensions.c');
+
+ilib_mex_build('libmex',['getDims','mexGetNumberOfDimensions','cmex'], 'mexGetNumberOfDimensions.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexGetNumberOfDimensions.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = ones(5,4,3,2);
+
+iDims = getDims(a);
+
+if iDims <> 4 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfElements.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfElements.linux.dia.ref
new file mode 100644 (file)
index 0000000..4cd5b95
--- /dev/null
@@ -0,0 +1,81 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetNumberOfElements mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int iSize = 0;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number of input argument"");';
+        '   }';
+        '';
+        '   iSize = mxGetNumberOfElements(prhs[0]);';
+        '   pOut = mxCreateDoubleScalar((double)iSize);';
+        '   plhs[0] = pOut;';
+        '}'],'mexGetNumberOfElements.c');
+
+ilib_mex_build('libmex',['getNumberOfElements','mexGetNumberOfElements','cmex'], 'mexGetNumberOfElements.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile
+   ilib_gen_Make: Copy compilation files (Makefile*, libtool...) to TMPDIR
+   ilib_gen_Make: Copy mexGetNumberOfElements.c to TMPDIR
+   ilib_gen_Make: Copy libmex.c to TMPDIR
+   ilib_gen_Make: configure : Generate Makefile.
+   ilib_gen_Make: Modification of the Makefile in TMPDIR.
+   Running the makefile
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = ones(1);
+
+var = getNumberOfElements(a);
+
+if var <> size(a, "*") then pause end
+
+a = ones(1, 2);
+
+var = getNumberOfElements(a);
+
+if var <> size(a, "*") then pause end
+
+a = ones(1, 2, 3);
+
+var = getNumberOfElements(a);
+
+if var <> size(a, "*") then pause end
+
+a = ones(1, 2, 3, 4);
+
+var = getNumberOfElements(a);
+
+if var <> size(a, "*") then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfElements.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfElements.tst
new file mode 100644 (file)
index 0000000..3404fc0
--- /dev/null
@@ -0,0 +1,48 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetNumberOfElements mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int iSize = 0;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number of input argument"");';
+        '   }';
+        '';
+        '   iSize = mxGetNumberOfElements(prhs[0]);';
+        '   pOut = mxCreateDoubleScalar((double)iSize);';
+        '   plhs[0] = pOut;';
+        '}'],'mexGetNumberOfElements.c');
+ilib_mex_build('libmex',['getNumberOfElements','mexGetNumberOfElements','cmex'], 'mexGetNumberOfElements.c',[],'Makelib','','','');
+exec('loader.sce');
+
+a = ones(1);
+var = getNumberOfElements(a);
+if var <> size(a, "*") then pause end
+
+a = ones(1, 2);
+var = getNumberOfElements(a);
+if var <> size(a, "*") then pause end
+
+a = ones(1, 2, 3);
+var = getNumberOfElements(a);
+if var <> size(a, "*") then pause end
+
+a = ones(1, 2, 3, 4);
+var = getNumberOfElements(a);
+if var <> size(a, "*") then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfElements.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfElements.win.dia.ref
new file mode 100644 (file)
index 0000000..a63f2f2
--- /dev/null
@@ -0,0 +1,78 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetNumberOfElements mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int iSize = 0;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number of input argument"");';
+        '   }';
+        '';
+        '   iSize = mxGetNumberOfElements(prhs[0]);';
+        '   pOut = mxCreateDoubleScalar((double)iSize);';
+        '   plhs[0] = pOut;';
+        '}'],'mexGetNumberOfElements.c');
+
+ilib_mex_build('libmex',['getNumberOfElements','mexGetNumberOfElements','cmex'], 'mexGetNumberOfElements.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexGetNumberOfElements.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = ones(1);
+
+var = getNumberOfElements(a);
+
+if var <> size(a, "*") then pause end
+
+a = ones(1, 2);
+
+var = getNumberOfElements(a);
+
+if var <> size(a, "*") then pause end
+
+a = ones(1, 2, 3);
+
+var = getNumberOfElements(a);
+
+if var <> size(a, "*") then pause end
+
+a = ones(1, 2, 3, 4);
+
+var = getNumberOfElements(a);
+
+if var <> size(a, "*") then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetScalar.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetScalar.linux.dia.ref
new file mode 100644 (file)
index 0000000..790e67c
--- /dev/null
@@ -0,0 +1,78 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetScalar mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   double dblScalar = 0;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   dblScalar = mxGetScalar(prhs[0]);';
+        '   pOut = mxCreateDoubleScalar(dblScalar);';
+        '   plhs[0] = pOut;';
+        '}'],'mexGetScalar.c');
+
+ilib_mex_build('libmex',['getScalar','mexGetScalar','cmex'], 'mexGetScalar.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile
+   ilib_gen_Make: Copy compilation files (Makefile*, libtool...) to TMPDIR
+   ilib_gen_Make: Copy mexGetScalar.c to TMPDIR
+   ilib_gen_Make: Copy libmex.c to TMPDIR
+   ilib_gen_Make: configure : Generate Makefile.
+   ilib_gen_Make: Modification of the Makefile in TMPDIR.
+   Running the makefile
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = 1:10;
+
+if getScalar(a) <> 1 then pause end
+
+if getScalar(int8(a)) <> 1 then pause end
+
+if getScalar(uint8(a)) <> 1 then pause end
+
+if getScalar(int16(a)) <> 1 then pause end
+
+if getScalar( uint16(a)) <> 1 then pause end
+
+if getScalar(int32(a)) <> 1 then pause end
+
+if getScalar(uint32(a)) <> 1 then pause end
+
+if getScalar(int64(a)) <> 1 then pause end
+
+if getScalar(uint64(a)) <> 1 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetScalar.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetScalar.tst
new file mode 100644 (file)
index 0000000..23a91bc
--- /dev/null
@@ -0,0 +1,44 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetScalar mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   double dblScalar = 0;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   dblScalar = mxGetScalar(prhs[0]);';
+        '   pOut = mxCreateDoubleScalar(dblScalar);';
+        '   plhs[0] = pOut;';
+        '}'],'mexGetScalar.c');
+ilib_mex_build('libmex',['getScalar','mexGetScalar','cmex'], 'mexGetScalar.c',[],'Makelib','','','');
+exec('loader.sce');
+
+a = 1:10;
+if getScalar(a) <> 1 then pause end
+if getScalar(int8(a)) <> 1 then pause end
+if getScalar(uint8(a)) <> 1 then pause end
+if getScalar(int16(a)) <> 1 then pause end
+if getScalar( uint16(a)) <> 1 then pause end
+if getScalar(int32(a)) <> 1 then pause end
+if getScalar(uint32(a)) <> 1 then pause end
+if getScalar(int64(a)) <> 1 then pause end
+if getScalar(uint64(a)) <> 1 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetScalar.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetScalar.win.dia.ref
new file mode 100644 (file)
index 0000000..97c4ac4
--- /dev/null
@@ -0,0 +1,75 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetScalar mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   double dblScalar = 0;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   dblScalar = mxGetScalar(prhs[0]);';
+        '   pOut = mxCreateDoubleScalar(dblScalar);';
+        '   plhs[0] = pOut;';
+        '}'],'mexGetScalar.c');
+
+ilib_mex_build('libmex',['getScalar','mexGetScalar','cmex'], 'mexGetScalar.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexGetScalar.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = 1:10;
+
+if getScalar(a) <> 1 then pause end
+
+if getScalar(int8(a)) <> 1 then pause end
+
+if getScalar(uint8(a)) <> 1 then pause end
+
+if getScalar(int16(a)) <> 1 then pause end
+
+if getScalar( uint16(a)) <> 1 then pause end
+
+if getScalar(int32(a)) <> 1 then pause end
+
+if getScalar(uint32(a)) <> 1 then pause end
+
+if getScalar(int64(a)) <> 1 then pause end
+
+if getScalar(uint64(a)) <> 1 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetSetMN.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetSetMN.linux.dia.ref
new file mode 100644 (file)
index 0000000..10bfe1c
--- /dev/null
@@ -0,0 +1,72 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetM, mxGetN, mSGetM, mxSetN mex functions
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '#include ""localization.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int i = 0;';
+        '   int iRows = 0;';
+        '   int iCols = 0;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   iRows = mxGetM(prhs[0]);';
+        '   iCols = mxGetN(prhs[0]);';
+        '   mxSetM(prhs[0], iRows * 2);';
+        '   mxSetN(prhs[0], iCols * 2);';
+        '   plhs[0] = prhs[0];';
+        '}'],'mexGetSetMN.c');
+
+ilib_mex_build('libmex',['expand','mexGetSetMN','cmex'], 'mexGetSetMN.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile
+   ilib_gen_Make: Copy compilation files (Makefile*, libtool...) to TMPDIR
+   ilib_gen_Make: Copy mexGetSetMN.c to TMPDIR
+   ilib_gen_Make: Copy libmex.c to TMPDIR
+   ilib_gen_Make: configure : Generate Makefile.
+   ilib_gen_Make: Modification of the Makefile in TMPDIR.
+   Running the makefile
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = [1,2;3,4];
+
+ref = a;
+
+ref(4,4) = 0;
+
+b = expand(a);
+
+if b <> ref then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetSetMN.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetSetMN.tst
new file mode 100644 (file)
index 0000000..df80e3c
--- /dev/null
@@ -0,0 +1,42 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetM, mxGetN, mSGetM, mxSetN mex functions
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        '#include ""localization.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int i = 0;';
+        '   int iRows = 0;';
+        '   int iCols = 0;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   iRows = mxGetM(prhs[0]);';
+        '   iCols = mxGetN(prhs[0]);';
+        '   mxSetM(prhs[0], iRows * 2);';
+        '   mxSetN(prhs[0], iCols * 2);';
+        '   plhs[0] = prhs[0];';
+        '}'],'mexGetSetMN.c');
+ilib_mex_build('libmex',['expand','mexGetSetMN','cmex'], 'mexGetSetMN.c',[],'Makelib','','','');
+exec('loader.sce');
+
+a = [1,2;3,4];
+ref = a;
+ref(4,4) = 0;
+b = expand(a);
+if b <> ref then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetSetMN.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetSetMN.win.dia.ref
new file mode 100644 (file)
index 0000000..87b12c9
--- /dev/null
@@ -0,0 +1,69 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetM, mxGetN, mSGetM, mxSetN mex functions
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '#include ""localization.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int i = 0;';
+        '   int iRows = 0;';
+        '   int iCols = 0;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   iRows = mxGetM(prhs[0]);';
+        '   iCols = mxGetN(prhs[0]);';
+        '   mxSetM(prhs[0], iRows * 2);';
+        '   mxSetN(prhs[0], iCols * 2);';
+        '   plhs[0] = prhs[0];';
+        '}'],'mexGetSetMN.c');
+
+ilib_mex_build('libmex',['expand','mexGetSetMN','cmex'], 'mexGetSetMN.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexGetSetMN.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = [1,2;3,4];
+
+ref = a;
+
+ref(4,4) = 0;
+
+b = expand(a);
+
+if b <> ref then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetSetPri.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetSetPri.linux.dia.ref
new file mode 100644 (file)
index 0000000..1d237df
--- /dev/null
@@ -0,0 +1,77 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetPr, mxGetPi, mSGetPr, mxSetPi,  mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int i = 0;';
+        '   int iSize = 0;';
+        '   mxArray* pOut = NULL;';
+        '   double* pDblR = NULL;';
+        '   double* pDblI = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   iSize = mxGetNumberOfElements(prhs[0]);';
+        '   pDblR = mxGetPr(prhs[0]);';
+        '   pDblI = mxGetPi(prhs[0]);';
+        '   pOut = mxCreateDoubleMatrix(1, iSize, 1);';
+        '   mxSetPr(pOut, pDblI);';
+        '   mxSetPi(pOut, pDblR);';
+        '   plhs[0] = pOut;';
+        '}'],'mexswapRI.c');
+
+ilib_mex_build('libmex',['swapRI','mexswapRI','cmex'], 'mexswapRI.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile
+   ilib_gen_Make: Copy compilation files (Makefile*, libtool...) to TMPDIR
+   ilib_gen_Make: Copy mexswapRI.c to TMPDIR
+   ilib_gen_Make: Copy libmex.c to TMPDIR
+   ilib_gen_Make: configure : Generate Makefile.
+   ilib_gen_Make: Modification of the Makefile in TMPDIR.
+   Running the makefile
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = 1:8;
+
+b = 8:-1:1;
+
+var1 = a + b * %i;
+
+ref = b + a * %i;
+
+var2 = swapRI(var1);
+
+if var2 <> ref then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetSetPri.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetSetPri.tst
new file mode 100644 (file)
index 0000000..9812d43
--- /dev/null
@@ -0,0 +1,48 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetPr, mxGetPi, mSGetPr, mxSetPi,  mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int i = 0;';
+        '   int iSize = 0;';
+        '   mxArray* pOut = NULL;';
+        '   double* pDblR = NULL;';
+        '   double* pDblI = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   iSize = mxGetNumberOfElements(prhs[0]);';
+        '   pDblR = mxGetPr(prhs[0]);';
+        '   pDblI = mxGetPi(prhs[0]);';
+        '   pOut = mxCreateDoubleMatrix(1, iSize, 1);';
+        '   mxSetPr(pOut, pDblI);';
+        '   mxSetPi(pOut, pDblR);';
+        '   plhs[0] = pOut;';
+        '}'],'mexswapRI.c');
+ilib_mex_build('libmex',['swapRI','mexswapRI','cmex'], 'mexswapRI.c',[],'Makelib','','','');
+exec('loader.sce');
+
+a = 1:8;
+b = 8:-1:1;
+var1 = a + b * %i;
+ref = b + a * %i;
+var2 = swapRI(var1);
+if var2 <> ref then pause end
+
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetSetPri.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetSetPri.win.dia.ref
new file mode 100644 (file)
index 0000000..d3fd188
--- /dev/null
@@ -0,0 +1,74 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetPr, mxGetPi, mSGetPr, mxSetPi,  mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int i = 0;';
+        '   int iSize = 0;';
+        '   mxArray* pOut = NULL;';
+        '   double* pDblR = NULL;';
+        '   double* pDblI = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   iSize = mxGetNumberOfElements(prhs[0]);';
+        '   pDblR = mxGetPr(prhs[0]);';
+        '   pDblI = mxGetPi(prhs[0]);';
+        '   pOut = mxCreateDoubleMatrix(1, iSize, 1);';
+        '   mxSetPr(pOut, pDblI);';
+        '   mxSetPi(pOut, pDblR);';
+        '   plhs[0] = pOut;';
+        '}'],'mexswapRI.c');
+
+ilib_mex_build('libmex',['swapRI','mexswapRI','cmex'], 'mexswapRI.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexswapRI.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = 1:8;
+
+b = 8:-1:1;
+
+var1 = a + b * %i;
+
+ref = b + a * %i;
+
+var2 = swapRI(var1);
+
+if var2 <> ref then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxIsEmpty.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxIsEmpty.linux.dia.ref
new file mode 100644 (file)
index 0000000..4e93033
--- /dev/null
@@ -0,0 +1,86 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxIsEmpty mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int bEmpty = 0;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   bEmpty = mxIsEmpty(prhs[0]);';
+        '   pOut = mxCreateLogicalScalar(bEmpty);';
+        '   plhs[0] = pOut;';
+        '}'],'mexIsEmpty.c');
+
+ilib_mex_build('libmex',['isEmpty','mexIsEmpty','cmex'], 'mexIsEmpty.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile
+   ilib_gen_Make: Copy compilation files (Makefile*, libtool...) to TMPDIR
+   ilib_gen_Make: Copy mexIsEmpty.c to TMPDIR
+   ilib_gen_Make: Copy libmex.c to TMPDIR
+   ilib_gen_Make: configure : Generate Makefile.
+   ilib_gen_Make: Modification of the Makefile in TMPDIR.
+   Running the makefile
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = list();
+
+if isEmpty(a) <> %t then pause end
+
+a = list(1);
+
+if isEmpty(a) <> %f then pause end
+
+a = {};
+
+if isEmpty(a) <> %t then pause end
+
+a = {1};
+
+if isEmpty(a) <> %f then pause end
+
+a = [];
+
+if isEmpty(a) <> %t then pause end
+
+a = [1];
+
+if isEmpty(a) <> %f then pause end
+
+a = "";
+
+if isEmpty(a) <> %f then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxIsEmpty.tst b/scilab/modules/mexlib/tests/unit_tests/mxIsEmpty.tst
new file mode 100644 (file)
index 0000000..2bb1586
--- /dev/null
@@ -0,0 +1,55 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxIsEmpty mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int bEmpty = 0;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   bEmpty = mxIsEmpty(prhs[0]);';
+        '   pOut = mxCreateLogicalScalar(bEmpty);';
+        '   plhs[0] = pOut;';
+        '}'],'mexIsEmpty.c');
+ilib_mex_build('libmex',['isEmpty','mexIsEmpty','cmex'], 'mexIsEmpty.c',[],'Makelib','','','');
+exec('loader.sce');
+
+a = list();
+if isEmpty(a) <> %t then pause end
+
+a = list(1);
+if isEmpty(a) <> %f then pause end
+
+a = {};
+if isEmpty(a) <> %t then pause end
+
+a = {1};
+if isEmpty(a) <> %f then pause end
+
+a = [];
+if isEmpty(a) <> %t then pause end
+
+a = [1];
+if isEmpty(a) <> %f then pause end
+
+a = "";
+if isEmpty(a) <> %f then pause end
+
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxIsEmpty.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxIsEmpty.win.dia.ref
new file mode 100644 (file)
index 0000000..3949671
--- /dev/null
@@ -0,0 +1,83 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxIsEmpty mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int bEmpty = 0;';
+        '   mxArray* pOut = NULL;';
+        '';
+        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
+        '   {';
+        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
+        '   }';
+        '';
+        '   bEmpty = mxIsEmpty(prhs[0]);';
+        '   pOut = mxCreateLogicalScalar(bEmpty);';
+        '   plhs[0] = pOut;';
+        '}'],'mexIsEmpty.c');
+
+ilib_mex_build('libmex',['isEmpty','mexIsEmpty','cmex'], 'mexIsEmpty.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexIsEmpty.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = list();
+
+if isEmpty(a) <> %t then pause end
+
+a = list(1);
+
+if isEmpty(a) <> %f then pause end
+
+a = {};
+
+if isEmpty(a) <> %t then pause end
+
+a = {1};
+
+if isEmpty(a) <> %f then pause end
+
+a = [];
+
+if isEmpty(a) <> %t then pause end
+
+a = [1];
+
+if isEmpty(a) <> %f then pause end
+
+a = "";
+
+if isEmpty(a) <> %f then pause end
+
index 96a789e..fefea2d 100644 (file)
@@ -291,6 +291,7 @@ int DotPowerDoubleByDouble(Double* _pDouble1, Double* _pDouble2, Double** _pDoub
 
             if(_pDouble2->isComplex())
             {
+                iResultComplex = 1;
                 for(int i = 0 ; i < _pDouble2->getSize() ; i++)
                 {
                     iPowerComplexScalarByComplexScalar(
@@ -301,6 +302,7 @@ int DotPowerDoubleByDouble(Double* _pDouble1, Double* _pDouble2, Double** _pDoub
             }
             else
             {
+                iResultComplex = 1;
                 for(int i = 0 ; i < _pDouble2->getSize() ; i++)
                 {
                     iPowerComplexScalarByRealScalar(
@@ -315,6 +317,7 @@ int DotPowerDoubleByDouble(Double* _pDouble1, Double* _pDouble2, Double** _pDoub
             double dblR1 = _pDouble1->get(0);
             if(_pDouble2->isComplex())
             {
+                iResultComplex = 1;
                 for(int i = 0 ; i < _pDouble2->getSize() ; i++)
                 {
                     iPowerRealScalarByComplexScalar(
@@ -346,17 +349,19 @@ int DotPowerDoubleByDouble(Double* _pDouble1, Double* _pDouble2, Double** _pDoub
             if(_pDouble2->isComplex())
             {
                 double dblI2 = _pDouble2->getImg(0);
+                iResultComplex = 1;
                 for(int i = 0 ; i < _pDouble1->getSize() ; i++)
                 {
                     iPowerComplexScalarByComplexScalar(
                         _pDouble1->get(i), _pDouble1->getImg(i),
                         dblR2, dblI2,
                         &(*_pDoubleOut)->get()[i], &(*_pDoubleOut)->getImg()[i]);
-                }
+               }
             }
             else
             {
                 double dblR2 = _pDouble2->get(0);
+                iResultComplex = 1;
                 for(int i = 0 ; i < _pDouble1->getSize() ; i++)
                 {
                     iPowerComplexScalarByRealScalar(
@@ -372,6 +377,7 @@ int DotPowerDoubleByDouble(Double* _pDouble1, Double* _pDouble2, Double** _pDoub
             if(_pDouble2->isComplex())
             {
                 double dblI2 = _pDouble2->getImg(0);
+                iResultComplex = 1;
                 for(int i = 0 ; i < _pDouble1->getSize() ; i++)
                 {
                     iPowerRealScalarByComplexScalar(
@@ -421,6 +427,7 @@ int DotPowerDoubleByDouble(Double* _pDouble1, Double* _pDouble2, Double** _pDoub
         {
             if(_pDouble2->isComplex())
             {
+                iResultComplex = 1;
                 for(int i = 0 ; i < _pDouble1->getSize() ; i++)
                 {
                     iPowerComplexScalarByComplexScalar(
@@ -431,6 +438,7 @@ int DotPowerDoubleByDouble(Double* _pDouble1, Double* _pDouble2, Double** _pDoub
             }
             else
             {
+                iResultComplex = 1;
                 for(int i = 0 ; i < _pDouble1->getSize() ; i++)
                 {
                     iPowerComplexScalarByRealScalar(
@@ -444,6 +452,7 @@ int DotPowerDoubleByDouble(Double* _pDouble1, Double* _pDouble2, Double** _pDoub
         {
             if(_pDouble2->isComplex())
             {
+                iResultComplex = 1;
                 for(int i = 0 ; i < _pDouble1->getSize() ; i++)
                 {
                     iPowerRealScalarByComplexScalar(
index 461a066..b283730 100644 (file)
@@ -20,6 +20,7 @@ extern "C"
 {
 #endif
     EXTERN_SYMBOL void addGatewayInContext(wchar_t* _pwstName, OLDGW_FUNC _pFunc, wchar_t* _pwstModule);
+    EXTERN_SYMBOL void addMexGatewayInContext(wchar_t* _pwstName, MEXGW_FUNC _pFunc, wchar_t* _pwstModule);
 #ifdef __cplusplus
 }
 #endif
index e3ed2e3..f6a45ae 100644 (file)
 #include "macrofile.hxx"
 #include "addGatewayInContext.h"
 
-void addGatewayInContext(wchar_t* _pwstName , OLDGW_FUNC _pFunc, wchar_t* _pwstModule)
+void addGatewayInContext(wchar_t* _pwstName, OLDGW_FUNC _pFunc, wchar_t* _pwstModule)
+{
+    symbol::Context::getInstance()->AddFunction(types::Function::createFunction(_pwstName, _pFunc, _pwstModule));
+}
+
+void addMexGatewayInContext(wchar_t* _pwstName, MEXGW_FUNC _pFunc, wchar_t* _pwstModule)
 {
     symbol::Context::getInstance()->AddFunction(types::Function::createFunction(_pwstName, _pFunc, _pwstModule));
 }
index 8db511f..53af01c 100644 (file)
@@ -14,5 +14,6 @@
 
 #define C_GATEWAY_PROTOTYPE(__gateway__) int __gateway__(char* fname, int* _piKey)
 typedef int (*OLDGW_FUNC)(char *fname, int* _piKey);
+typedef int (*MEXGW_FUNC)(int nlhs, int* plhs[], int nrhs, int* prhs[]);
 
 #endif /* !__C_GATEWAY_PROTOTYPE_H__ */
index 5b44c0d..326e739 100644 (file)
@@ -48,8 +48,10 @@ namespace types
 
         static Function*        createFunction(std::wstring _szName, GW_FUNC _pFunc, std::wstring _szModule);
         static Function*        createFunction(std::wstring _szName, OLDGW_FUNC _pFunc, std::wstring _szModule);
+        static Function*        createFunction(std::wstring _szName, MEXGW_FUNC _pFunc, std::wstring _szModule);
         static Function*        createFunction(std::wstring _szName, GW_FUNC _pFunc, LOAD_DEPS _pLoadDeps, std::wstring _szModule);
         static Function*        createFunction(std::wstring _szName, OLDGW_FUNC _pFunc, LOAD_DEPS _pLoadDeps, std::wstring _szModule);
+        static Function*        createFunction(std::wstring _szName, MEXGW_FUNC _pFunc, LOAD_DEPS _pLoadDeps, std::wstring _szModule);
 
         Function*               getAsFunction(void);
         RealType                getType(void) { return RealFunction; }
@@ -92,6 +94,22 @@ namespace types
         OLDGW_FUNC              m_pOldFunc;
     };
 
+    class WrapMexFunction : public Function
+    {
+    private :
+                                WrapMexFunction(WrapMexFunction* _pWrapFunction);
+    public :
+                                WrapMexFunction(std::wstring _szName, MEXGW_FUNC _pFunc, LOAD_DEPS _pLoadDeps, std::wstring _szModule);
+
+                                Callable::ReturnValue call(typed_list &in, int _iRetCount, typed_list &out, ast::ConstVisitor* execFunc);
+        InternalType*           clone();
+
+        MEXGW_FUNC              getFunc() { return m_pOldFunc; }
+
+    private :
+        MEXGW_FUNC              m_pOldFunc;
+    };
+
     class GatewayStruct
     {
     public :
index 8b0f12e..c37f958 100644 (file)
@@ -80,6 +80,9 @@ namespace types
 
         virtual InternalType*       clone(void) { return NULL;}
 
+        virtual bool resize(int* _piDims, int _iDims){return true;}
+        virtual bool resize(int _iNewRows, int _iNewCols){return true;}
+
     };
 
     static bool isCoordIndex(int _iIndex, int* _piCoord, int _iCoordCount)
index 06b2f95..1c6fade 100644 (file)
@@ -34,6 +34,11 @@ namespace types
         return new WrapFunction(_stName, _pFunc, NULL, _stModule);
     }
 
+    Function *Function::createFunction(std::wstring _stName, MEXGW_FUNC _pFunc, std::wstring _stModule)
+    {
+        return new WrapMexFunction(_stName, _pFunc, NULL, _stModule);
+    }
+
     Function *Function::createFunction(std::wstring _stName, GW_FUNC _pFunc, LOAD_DEPS _pLoadDeps, std::wstring _stModule)
     {
         return new Function(_stName, _pFunc, _pLoadDeps, _stModule);
@@ -44,6 +49,11 @@ namespace types
         return new WrapFunction(_stName, _pFunc, _pLoadDeps, _stModule);
     }
 
+    Function *Function::createFunction(std::wstring _stName, MEXGW_FUNC _pFunc, LOAD_DEPS _pLoadDeps, std::wstring _stModule)
+    {
+        return new WrapMexFunction(_stName, _pFunc, _pLoadDeps, _stModule);
+    }
+
     Function::Function(std::wstring _stName, GW_FUNC _pFunc, LOAD_DEPS _pLoadDeps, std::wstring _stModule) : Callable(), m_pFunc(_pFunc), m_pLoadDeps(_pLoadDeps)
     {
         setName(_stName);
@@ -158,4 +168,60 @@ namespace types
         }
         return retVal;
     }
+
+    WrapMexFunction::WrapMexFunction(std::wstring _stName, MEXGW_FUNC _pFunc, LOAD_DEPS _pLoadDeps, std::wstring _stModule)
+    {
+        m_stName = _stName;
+        m_pOldFunc = _pFunc;
+        m_stModule = _stModule;
+        m_pLoadDeps = _pLoadDeps;
+    }
+
+    WrapMexFunction::WrapMexFunction(WrapMexFunction* _pWrapFunction)
+    {
+        m_stModule  = _pWrapFunction->getModule();
+        m_stName    = _pWrapFunction->getName();
+        m_pOldFunc  = _pWrapFunction->getFunc();
+        m_pLoadDeps = _pWrapFunction->getDeps();
+    }
+
+    InternalType* WrapMexFunction::clone()
+    {
+        return new WrapMexFunction(this);
+    }
+
+    Function::ReturnValue WrapMexFunction::call(typed_list &in, int _iRetCount, typed_list &out, ast::ConstVisitor* execFunc)
+    {
+        if (m_pLoadDeps != NULL)
+        {
+            m_pLoadDeps();
+        }
+
+        ReturnValue retVal = Callable::OK;
+
+        int nlhs = _iRetCount;
+        int** plhs = new int*[nlhs];
+        memset(plhs, 0x00, sizeof(int*) * nlhs);
+
+        int nrhs = (int)in.size();
+        int** prhs = new int*[nrhs];
+        for(int i = 0 ; i < nrhs ; i++)
+        {
+            prhs[i] = (int*)(in[i]);
+        }
+
+        m_pOldFunc(nlhs, plhs, nrhs, prhs);
+
+        if(_iRetCount == 1 && plhs[0] == NULL)
+        {//dont copy empty values, juste return "no value"
+            return retVal;
+        }
+
+        for(int i = 0 ; i < nlhs ; i++)
+        {
+            out.push_back((types::InternalType*)plhs[i]);
+        }
+
+        return retVal;
+    }
 }