Some mexlib unit tests. 31/4431/8
Iuri de Silvio [Fri, 8 Jul 2011 03:51:23 +0000 (00:51 -0300)]
Change-Id: I9d314a8e40031d477d1b564eb83ba5d7e769c4b7

124 files changed:
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/libmat/libmat.vcxproj
scilab/modules/mexlib/src/libmex/libmex.vcxproj
scilab/modules/mexlib/src/libmx/libmx.vcxproj
scilab/modules/mexlib/tests/unit_tests/mexEvalString.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexEvalString.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexEvalString.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexGetArray.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexGetArray.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexGetArray.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexGetVariable.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexGetVariable.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexGetVariable.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexGetVariablePtr.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexGetVariablePtr.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexGetVariablePtr.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexIsGlobal.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexIsGlobal.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexIsGlobal.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexPrintf.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexPrintf.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexPrintf.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexPutVariable.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexPutVariable.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mexPutVariable.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxAddField.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxAddField.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxAddField.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxArrayToString.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxArrayToString.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxArrayToString.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxAssert.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxAssert.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCalcSingleSubscript.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCalcSingleSubscript.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCalcSingleSubscript.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCheckTypes.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCheckTypes.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCheckTypes.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateCell.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateCell.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateCell.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalArray.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalArray.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalArray.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateStruct.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateStruct.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxCreateStruct.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetChars.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetChars.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetChars.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetClassID.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetClassID.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetClassID.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetClassName.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetClassName.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetClassName.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetDimensions.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetDimensions.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetDimensions.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetField.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetField.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetField.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetFieldByNumber.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetFieldByNumber.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetFieldByNumber.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetFieldNameByNumber.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetFieldNameByNumber.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetFieldNameByNumber.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetFieldNumber.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetFieldNumber.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetFieldNumber.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetInf.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetInf.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetInf.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetLogicals.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetLogicals.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetLogicals.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetNaN.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetNaN.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetNaN.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfFields.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfFields.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfFields.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetScalar.tst
scilab/modules/mexlib/tests/unit_tests/mxGetSetData.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetSetData.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetSetData.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetString.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetString.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxGetString.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsClass.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsClass.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsClass.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsComplex.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsComplex.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsComplex.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsFinite.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsFinite.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsFinite.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsInf.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsInf.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsInf.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsLogicalScalar.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsLogicalScalar.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsLogicalScalar.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsNaN.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsNaN.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxIsNaN.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxSetCell.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxSetCell.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxSetCell.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxSetDimensions.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxSetDimensions.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxSetDimensions.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxSetField.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxSetField.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxSetField.win.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxSetFieldByNumber.linux.dia.ref [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxSetFieldByNumber.tst [new file with mode: 0644]
scilab/modules/mexlib/tests/unit_tests/mxSetFieldByNumber.win.dia.ref [new file with mode: 0644]

index 47bb76d..847037a 100644 (file)
@@ -15,7 +15,11 @@ MEXLIB_FLAGS =       -I$(srcdir)/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
+               -I$(top_srcdir)/modules/abstractSyntaxTree/includes \
+               -I$(top_srcdir)/modules/parse/includes \
+               -I$(top_srcdir)/modules/system_env/includes \
+               -I$(top_srcdir)/modules/threads/includes/ \
+               -I$(top_srcdir)/modules/api_scilab/includes/
 
 MEXLIB_DEP =  \
        $(top_builddir)/modules/dynamic_link/libscidynamic_link.la \
index 45a1da3..ccf20be 100644 (file)
@@ -422,7 +422,11 @@ MEXLIB_FLAGS = -I$(srcdir)/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
+               -I$(top_srcdir)/modules/abstractSyntaxTree/includes \
+               -I$(top_srcdir)/modules/parse/includes \
+               -I$(top_srcdir)/modules/system_env/includes \
+               -I$(top_srcdir)/modules/threads/includes/ \
+               -I$(top_srcdir)/modules/api_scilab/includes/
 
 MEXLIB_DEP = \
        $(top_builddir)/modules/dynamic_link/libscidynamic_link.la \
index 94efe65..add806f 100644 (file)
@@ -26,7 +26,7 @@ extern "C"
 
 #include <stdio.h>
 #include "machine.h"
-//#include "stack-c.h"
+#include <assert.h>
 
     typedef int Matrix;
     typedef unsigned long int vraiptrst;
@@ -53,8 +53,8 @@ extern "C"
     /* mexGetArray : NOT IN MATLAB API - V6.4 compatible */
 #define mexGetArrayPtr(name,type) mexGetArray(name,type)
 
-    void mexPrintf(const char *fmt, ...);
-    void C2F(mexprintf) (char *error_msg, int len);
+    int mexPrintf(const char *format, ...);
+    void C2F(mexprintf)(char *error_msg, int len);
 
     /* mexPutFull: NOT IN MATLAB API - V4 compatible */
     int mexPutFull(char *name, int m, int n, double *pr, double *pi);
@@ -69,9 +69,9 @@ extern "C"
 
     mxArray *mxCreateCharMatrixFromStrings(int m, const char **str);
     mxArray *mxCreateString(const char *string);
-    mxArray *C2F(mxcreatestring) (char *string, long int l);
+    mxArray *C2F(mxcreatestring)(char *string, long int l);
     /* mxcreatefull : NOT IN MATLAB API - v4 compatible */
-    mxArray *C2F(mxcreatefull) (int *m, int *n, int *it);
+    mxArray *C2F(mxcreatefull)(int *m, int *n, int *it);
     mxArray *mxCreateCharArray(int ND, const int *size);
 
     mxArray *mxCreateCellArray(int ND, const int *size);
@@ -80,106 +80,108 @@ extern "C"
     mxArray *mxCreateStructArray(int ndim, const int *dims, int nfields, const char **field_names);
     mxArray *mxCreateStructMatrix(int m, int n, int nfields, const char **field_names);
 
-    mxArray *mxGetCell(const mxArray * ptr, int index);
+    mxArray *mxGetCell(const mxArray *ptr, int index);
 
-    double mxGetScalar(const mxArray * ptr);
-    double C2F(mxgetscalar) (mxArray * ptr);
-    double *mxGetPi(const mxArray * ptr);
-    double *C2F(mxgetpi) (mxArray * ptr);
-    double *mxGetPr(const mxArray * ptr);
-    double *C2F(mxgetpr) (mxArray * ptr);
+    double mxGetScalar(const mxArray *ptr);
+    double C2F(mxgetscalar)(mxArray *ptr);
+    double *mxGetPi(const mxArray *ptr);
+    double *C2F(mxgetpi)(mxArray *ptr);
+    double *mxGetPr(const mxArray *ptr);
+    double *C2F(mxgetpr)(mxArray *ptr);
     double mxGetInf(void);
     double mxGetNaN(void);
     double mxGetEps(void);
     bool mxIsNaN(double x);
     bool mxIsInf(double x);
     bool mxIsFinite(double x);
-    int *mxGetDimensions(const mxArray * ptr);
-    int mxCalcSingleSubscript(const mxArray * ptr, int nsubs, const int *subs);
-    int mxGetNumberOfElements(const mxArray * ptr);
-    int mxGetNumberOfDimensions(const mxArray * ptr);
-    int mxGetNumberOfFields(const mxArray * ptr);
-    void *mxGetData(const mxArray * ptr);
-    void *mxGetImagData(const mxArray * ptr);
+    int *mxGetDimensions(const mxArray *ptr);
+    int mxCalcSingleSubscript(const mxArray *ptr, int nsubs, const int *subs);
+    const char *mexFunctionName(void);
+    int mxGetNumberOfElements(const mxArray *ptr);
+    int mxGetNumberOfDimensions(const mxArray *ptr);
+    int mxGetNumberOfFields(const mxArray *ptr);
+    void *mxGetData(const mxArray *ptr);
+    void *mxGetImagData(const mxArray *ptr);
 
-    void clear_mex(int nlhs, mxArray ** plhs, int nrhs, mxArray ** prhs);
+    void clear_mex(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs);
 
     extern void errjump();
 
-    int mxGetM(const mxArray * ptr);
-    int C2F(mxgetm) (mxArray * ptr);
-    int mxGetN(const mxArray * ptr);
-    int C2F(mxgetn) (mxArray * ptr);
-    int mxGetString(const mxArray * ptr, char *str, int strl);
-    int C2F(mxgetstring) (mxArray * ptr, char *str, int *strl);
-    bool mxIsComplex(const mxArray * ptr);
-    int C2F(mxiscomplex) (mxArray * ptr);
+    int mxGetM(const mxArray *ptr);
+    int C2F(mxgetm)(mxArray *ptr);
+    int mxGetN(const mxArray *ptr);
+    int C2F(mxgetn)(mxArray *ptr);
+    int mxGetString(const mxArray *ptr, char *str, int strl);
+    int C2F(mxgetstring)(mxArray *ptr, char *str, int *strl);
+    bool mxIsComplex(const mxArray *ptr);
+    int C2F(mxiscomplex)(mxArray *ptr);
     /* mxisfull : NOT IN MATLAB API - v4 compatible */
-    bool mxIsFull(const mxArray * ptr);
-    int C2F(mxisfull) (mxArray * ptr);
-    bool mxIsNumeric(const mxArray * ptr);
-    int C2F(mxisnumeric) (mxArray * ptr);
-    bool mxIsSparse(const mxArray * ptr);
-    int C2F(mxissparse) (mxArray * ptr);
+    bool mxIsFull(const mxArray *ptr);
+    int C2F(mxisfull)(mxArray *ptr);
+    bool mxIsNumeric(const mxArray *ptr);
+    int C2F(mxisnumeric)(mxArray *ptr);
+    bool mxIsSparse(const mxArray *ptr);
+    int C2F(mxissparse)(mxArray *ptr);
     /* mxisstring : NOT IN MATLAB API - v6.0 compatible */
-    bool mxIsString(const mxArray * ptr);
-    int C2F(mxisstring) (mxArray * ptr);
-    int *mxGetIr(const mxArray * ptr);
-    int *mxGetJc(const mxArray * ptr);
-
-    int C2F(mexcallscilab) (int *nlhs, mxArray ** plhs, int *nrhs, mxArray ** prhs, char *name, int namelen);
-    int C2F(mxcopyptrtoreal8) (mxArray * ptr, double *y, int *n);
-    int C2F(mxcopyreal8toptr) (double *y, mxArray * ptr, int *n);
-    int mexAtExit(mxArray * ptr);
-    int mexCallSCILAB(int nlhs, mxArray ** plhs, int nrhs, mxArray ** prhs, const char *name);
-    int mexCallMATLAB(int nlhs, mxArray ** plhs, int nrhs, mxArray ** prhs, const char *name);
-    int mxGetElementSize(const mxArray * ptr);
-    int mxGetNzmax(const mxArray * ptr);
-    char *mxArrayToString(const mxArray * array_ptr);
-    bool mxIsDouble(const mxArray * ptr);
-    bool mxIsSingle(const mxArray * ptr);
-    bool mxIsLogical(const mxArray * ptr);
+    bool mxIsString(const mxArray *ptr);
+    int C2F(mxisstring)(mxArray *ptr);
+    int *mxGetIr(const mxArray *ptr);
+    int *mxGetJc(const mxArray *ptr);
+
+    int C2F(mexcallscilab)(int *nlhs, mxArray **plhs, int *nrhs, mxArray **prhs, char *name, int namelen);
+    int C2F(mxcopyptrtoreal8)(mxArray *ptr, double *y, int *n);
+    int C2F(mxcopyreal8toptr)(double *y, mxArray *ptr, int *n);
+    int mexAtExit(mxArray *ptr);
+    int mexCallSCILAB(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name);
+    int mexCallMATLAB(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name);
+    int mxGetElementSize(const mxArray *ptr);
+    int mxGetNzmax(const mxArray *ptr);
+    char *mxArrayToString(const mxArray *array_ptr);
+    bool mxIsDouble(const mxArray *ptr);
+    bool mxIsSingle(const mxArray *ptr);
+    bool mxIsLogical(const mxArray *ptr);
     mxArray *mxCreateLogicalScalar(mxLogical value);
     mxArray *mxCreateLogicalMatrix(int m, int n);
-    bool mxIsLogicalScalarTrue(mxArray * ptr);
-    bool mxIsLogicalScalar(const mxArray * ptr);
-    bool mexIsGlobal(const mxArray * ptr);
+    bool mxIsLogicalScalarTrue(const mxArray *ptr);
+    bool mxIsLogicalScalar(const mxArray *ptr);
+    bool mexIsGlobal(const mxArray *ptr);
     /* mxsetlogical: NOT IN MATLAB API - v6.5 compatible */
-    void mxSetLogical(mxArray * ptr);
+    void mxSetLogical(mxArray *ptr);
     /* mxclearlogical: NOT IN MATLAB API - v6.5 compatible */
-    void mxClearLogical(mxArray * ptr);
-    bool mxIsChar(const mxArray * ptr);
-    bool mxIsEmpty(const mxArray * ptr);
-    bool mxIsClass(const mxArray * ptr, const char *name);
-    bool mxIsCell(const mxArray * ptr);
-    bool mxIsStruct(const mxArray * ptr);
-
-    bool mxIsInt8(const mxArray * ptr);
-    bool mxIsInt16(const mxArray * ptr);
-    bool mxIsInt32(const mxArray * ptr);
-    bool mxIsInt64(const mxArray * ptr);
-    bool mxIsUint8(const mxArray * ptr);
-    bool mxIsUint16(const mxArray * ptr);
-    bool mxIsUint32(const mxArray * ptr);
-    bool mxIsUint64(const mxArray * ptr);
-
-    void mxSetM(mxArray * ptr, int m);
-    void mxSetN(mxArray * ptr, int n);
-    void mxSetJc(mxArray * array_ptr, int *jc_data);
-    void mxSetIr(mxArray * array_ptr, int *ir_data);
-    void mxSetNzmax(mxArray * array_ptr, int nzmax);
-    void mxSetCell(mxArray * pa, int i, mxArray * value);
+    void mxClearLogical(mxArray *ptr);
+    bool mxIsChar(const mxArray *ptr);
+    bool mxIsEmpty(const mxArray *ptr);
+    bool mxIsClass(const mxArray *ptr, const char *name);
+    bool mxIsCell(const mxArray *ptr);
+    bool mxIsStruct(const mxArray *ptr);
+    bool mxIsFunction(const mxArray *ptr);
+
+    bool mxIsInt8(const mxArray *ptr);
+    bool mxIsInt16(const mxArray *ptr);
+    bool mxIsInt32(const mxArray *ptr);
+    bool mxIsInt64(const mxArray *ptr);
+    bool mxIsUint8(const mxArray *ptr);
+    bool mxIsUint16(const mxArray *ptr);
+    bool mxIsUint32(const mxArray *ptr);
+    bool mxIsUint64(const mxArray *ptr);
+
+    void mxSetM(mxArray *ptr, int m);
+    void mxSetN(mxArray *ptr, int n);
+    void mxSetJc(mxArray *array_ptr, int *jc_data);
+    void mxSetIr(mxArray *array_ptr, int *ir_data);
+    void mxSetNzmax(mxArray *array_ptr, int nzmax);
+    void mxSetCell(mxArray *pa, int i, mxArray *value);
 
     /* mexGetArray: NOT IN MATLAB API - v6.5 compatible */
     mxArray *mexGetArray(char *name, char *workspace);
     mxArray *mexGetVariable(const char *workspace, const char *name);
     const mxArray *mexGetVariablePtr(const char *workspace, const char *name);
 
-    unsigned long int C2F(mxcalloc) (unsigned int *n, unsigned int *size);
+    unsigned long int C2F(mxcalloc)(unsigned int *n, unsigned int *size);
     void *mxCalloc(size_t n, size_t size);
     void *mxMalloc(size_t nsize);
     void mxFree(void *ptr);
-    void mxDestroyArray(mxArray * ptr);
+    void mxDestroyArray(mxArray *ptr);
 
     /* mxCalloc_m : NOT IN MATLAB API - SCILAB SPECIFIC ? */
     void *mxCalloc_m(unsigned int n, unsigned int size);
@@ -188,24 +190,24 @@ extern "C"
     /* mxFree_m : NOT IN MATLAB API - SCILAB SPECIFIC ? */
     void mxFree_m(void *);
     /* mxfreematrix: NOT IN MATLAB API - v6.0 compatible */
-    void mxFreeMatrix(mxArray * ptr);
-    void C2F(mxfreematrix) (mxArray * ptr);
+    void mxFreeMatrix(mxArray *ptr);
+    void C2F(mxfreematrix)(mxArray *ptr);
 
     void mexErrMsgTxt(const char *error_msg);
-    void C2F(mexerrmsgtxt) (char *error_msg, int len);
+    void C2F(mexerrmsgtxt)(char *error_msg, int len);
     int mexEvalString(const char *name);
     void mexWarnMsgTxt(const char *error_msg);
     /* mexprint: NOT IN MATLAB API - SCILAB SPECIFIC ? */
     void mexprint(char *fmt, ...);
 
-    int mxGetFieldNumber(const mxArray * ptr, const char *string);
-    mxArray *mxGetField(const mxArray * pa, int i, const char *fieldname);
-    void mxSetFieldByNumber(mxArray * array_ptr, int index, int field_number, mxArray * value);
-    void mxSetField(mxArray * pa, int i, const char *fieldname, mxArray * value);
+    int mxGetFieldNumber(const mxArray *ptr, const char *string);
+    mxArray *mxGetField(const mxArray *pa, int i, const char *fieldname);
+    void mxSetFieldByNumber(mxArray *array_ptr, int index, int field_number, mxArray *value);
+    void mxSetField(mxArray *pa, int i, const char *fieldname, mxArray *value);
 
-    mxArray *mxGetFieldByNumber(const mxArray * ptr, int index, int field_number);
-    const char *mxGetFieldNameByNumber(const mxArray * array_ptr, int field_number);
-    mxLogical *mxGetLogicals(const mxArray * ptr);
+    mxArray *mxGetFieldByNumber(const mxArray *ptr, int index, int field_number);
+    const char *mxGetFieldNameByNumber(const mxArray *array_ptr, int field_number);
+    mxLogical *mxGetLogicals(const mxArray *ptr);
 
     typedef enum
     {
@@ -230,23 +232,23 @@ extern "C"
     } mxClassID;
 
     typedef enum
-    { mxREAL, mxCOMPLEX } mxComplexity;
+    {mxREAL, mxCOMPLEX} mxComplexity;
 
-    mxClassID mxGetClassID(const mxArray * ptr);
+    mxClassID mxGetClassID(const mxArray *ptr);
     /* mxGetName: NOT IN MATLAB API - v6.4 compatible */
-    const char *mxGetName(const mxArray * array_ptr);
+    const char *mxGetName(const mxArray *array_ptr);
     /* mxSetName: NOT IN MATLAB API - v6.4 compatible */
-    void mxSetName(mxArray * pa, const char *s);
-    void mxSetPr(mxArray * array_ptr, double *pr);
-    void mxSetPi(mxArray * array_ptr, double *pi);
-    void mxSetData(mxArray * array_ptr, void *pr);
+    void mxSetName(mxArray *pa, const char *s);
+    void mxSetPr(mxArray *array_ptr, double *pr);
+    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, mxComplexity flag);
-    int mxSetDimensions(mxArray * array_ptr, const int *dims, int ndim);
+    int mxSetDimensions(mxArray *array_ptr, const int *dims, int ndim);
     mxArray *mxCreateDoubleMatrix(int m, int n, mxComplexity it);
     mxArray *mxCreateDoubleScalar(double value);
     mxArray *mxCreateSparse(int m, int n, int nzmax, mxComplexity cmplx);
-    mxArray *mxDuplicateArray(const mxArray * ptr);
+    mxArray *mxDuplicateArray(const mxArray *ptr);
 
     /* typedef uint16_T mxChar; */
 
@@ -278,6 +280,16 @@ extern "C"
 #ifdef __cplusplus
 extern "C"
 {
-    void mexFunction(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[]);
+    void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]);
 }
 #endif
+//define mxAssert in order to benefit user compilation flag ( debug or not )
+#define mxAssert(/* int */expr, /*char* */error_message) if (!expr){mexPrintf("Assertion Error: %s\n", error_message); assert(expr);}
+//void mxAssert(int expr, char *error_message);
+void mxAssertS(int expr, char *error_message);
+mxChar *mxGetChars(mxArray *array_ptr);
+const char *mxGetClassName(const mxArray *ptr);
+int mexPutVariable(const char *workspace, const char *varname, const mxArray *pm);
+void mxSetImagData(mxArray * array_ptr, void *data_ptr);
+int mxAddField(mxArray *pm, const char *fieldname);
+mxArray *mxCreateLogicalArray(mwSize ndim, const mwSize *dims);
index d3dfd2e..3a2e6ca 100644 (file)
 #include "yaspio.hxx"
 #include "context.hxx"
 #include "symbol.hxx"
+#include "parser.hxx"
+#include "configvariable.hxx"
+#include "overload.hxx"
+#include "execvisitor.hxx"
 
 #include "types.hxx"
 #include "int8.hxx"
@@ -85,9 +89,14 @@ extern "C"
 
 static char *the_current_mex_name;
 
-mxClassID mxGetClassID(const mxArray * ptr)
+mxClassID mxGetClassID(const mxArray *ptr)
 {
-    types::InternalType::RealType type = ((types::InternalType *) ptr)->getType();
+    types::InternalType *pIT = (types::InternalType *) ptr;
+    if (pIT == NULL)
+    {
+        return mxUNKNOWN_CLASS;
+    }
+    types::InternalType::RealType type = pIT->getType();
 
     switch (type)
     {
@@ -115,57 +124,68 @@ mxClassID mxGetClassID(const mxArray * ptr)
         return mxLOGICAL_CLASS;
     case types::InternalType::RealFloat:
         return mxSINGLE_CLASS;
+    case types::InternalType::RealStruct:
+        return mxSTRUCT_CLASS;
+    case types::InternalType::RealCell:
+        return mxCELL_CLASS;
+    case types::InternalType::RealFunction:
+        return mxFUNCTION_CLASS;
     default:
         return mxUNKNOWN_CLASS;
     }
 }
 
-bool mxIsInt8(const mxArray * ptr)
+bool mxIsInt8(const mxArray *ptr)
 {
     return mxGetClassID(ptr) == mxINT8_CLASS;
 }
 
-bool mxIsInt16(const mxArray * ptr)
+bool mxIsInt16(const mxArray *ptr)
 {
     return mxGetClassID(ptr) == mxINT16_CLASS;
 }
 
-bool mxIsInt32(const mxArray * ptr)
+bool mxIsInt32(const mxArray *ptr)
 {
     return mxGetClassID(ptr) == mxINT32_CLASS;
 }
 
-bool mxIsInt64(const mxArray * ptr)
+bool mxIsInt64(const mxArray *ptr)
 {
     return mxGetClassID(ptr) == mxINT64_CLASS;
 }
 
-bool mxIsUint8(const mxArray * ptr)
+bool mxIsUint8(const mxArray *ptr)
 {
     return mxGetClassID(ptr) == mxUINT8_CLASS;
 }
 
-bool mxIsUint16(const mxArray * ptr)
+bool mxIsUint16(const mxArray *ptr)
 {
     return mxGetClassID(ptr) == mxUINT16_CLASS;
 }
 
-bool mxIsUint32(const mxArray * ptr)
+bool mxIsUint32(const mxArray *ptr)
 {
     return mxGetClassID(ptr) == mxUINT32_CLASS;
 }
 
-bool mxIsUint64(const mxArray * ptr)
+bool mxIsUint64(const mxArray *ptr)
 {
     return mxGetClassID(ptr) == mxUINT64_CLASS;
 }
 
+bool mxIsFunction(const mxArray *ptr)
+{
+    return mxGetClassID(ptr) == mxFUNCTION_CLASS;
+}
+
 double mxGetEps(void)
 {
-    types::InternalType * pITEps = symbol::Context::getInstance()->get(symbol::Symbol(L"%eps"));
+    types::InternalType *pITEps = symbol::Context::getInstance()->get(symbol::Symbol(L"%eps"));
     if (pITEps && pITEps->isDouble())
     {
-        return pITEps->getAs < types::Double > ()->get(0);
+        return pITEps->getAs<types::Double>()->get(0);
     }
 
     return -1;
@@ -173,10 +193,10 @@ double mxGetEps(void)
 
 double mxGetInf(void)
 {
-    types::InternalType * pITInf = symbol::Context::getInstance()->get(symbol::Symbol(L"%inf"));
+    types::InternalType *pITInf = symbol::Context::getInstance()->get(symbol::Symbol(L"%inf"));
     if (pITInf && pITInf->isDouble())
     {
-        return pITInf->getAs < types::Double > ()->get(0);
+        return pITInf->getAs<types::Double>()->get(0);
     }
 
     return -1;
@@ -184,11 +204,13 @@ double mxGetInf(void)
 
 double mxGetNaN(void)
 {
-    double x, y;
+    types::InternalType *pITInf = symbol::Context::getInstance()->get(symbol::Symbol(L"%nan"));
+    if (pITInf)
+    {
+        return pITInf->getAs<types::Double>()->get(0);
+    }
 
-    x = mxGetInf();
-    y = x / x;
-    return y;
+    return -1;
 }
 
 bool mxIsInf(double x)
@@ -227,22 +249,15 @@ bool mxIsNaN(double x)
     }
 }
 
-mxArray *mxCreateData(int m)
-/* Utility fctn : create a no-header, unpopulated  *
- * mxArray of size=m*sizeof(double)                */
+int mxGetNumberOfElements(const mxArray *ptr)
 {
-    return mxCreateDoubleMatrix(1, m, mxREAL);
-}
-
-int mxGetNumberOfElements(const mxArray * ptr)
-{
-    types::InternalType * pIT = (types::InternalType *) ptr;
+    types::InternalType *pIT = (types::InternalType *) ptr;
     if (pIT == NULL)
     {
         return 0;
     }
 
-    types::GenericType * pGT = dynamic_cast < types::GenericType * >(pIT);
+    types::GenericType *pGT = dynamic_cast<types::GenericType *>(pIT);
     if (pGT == NULL)
     {
         return 0;
@@ -251,15 +266,15 @@ int mxGetNumberOfElements(const mxArray * ptr)
     return pGT->getSize();
 }
 
-double *mxGetPr(const mxArray * ptr)
+double *mxGetPr(const mxArray *ptr)
 {
-    types::InternalType * pIT = (types::InternalType *) ptr;
+    types::InternalType *pIT = (types::InternalType *) ptr;
     if (pIT == NULL)
     {
         return NULL;
     }
 
-    types::Double * pD = dynamic_cast < types::Double * >(pIT);
+    types::Double *pD = dynamic_cast<types::Double *>(pIT);
     if (pD == NULL)
     {
         return NULL;
@@ -268,20 +283,20 @@ double *mxGetPr(const mxArray * ptr)
     return pD->get();
 }
 
-double *mxGetPi(const mxArray * ptr)
+double *mxGetPi(const mxArray *ptr)
 {
     return ((types::Double *) ptr)->getImg();
 }
 
-int mxGetNumberOfDimensions(const mxArray * ptr)
+int mxGetNumberOfDimensions(const mxArray *ptr)
 {
-    types::InternalType * pIT = (types::InternalType *) ptr;
+    types::InternalType *pIT = (types::InternalType *) ptr;
     if (pIT == NULL)
     {
         return 0;
     }
 
-    types::GenericType * pGT = pIT->getAs < types::GenericType > ();
+    types::GenericType *pGT = pIT->getAs<types::GenericType>();
     if (pGT == NULL)
     {                           //InternalType but not GenericType, so mono dimension type.
         return 1;
@@ -290,9 +305,9 @@ int mxGetNumberOfDimensions(const mxArray * ptr)
     return pGT->getDims();
 }
 
-int *mxGetDimensions(const mxArray * ptr)
+int *mxGetDimensions(const mxArray *ptr)
 {
-    types::InternalType * pIT = (types::InternalType *) ptr;
+    types::InternalType *pIT = (types::InternalType *) ptr;
     if (pIT == NULL)
     {
         return NULL;
@@ -304,14 +319,14 @@ int *mxGetDimensions(const mxArray * ptr)
     case types::InternalType::RealMList:
     case types::InternalType::RealTList:
         {
-            int *piDims = (int *)MALLOC(sizeof(int));
+            int *piDims = (int *) MALLOC(sizeof(int));
 
-            piDims[0] = pIT->getAs < types::Container > ()->getSize();
+            piDims[0] = pIT->getAs<types::Container>()->getSize();
             return piDims;
         }
     default:
         {
-            types::GenericType * pGT = pIT->getAs < types::GenericType > ();
+            types::GenericType *pGT = pIT->getAs<types::GenericType>();
             if (pGT == NULL)
             {
                 return NULL;
@@ -322,15 +337,15 @@ int *mxGetDimensions(const mxArray * ptr)
     return NULL;
 }
 
-int mxGetM(const mxArray * ptr)
+int mxGetM(const mxArray *ptr)
 {
-    types::InternalType * pIT = (types::InternalType *) ptr;
+    types::InternalType *pIT = (types::InternalType *) ptr;
     if (pIT == NULL)
     {
         return NULL;
     }
 
-    types::GenericType * pGT = pIT->getAs < types::GenericType > ();
+    types::GenericType *pGT = pIT->getAs<types::GenericType>();
     if (pGT == NULL)
     {
         return NULL;
@@ -338,15 +353,15 @@ int mxGetM(const mxArray * ptr)
     return pGT->getRows();
 }
 
-void mxSetM(mxArray * ptr, int M)
+void mxSetM(mxArray *ptr, int M)
 {
-    types::InternalType * pIT = (types::InternalType *) ptr;
+    types::InternalType *pIT = (types::InternalType *) ptr;
     if (pIT == NULL)
     {
         return;
     }
 
-    types::GenericType * pGT = pIT->getAs < types::GenericType > ();
+    types::GenericType *pGT = pIT->getAs<types::GenericType>();
     if (pGT == NULL)
     {
         return;
@@ -355,34 +370,34 @@ void mxSetM(mxArray * ptr, int M)
     pGT->resize(M, pGT->getCols());
 }
 
-int *mxGetJc(const mxArray * ptr)
+int *mxGetJc(const mxArray *ptr)
 {
     // TODO: sparse
     return NULL;
 }
 
-int *mxGetIr(const mxArray * ptr)
+int *mxGetIr(const mxArray *ptr)
 {
     // TODO: sparse
     return NULL;
 }
 
-void mxSetJc(mxArray * array_ptr, int *jc_data)
+void mxSetJc(mxArray *array_ptr, int *jc_data)
 {
     // TODO: sparse
 }
 
-void mxSetIr(mxArray * array_ptr, int *ir_data)
+void mxSetIr(mxArray *array_ptr, int *ir_data)
 {
     // TODO: sparse
 }
 
-void mxSetNzmax(mxArray * array_ptr, int nzmax)
+void mxSetNzmax(mxArray *array_ptr, int nzmax)
 {
     // TODO: sparse
 }
 
-int mxGetN(const mxArray * ptr)
+int mxGetN(const mxArray *ptr)
 {
     types::InternalType * pIT = (types::InternalType *) ptr;
     if (pIT == NULL)
@@ -390,7 +405,7 @@ int mxGetN(const mxArray * ptr)
         return NULL;
     }
 
-    types::GenericType * pGT = pIT->getAs < types::GenericType > ();
+    types::GenericType * pGT = pIT->getAs<types::GenericType>();
     if (pGT == NULL)
     {
         return NULL;
@@ -398,7 +413,7 @@ int mxGetN(const mxArray * ptr)
     return pGT->getCols();
 }
 
-void mxSetN(mxArray * ptr, int N)
+void mxSetN(mxArray *ptr, int N)
 {
     types::InternalType * pIT = (types::InternalType *) ptr;
     if (pIT == NULL)
@@ -406,7 +421,7 @@ void mxSetN(mxArray * ptr, int N)
         return;
     }
 
-    types::GenericType * pGT = pIT->getAs < types::GenericType > ();
+    types::GenericType * pGT = pIT->getAs<types::GenericType>();
     if (pGT == NULL)
     {
         return;
@@ -415,35 +430,35 @@ void mxSetN(mxArray * ptr, int N)
     pGT->resize(pGT->getRows(), N);
 }
 
-bool mxIsString(const mxArray * ptr)
+bool mxIsString(const mxArray *ptr)
 {
     /* mxIsString is obsolete. */
     return mxIsChar(ptr);
 }
 
-bool mxIsChar(const mxArray * ptr)
+bool mxIsChar(const mxArray *ptr)
 {
     return mxGetClassID(ptr) == mxCHAR_CLASS;
 }
 
-bool mxIsNumeric(const mxArray * ptr)
+bool mxIsNumeric(const mxArray *ptr)
 {
     return mxIsDouble(ptr) || mxIsSingle(ptr) ||
         mxIsInt8(ptr) || mxIsUint8(ptr) ||
         mxIsInt16(ptr) || mxIsUint16(ptr) || mxIsInt32(ptr) || mxIsUint32(ptr) || mxIsInt64(ptr) || mxIsUint64(ptr);
 }
 
-bool mxIsDouble(const mxArray * ptr)
+bool mxIsDouble(const mxArray *ptr)
 {
     return mxGetClassID(ptr) == mxDOUBLE_CLASS;
 }
 
-bool mxIsSingle(const mxArray * ptr)
+bool mxIsSingle(const mxArray *ptr)
 {
     return mxGetClassID(ptr) == mxSINGLE_CLASS;
 }
 
-bool mxIsEmpty(const mxArray * ptr)
+bool mxIsEmpty(const mxArray *ptr)
 {
     types::InternalType * pIT = (types::InternalType *) ptr;
     if (pIT == NULL)
@@ -453,96 +468,85 @@ bool mxIsEmpty(const mxArray * ptr)
 
     switch (pIT->getType())
     {
-    case types::InternalType::RealDouble:
+        case types::InternalType::RealDouble:
         {
-            types::Double * pD = pIT->getAs < types::Double > ();
-            return pD->getSize() == 0;
+            types::Double *pD = pIT->getAs<types::Double>();
+           return pD->getSize() == 0;
         }
-    case types::InternalType::RealCell:
+        case types::InternalType::RealCell:
         {
-            types::Cell * pC = pIT->getAs < types::Cell > ();
-            return pC->getSize() == 0;
+            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:
+        case types::InternalType::RealContainer:
+        case types::InternalType::RealList:
+        case types::InternalType::RealMList:
+        case types::InternalType::RealTList:
         {
-            types::Container * pC = pIT->getAs < types::Container > ();
+            types::Container *pC = pIT->getAs<types::Container>();
             return pC->getSize() == 0;
         }
-    default:
+        default:
         {                       //other type can not be empty
             return false;
         }
     }
 }
 
-bool mxIsFull(const mxArray * ptr)
+bool mxIsFull(const mxArray *ptr)
 {
     /* mxIsFull is obsolete. */
     return !mxIsSparse(ptr);
 }
 
-bool mxIsSparse(const mxArray * ptr)
+bool mxIsSparse(const mxArray *ptr)
 {
     // TODO: sparse
     return false;
 }
 
-bool mxIsLogical(const mxArray * ptr)
-{
-    // TODO: review
-    types::InternalType * pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
-    {
-        return false;
-    }
-
-    return pIT->isBool();
-    //return mxGetClassID(ptr)==mxLOGICAL_CLASS;
-}
-
-bool mxIsLogicalScalar(const mxArray * ptr)
+bool mxIsLogical(const mxArray *ptr)
 {
-    return mxIsLogical(ptr) && mxGetNumberOfElements(ptr) == 1;
+    return mxGetClassID(ptr)==mxLOGICAL_CLASS;
 }
 
-void mxSetLogical(mxArray * ptr)
+void mxSetLogical(mxArray *ptr)
 {
     /* obsolete */
     if (!mxIsNumeric(ptr))
     {
         return;
     }
-    int *pr = (int *)mxGetPr(ptr);
-    ptr = (mxArray *) new types::Bool(mxGetNumberOfDimensions(ptr), mxGetDimensions(ptr));
-
-    ((types::Bool *) ptr)->set(pr);
+    int *data = (int *) mxGetData(ptr);
+    mxArray *newPtr = (mxArray *) new types::Bool(mxGetNumberOfDimensions(ptr), mxGetDimensions(ptr));
+    // TODO: destroy ptr?
+    mxSetData(newPtr, data);
+    *ptr = *newPtr;
 }
 
-void mxClearLogical(mxArray * ptr)
+void mxClearLogical(mxArray *ptr)
 {
     /* obsolete */
     if (!mxIsLogical(ptr))
     {
         return;
     }
-    int *pr = (int *)mxGetPr(ptr);
-    ptr = (mxArray *) new types::Double(mxGetNumberOfDimensions(ptr), mxGetDimensions(ptr));
-
-    ((types::Bool *) ptr)->set(pr);
+    int *data = (int *) mxGetData(ptr);
+    mxArray *newPtr = (mxArray *) new types::Int32(mxGetNumberOfDimensions(ptr), mxGetDimensions(ptr));
+    // TODO: destroy ptr?
+    mxSetData(newPtr, data);
+    *ptr = *newPtr;
 }
 
-bool mxIsComplex(const mxArray * ptr)
+bool mxIsComplex(const mxArray *ptr)
 {
-    types::InternalType * pIT = (types::InternalType *) ptr;
+    types::InternalType *pIT = (types::InternalType *) ptr;
     if (pIT == NULL)
     {
         return false;
     }
 
-    types::GenericType * pGT = pIT->getAs < types::GenericType > ();
+    types::GenericType *pGT = pIT->getAs<types::GenericType>();
     if (pGT == NULL)
     {
         return false;
@@ -551,10 +555,10 @@ bool mxIsComplex(const mxArray * ptr)
     return pGT->isComplex();
 }
 
-double mxGetScalar(const mxArray * ptr)
+double mxGetScalar(const mxArray *ptr)
 {
     // TODO: review spec
-    types::InternalType * pIT = (types::InternalType *) ptr;
+    types::InternalType *pIT = (types::InternalType *) ptr;
     if (pIT == NULL)
     {
         return 0;
@@ -562,69 +566,189 @@ double mxGetScalar(const mxArray * ptr)
 
     switch (pIT->getType())
     {
-    case types::InternalType::RealDouble:
+        case types::InternalType::RealDouble:
         {
-            types::Double * pD = pIT->getAs < types::Double > ();
+            types::Double *pD = pIT->getAs<types::Double>();
             return pD->get(0);
         }
-    case types::InternalType::RealBool:
+        case types::InternalType::RealBool:
         {
-            types::Bool * pB = pIT->getAs < types::Bool > ();
-            return (double)pB->get(0);
+            types::Bool *pB = pIT->getAs<types::Bool>();
+            return (double) pB->get(0);
         }
-    case types::InternalType::RealInt8:
+        case types::InternalType::RealInt8:
         {
-            types::Int8 * pI = pIT->getAs < types::Int8 > ();
-            return (double)pI->get(0);
+            types::Int8 *pI = pIT->getAs<types::Int8>();
+            return (double) pI->get(0);
         }
-    case types::InternalType::RealUInt8:
+        case types::InternalType::RealUInt8:
         {
-            types::UInt8 * pI = pIT->getAs < types::UInt8 > ();
-            return (double)pI->get(0);
+            types::UInt8 *pI = pIT->getAs<types::UInt8>();
+            return (double) pI->get(0);
         }
-    case types::InternalType::RealInt16:
+        case types::InternalType::RealInt16:
         {
-            types::Int16 * pI = pIT->getAs < types::Int16 > ();
-            return (double)pI->get(0);
+            types::Int16 *pI = pIT->getAs<types::Int16>();
+            return (double) pI->get(0);
         }
-    case types::InternalType::RealUInt16:
+        case types::InternalType::RealUInt16:
         {
-            types::UInt16 * pI = pIT->getAs < types::UInt16 > ();
-            return (double)pI->get(0);
+            types::UInt16 *pI = pIT->getAs<types::UInt16>();
+            return (double) pI->get(0);
         }
-    case types::InternalType::RealInt32:
+        case types::InternalType::RealInt32:
         {
-            types::Int32 * pI = pIT->getAs < types::Int32 > ();
-            return (double)pI->get(0);
+            types::Int32 *pI = pIT->getAs<types::Int32>();
+            return (double) pI->get(0);
         }
-    case types::InternalType::RealUInt32:
+        case types::InternalType::RealUInt32:
         {
-            types::UInt32 * pI = pIT->getAs < types::UInt32 > ();
-            return (double)pI->get(0);
+            types::UInt32 *pI = pIT->getAs<types::UInt32>();
+            return (double) pI->get(0);
         }
-    case types::InternalType::RealInt64:
+        case types::InternalType::RealInt64:
         {
-            types::Int64 * pI = pIT->getAs < types::Int64 > ();
-            return (double)pI->get(0);
+            types::Int64 *pI = pIT->getAs<types::Int64>();
+            return (double) pI->get(0);
         }
-    case types::InternalType::RealUInt64:
+        case types::InternalType::RealUInt64:
         {
-            types::UInt64 * pI = pIT->getAs < types::UInt64 > ();
-            return (double)pI->get(0);
+            types::UInt64 *pI = pIT->getAs<types::UInt64>();
+            return (double) pI->get(0);
         }
-    default:
-        return 0;
+        default:
+            return 0;
     }
 }
 
-void *mxGetData(const mxArray * ptr)
+void *mxGetData(const mxArray *ptr)
 {
-    return mxGetPr(ptr);
+    types::InternalType *pIT = (types::InternalType *) ptr;
+    if (pIT == NULL)
+    {
+        return NULL;
+    }
+
+    switch (pIT->getType())
+    {
+        case types::InternalType::RealDouble:
+        {
+            types::Double *pD = pIT->getAs<types::Double>();
+            return pD->get();
+        }
+        case types::InternalType::RealBool:
+        {
+            types::Bool *pB = pIT->getAs<types::Bool>();
+            return pB->get();
+        }
+        case types::InternalType::RealInt8:
+        {
+            types::Int8 *pI = pIT->getAs<types::Int8>();
+            return pI->get();
+        }
+        case types::InternalType::RealUInt8:
+        {
+            types::UInt8 *pI = pIT->getAs<types::UInt8>();
+            return pI->get();
+        }
+        case types::InternalType::RealInt16:
+        {
+            types::Int16 *pI = pIT->getAs<types::Int16>();
+            return pI->get();
+        }
+        case types::InternalType::RealUInt16:
+        {
+            types::UInt16 *pI = pIT->getAs<types::UInt16>();
+            return pI->get();
+        }
+        case types::InternalType::RealInt32:
+        {
+            types::Int32 *pI = pIT->getAs<types::Int32>();
+            return pI->get();
+        }
+        case types::InternalType::RealUInt32:
+        {
+            types::UInt32 *pI = pIT->getAs<types::UInt32>();
+            return pI->get();
+        }
+        case types::InternalType::RealInt64:
+        {
+            types::Int64 *pI = pIT->getAs<types::Int64>();
+            return pI->get();
+        }
+        case types::InternalType::RealUInt64:
+        {
+            types::UInt64 *pI = pIT->getAs<types::UInt64>();
+            return pI->get();
+        }
+        default:
+            return NULL;
+    }
 }
 
-void *mxGetImagData(const mxArray * ptr)
+void *mxGetImagData(const mxArray *ptr)
 {
-    return mxGetPi(ptr);
+    types::InternalType *pIT = (types::InternalType *) ptr;
+    if (pIT == NULL)
+    {
+        return NULL;
+    }
+
+    switch (pIT->getType())
+    {
+        case types::InternalType::RealDouble:
+        {
+            types::Double *pD = pIT->getAs<types::Double>();
+            return pD->getImg();
+        }
+        case types::InternalType::RealBool:
+        {
+            types::Bool *pB = pIT->getAs<types::Bool>();
+            return pB->getImg();
+        }
+        case types::InternalType::RealInt8:
+        {
+            types::Int8 *pI = pIT->getAs<types::Int8>();
+            return pI->getImg();
+        }
+        case types::InternalType::RealUInt8:
+        {
+            types::UInt8 *pI = pIT->getAs<types::UInt8>();
+            return pI->getImg();
+        }
+        case types::InternalType::RealInt16:
+        {
+            types::Int16 *pI = pIT->getAs<types::Int16>();
+            return pI->getImg();
+        }
+        case types::InternalType::RealUInt16:
+        {
+            types::UInt16 *pI = pIT->getAs<types::UInt16>();
+            return pI->getImg();
+        }
+        case types::InternalType::RealInt32:
+        {
+            types::Int32 *pI = pIT->getAs<types::Int32>();
+            return pI->getImg();
+        }
+        case types::InternalType::RealUInt32:
+        {
+            types::UInt32 *pI = pIT->getAs<types::UInt32>();
+            return pI->getImg();
+        }
+        case types::InternalType::RealInt64:
+        {
+            types::Int64 *pI = pIT->getAs<types::Int64>();
+            return pI->getImg();
+        }
+        case types::InternalType::RealUInt64:
+        {
+            types::UInt64 *pI = pIT->getAs<types::UInt64>();
+            return pI->getImg();
+        }
+        default:
+            return NULL;
+    }
 }
 
 void mexErrMsgTxt(const char *error_msg)
@@ -632,17 +756,24 @@ void mexErrMsgTxt(const char *error_msg)
     throw new ast::ScilabException(error_msg);
 }
 
-void mxAssert(int expr, char *error_message)
+//view mexlib.h
+//void mxAssert(int expr, char *error_message)
+//{
+//    if (!expr)
+//    {
+//        mexPrintf("Assertion Error: %s\n", error_message);
+//        assert(expr);
+//    }
+//}
+
+void mxAssertS(int expr, char *error_message)
 {
-    if (!expr)
-    {
-        mexErrMsgTxt(error_message);
-    }
+    assert(expr);
 }
 
 mxArray *mxCreateDoubleMatrix(int m, int n, mxComplexity complexFlag)
 {
-    types::Double * ptr = new types::Double(m, n, complexFlag == mxCOMPLEX);
+    types::Double *ptr = new types::Double(m, n, complexFlag == mxCOMPLEX);
     return (mxArray *) ptr;
 }
 
@@ -654,163 +785,178 @@ mxArray *mxCreateDoubleScalar(double value)
     return ptr;
 }
 
-bool mxIsClass(const mxArray * ptr, const char *name)
+bool mxIsClass(const mxArray *ptr, const char *name)
 {
-    mxClassID classID = mxGetClassID(ptr);
-
     if (strcmp(name, "cell") == 0)
     {
-        return classID == mxCELL_CLASS;
+        return mxIsCell(ptr);
     }
     if (strcmp(name, "char") == 0)
     {
-        return classID == mxCHAR_CLASS;
+        return mxIsChar(ptr);
     }
     if (strcmp(name, "double") == 0)
     {
-        return classID == mxDOUBLE_CLASS;
+        return mxIsDouble(ptr);
     }
     if (strcmp(name, "function_handle") == 0)
     {
-        return classID == mxFUNCTION_CLASS;
+        return mxIsFunction(ptr);
     }
     if (strcmp(name, "int8") == 0)
     {
-        return classID == mxINT8_CLASS;
+        return mxIsInt8(ptr);
     }
     if (strcmp(name, "int16") == 0)
     {
-        return classID == mxINT16_CLASS;
+        return mxIsInt16(ptr);
     }
     if (strcmp(name, "int32") == 0)
     {
-        return classID == mxINT32_CLASS;
+        return mxIsInt32(ptr);
     }
     if (strcmp(name, "int64") == 0)
     {
-        return classID == mxINT64_CLASS;
+        return mxIsInt64(ptr);
     }
     if (strcmp(name, "logical") == 0)
     {
-        return classID == mxLOGICAL_CLASS;
+        return mxIsLogical(ptr);
     }
     if (strcmp(name, "single") == 0)
     {
-        return classID == mxSINGLE_CLASS;
+        return mxIsSingle(ptr);
     }
     if (strcmp(name, "struct") == 0)
     {
-        return classID == mxSTRUCT_CLASS;
+        return mxIsStruct(ptr);
     }
     if (strcmp(name, "uint8") == 0)
     {
-        return classID == mxUINT8_CLASS;
+        return mxIsUint8(ptr);
     }
     if (strcmp(name, "uint16") == 0)
     {
-        return classID == mxUINT16_CLASS;
+        return mxIsUint16(ptr);
     }
     if (strcmp(name, "uint32") == 0)
     {
-        return classID == mxUINT32_CLASS;
+        return mxIsUint32(ptr);
     }
     if (strcmp(name, "uint64") == 0)
     {
-        return classID == mxUINT64_CLASS;
+        return mxIsUint64(ptr);
     }
     // TODO: how to handle <class_name> and <class_id>?
-    if (strcmp(name, "unknown") == 0)
-    {
-        return classID == mxUNKNOWN_CLASS;
-    }
     return false;
 }
 
 mxArray *mxCreateStructArray(int ndim, const int *dims, int nfields, const char **field_names)
 {
-    types::Struct * ptr = new types::Struct(ndim, (int *)dims);
+    types::Struct *ptr = new types::Struct(ndim, (int *) dims);
     for (int i = 0; i < nfields; i++)
     {
-        // TODO: is this cast right?
-        ptr->addField((wchar_t *) field_names[i]);
+        wchar_t *name = to_wide_string(field_names[i]);
+        ptr->addField(name);
+        FREE(name);
     }
     return (mxArray *) ptr;
 }
 
 mxArray *mxCreateStructMatrix(int m, int n, int nfields, const char **field_names)
 {
-    int dims[2] = { m, n };
+    int dims[2] = {m, n};
     return mxCreateStructArray(2, dims, nfields, field_names);
 }
 
-void mxSetFieldByNumber(mxArray * array_ptr, int lindex, int field_number, mxArray * value)
+void mxSetFieldByNumber(mxArray *array_ptr, int lindex, int field_number, mxArray *value)
 {
-    if (mxIsStruct(array_ptr))
+    if (mxIsStruct(array_ptr) && lindex < mxGetNumberOfElements(array_ptr))
     {
-        types::SingleStruct * ptr = ((types::Struct *) array_ptr)->get(lindex);
-        types::String * names = ptr->getFieldNames();
+        types::SingleStruct *ptr = ((types::Struct *) array_ptr)->get(lindex);
+        types::String *names = ptr->getFieldNames();
         ptr->set(names->get(field_number), (types::InternalType *) value);
     }
 }
 
-void mxSetField(mxArray * array_ptr, int lindex, const char *field_name, mxArray * value)
+void mxSetField(mxArray *array_ptr, int lindex, const char *field_name, mxArray *value)
 {
-    int field_num;
+    int field_num = mxGetFieldNumber(array_ptr, field_name);
+    if (field_num >= 0)
+    {
+        mxSetFieldByNumber(array_ptr, lindex, field_num, value);
+    }
+}
 
-    field_num = mxGetFieldNumber(array_ptr, field_name);
-    mxSetFieldByNumber(array_ptr, lindex, field_num, value);
+const char *mxGetFieldNameByNumber(const mxArray *array_ptr, int field_number)
+{
+    if (!mxIsStruct(array_ptr))
+    {
+        return NULL;
+    }
+    if (field_number < 0 || field_number >= mxGetNumberOfFields(array_ptr))
+    {
+        return NULL;
+    }
+    types::String *names = ((types::Struct *) array_ptr)->getFieldNames();
+    wchar_t *name = names->get(field_number);
+    return (const char *) wide_string_to_UTF8(name);
 }
 
-const char *mxGetFieldNameByNumber(const mxArray * array_ptr, int field_number)
+int mxAddField(mxArray *ptr, const char *fieldname)
 {
-    types::String * names = ((types::Struct *) array_ptr)->getFieldNames();
-    // TODO: is this cast right?
-    return (const char *)names->get(field_number);
+    if (!mxIsStruct(ptr))
+    {
+        return -1;
+    }
+    types::Struct *pa = (types::Struct *) ptr;
+    wchar_t *wfieldname = to_wide_string(fieldname);
+    pa->addField(wfieldname);
+    return mxGetFieldNumber(ptr, fieldname);
 }
 
-mxChar *mxGetChars(mxArray * array_ptr)
+mxChar *mxGetChars(mxArray *array_ptr)
 {
     if (!mxIsChar(array_ptr))
     {
         return NULL;
     }
     wchar_t *chars = ((types::String *) array_ptr)->get(0);
-
-    return (mxChar *) chars;
+    return (mxChar *) wide_string_to_UTF8(chars);
 }
 
 mxArray *mxCreateNumericArray(int ndim, const int *dims, mxClassID CLASS, mxComplexity complexFlag)
 {
-    types::GenericType * ptr;
+    types::GenericType *ptr;
 
     switch (CLASS)
     {
     case mxDOUBLE_CLASS:
-        ptr = new types::Double(ndim, (int *)dims, complexFlag == mxCOMPLEX);
+        ptr = new types::Double(ndim, (int *) dims, complexFlag == mxCOMPLEX);
         break;
     case mxINT8_CLASS:
-        ptr = new types::Int8(ndim, (int *)dims);
+        ptr = new types::Int8(ndim, (int *) dims);
         break;
     case mxUINT8_CLASS:
-        ptr = new types::UInt8(ndim, (int *)dims);
+        ptr = new types::UInt8(ndim, (int *) dims);
         break;
     case mxINT16_CLASS:
-        ptr = new types::Int16(ndim, (int *)dims);
+        ptr = new types::Int16(ndim, (int *) dims);
         break;
     case mxUINT16_CLASS:
-        ptr = new types::UInt16(ndim, (int *)dims);
+        ptr = new types::UInt16(ndim, (int *) dims);
         break;
     case mxINT32_CLASS:
-        ptr = new types::Int32(ndim, (int *)dims);
+        ptr = new types::Int32(ndim, (int *) dims);
         break;
     case mxUINT32_CLASS:
-        ptr = new types::UInt32(ndim, (int *)dims);
+        ptr = new types::UInt32(ndim, (int *) dims);
         break;
     case mxINT64_CLASS:
-        ptr = new types::Int64(ndim, (int *)dims);
+        ptr = new types::Int64(ndim, (int *) dims);
         break;
     case mxUINT64_CLASS:
-        ptr = new types::UInt64(ndim, (int *)dims);
+        ptr = new types::UInt64(ndim, (int *) dims);
         break;
     default:
         ptr = NULL;
@@ -820,7 +966,7 @@ mxArray *mxCreateNumericArray(int ndim, const int *dims, mxClassID CLASS, mxComp
 
 mxArray *mxCreateNumericMatrix(int m, int n, mxClassID CLASS, mxComplexity complexFlag)
 {
-    int dims[2] = { m, n };
+    int dims[2] = {m, n};
     return mxCreateNumericArray(2, dims, CLASS, complexFlag);
 }
 
@@ -830,61 +976,86 @@ mxArray *mxCreateCharArray(int ndim, const int *dims)
     {
         ndim = 2;
     }
-    types::String * ptr = new types::String(ndim, (int *)dims);
+    types::String *ptr = new types::String(ndim, (int *) dims);
     return (mxArray *) ptr;
 }
 
 mxArray *mxCreateCellArray(int ndim, const int *dims)
 {
-    types::Cell * ptr = new types::Cell(ndim, (int *)dims);
+    types::Cell *ptr = new types::Cell(ndim, (int *) dims);
     return (mxArray *) ptr;
 }
 
 mxArray *mxCreateCellMatrix(int m, int n)
 {
-    int dims[2] = { m, n };
+    int dims[2] = {m, n};
     return mxCreateCellArray(2, dims);
 }
 
-mxArray *mxGetCell(const mxArray * ptr, int lindex)
+mxArray *mxGetCell(const mxArray *ptr, int lindex)
 {
     types::Cell * pa = (types::Cell *) ptr;
     return (mxArray *) pa->get(lindex);
 }
 
-int mxGetFieldNumber(const mxArray * ptr, const char *string)
+int mxGetFieldNumber(const mxArray *ptr, const char *string)
 {
-    // TODO: review
-    types::String * names = ((types::Struct *) ptr)->getFieldNames();
+    if (!mxIsStruct(ptr))
+    {
+        return -1;
+    }
+    types::Struct *pa = (types::Struct *) ptr;
+    types::String *names = pa->getFieldNames();
+    wchar_t *field_name = to_wide_string(string);
+
     for (int i = 0; i < names->getSize(); i++)
     {
-        if (strcmp((char *)names->get(i), string) == 0)
+        if (wcscmp(names->get(i), field_name) == 0)
         {
+            FREE(field_name);
             return i;
         }
     }
+    FREE(field_name);
     return -1;
 }
 
-mxArray *mxGetField(const mxArray * ptr, int lindex, const char *string)
+mxArray *mxGetField(const mxArray *ptr, int lindex, const char *string)
 {
-    // TODO: review
-    types::Struct * pa = (types::Struct *) ptr;
-    types::SingleStruct * s = pa->get(lindex);
-    return (mxArray *) s->get((wchar_t *) string);
+    int field_num = mxGetFieldNumber(ptr, string);
+    if (field_num < 0)
+    {
+        return NULL;
+    }
+    return mxGetFieldByNumber(ptr, lindex, field_num);
 }
 
-mxArray *mxGetFieldByNumber(const mxArray * ptr, int lindex, int field_number)
+mxArray *mxGetFieldByNumber(const mxArray *ptr, int lindex, int field_number)
 {
-    // TODO: review
-    types::Struct * pa = (types::Struct *) ptr;
-    types::String * names = pa->getFieldNames();
-    types::SingleStruct * s = pa->get(lindex);
+    if (!mxIsStruct(ptr))
+    {
+        return NULL;
+    }
+    if (lindex >= mxGetNumberOfElements(ptr) || lindex < 0)
+    {
+        return NULL;
+    }
+    if (field_number >= mxGetNumberOfFields(ptr) || field_number < 0)
+    {
+        return NULL;
+    }
+    types::Struct *pa = (types::Struct *) ptr;
+    types::String *names = pa->getFieldNames();
+    types::SingleStruct *s = pa->get(lindex);
     return (mxArray *) s->get(names->get(field_number));
 }
 
-int mxGetNumberOfFields(const mxArray * ptr)
+int mxGetNumberOfFields(const mxArray *ptr)
 {
+    if (!mxIsStruct(ptr))
+    {
+        return 0;
+    }
     types::Struct * pa = (types::Struct *) ptr;
     return pa->getFieldNames()->getSize();
 }
@@ -949,86 +1120,59 @@ static void mxFree_m_all()
     // FIXME
 }
 
-bool mxIsCell(const mxArray * ptr)
+bool mxIsCell(const mxArray *ptr)
 {
     return mxGetClassID(ptr) == mxCELL_CLASS;
 }
 
-bool mxIsStruct(const mxArray * ptr)
+bool mxIsStruct(const mxArray *ptr)
 {
     return mxGetClassID(ptr) == mxSTRUCT_CLASS;
 }
 
-/***************************************************************
-* 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 mxGetString(const mxArray *ptr, char *str, int strl)
 {
     if (!mxIsChar(ptr))
     {
         return 1;
     }
-    types::String * pa = (types::String *) ptr;
-    int length = Min(strl - 1, pa->getSize());
-
-    memcpy(str, pa->get(), length);
-    str[length] = '\0';
-    return (length != pa->getSize())? 1 : 0;
+    types::String *pa = (types::String *) ptr;
+    wchar_t *to_copy = *pa->get();
+    char *dest = wide_string_to_UTF8(to_copy);
+    memcpy(str, dest, strl-1);
+    str[strl-1] = '\0';
+    FREE(dest);
+    return (strl <= wcslen(to_copy) + 1) ? 1 : 0;
 }
 
-char *mxArrayToString(const mxArray * array_ptr)
+char *mxArrayToString(const mxArray *array_ptr)
 {
-    // TODO: review
-    if (mxIsChar(array_ptr))
+    if (!mxIsChar(array_ptr))
     {
-        types::String * pa = (types::String *) array_ptr;
-        int buflen = pa->getSize() + 1;
-        char *buf = (char *)mxCalloc(buflen, sizeof(char));
-
-        if (mxGetString(array_ptr, buf, buflen) == 0)
-        {
-            return buf;
-        }
+        return (char *) 0;
     }
-    return (char *)0;
+    types::String *pa = (types::String *) array_ptr;
+    wchar_t *to_copy = *pa->get();
+    return wide_string_to_UTF8(to_copy);
 }
 
-/*-------------------------------------------------
-* 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)
+void mxFreeMatrix(mxArray *ptr)
 {
     mxDestroyArray(ptr);
 }
 
-bool mexIsGlobal(const mxArray * ptr)
+bool mexIsGlobal(const mxArray *ptr)
 {
-    // TODO: really need iterate in symbols?
-    symbol::Context * context = symbol::Context::getInstance();
+    // TODO: really need iterate all symbols?
+    symbol::Context *context = symbol::Context::getInstance();
     int size = symbol::Symbol::map_size();
     wchar_t **keys = symbol::Symbol::get_all();
 
     for (int i = 0; i < size; i++)
     {
-        symbol::Symbol * s = new symbol::Symbol(keys[i]);
-        types::InternalType * value = context->get(*s);
-        if (value == (types::InternalType *) ptr)
+        symbol::Symbol *s = new symbol::Symbol(keys[i]);
+        const mxArray *value = (const mxArray *) context->get(*s);
+        if (value == ptr)
         {
             return context->isGlobalVisible(*s);
         }
@@ -1036,7 +1180,7 @@ bool mexIsGlobal(const mxArray * ptr)
     return false;
 }
 
-mxArray *mxDuplicateArray(const mxArray * ptr)
+mxArray *mxDuplicateArray(const mxArray *ptr)
 {
     types::InternalType * pIT = (types::InternalType *) ptr;
     if (pIT == NULL)
@@ -1047,13 +1191,7 @@ mxArray *mxDuplicateArray(const mxArray * ptr)
     return (mxArray *) pIT->clone();
 }
 
-mxArray *UnrefStruct(mxArray * ptr)
-{
-    // FIXME
-    return NULL;
-}
-
-void mxDestroyArray(mxArray * ptr)
+void mxDestroyArray(mxArray *ptr)
 {
     if (mxIsDouble(ptr))
     {
@@ -1114,7 +1252,7 @@ void mxFree(void *ptr)
     // FIXME
 }
 
-int mexAtExit(mxArray * ptr)
+int mexAtExit(mxArray *ptr)
 {
     // FIXME
     return 0;
@@ -1126,19 +1264,22 @@ mxArray *mxCreateSparse(int m, int n, int nzmax, mxComplexity cmplx)
     return NULL;
 }
 
-/***************************************************************
-* Create on Scilab Stack a 1x1 string matrix filled with string
-**************************************************************/
-
 mxArray *mxCreateString(const char *string)
 {
     types::String * ptr = new types::String(string);
     return (mxArray *) ptr;
 }
 
+
+mxArray *mxCreateLogicalArray(int ndim, const int *dims)
+{
+    types::Bool *ptr = new types::Bool(ndim, (int *) dims);
+    return (mxArray *) ptr;
+}
+
 mxArray *mxCreateLogicalMatrix(int m, int n)
 {
-    types::Bool * ptr = new types::Bool(m, n);
+    types::Bool *ptr = new types::Bool(m, n);
     return (mxArray *) ptr;
 }
 
@@ -1150,7 +1291,7 @@ mxArray *mxCreateLogicalScalar(mxLogical value)
     return ptr;
 }
 
-bool mxIsLogicalScalarTrue(mxArray * ptr)
+bool mxIsLogicalScalarTrue(const mxArray *ptr)
 {
     if (mxIsLogicalScalar(ptr) == false)
     {
@@ -1165,25 +1306,21 @@ bool mxIsLogicalScalarTrue(mxArray * ptr)
     return true;
 }
 
-bool mxIsLogicalScalar(mxArray * ptr)
+bool mxIsLogicalScalar(const mxArray *ptr)
 {
     return mxIsLogical(ptr) && mxGetNumberOfElements(ptr) == 1;
 }
 
-/*
-Print function which prints (format,args,....)
-in Scilab window
-*/
-
-void mexPrintf(const char *fmt, ...)
+int mexPrintf(const char *format, ...)
 {
-    va_list args;
-    char buf[2048];
-
-    va_start(args, fmt);
-    sprintf(buf, fmt, args);
-    YaspWrite(fmt);
-    va_end(args);
+    // TODO: define this size limit
+    char string[1024];
+    va_list arg_ptr;
+    va_start(arg_ptr, format);
+    vsnprintf(string, 1024, format, arg_ptr);
+    va_end(arg_ptr);
+    YaspWrite(string);
+    return 0;
 }
 
 void mexWarnMsgTxt(const char *error_msg)
@@ -1193,32 +1330,31 @@ void mexWarnMsgTxt(const char *error_msg)
     YaspError("\n\n");
 }
 
-int mexCallSCILAB(int nlhs, mxArray ** plhs, int nrhs, mxArray ** prhs, const char *name)
+int mexCallSCILAB(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name)
 {
     // FIXME
     return 0;
 }
 
-int mexCallMATLAB(int nlhs, mxArray ** plhs, int nrhs, mxArray ** prhs, const char *name)
+int mexCallMATLAB(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name)
 {
-    // FIXME
-    return 0;
+    return mexCallSCILAB(nlhs, plhs, nrhs, prhs, name);
 }
 
-int mxCalcSingleSubscript(const mxArray * ptr, int nsubs, const int *subs)
+int mxCalcSingleSubscript(const mxArray *ptr, int nsubs, const int *subs)
 {
-    int retval = 0, coeff = 1;
+    int index = 0;
+    int iMult = 1;
     int *dims = mxGetDimensions(ptr);
-
-    for (int i = 0; i < nsubs; i++)
+    for(int i = 0; i < nsubs; i++)
     {
-        retval += subs[i] * coeff;
-        coeff *= dims[i];
+        index += subs[i] * iMult;
+        iMult *= dims[i];
     }
-    return retval;
+    return index;
 }
 
-int C2F(mexcallscilab) (int *nlhs, mxArray ** plhs, int *nrhs, mxArray ** prhs, char *name, int namelen)
+int C2F(mexcallscilab) (int *nlhs, mxArray **plhs, int *nrhs, mxArray **prhs, char *name, int namelen)
 {
     return mexCallSCILAB(*nlhs, plhs, *nrhs, prhs, name);
 }
@@ -1229,15 +1365,19 @@ const char *mexFunctionName(void)
     return the_current_mex_name;
 }
 
-int mxGetElementSize(const mxArray * ptr)
+int mxGetElementSize(const mxArray *ptr)
 {
+    if (mxIsChar(ptr))
+    {
+        return sizeof(wchar_t *);
+    }
     if (mxIsDouble(ptr))
     {
-        return sizeof(types::Double *);
+        return sizeof(double);
     }
     if (mxIsChar(ptr))
     {
-        return sizeof(types::String *);
+        return sizeof(char);
     }
     if (mxIsSparse(ptr))
     {
@@ -1245,43 +1385,43 @@ int mxGetElementSize(const mxArray * ptr)
     }
     if (mxIsInt8(ptr))
     {
-        return sizeof(types::Int8 *);
+        return sizeof(char);
     }
     if (mxIsInt16(ptr))
     {
-        return sizeof(types::Int16 *);
+        return sizeof(short);
     }
     if (mxIsInt32(ptr))
     {
-        return sizeof(types::Int32 *);
+        return sizeof(int);
     }
     if (mxIsInt64(ptr))
     {
-        return sizeof(types::Int64 *);
+        return sizeof(long long);
     }
     if (mxIsUint8(ptr))
     {
-        return sizeof(types::UInt8 *);
+        return sizeof(unsigned char);
     }
     if (mxIsUint16(ptr))
     {
-        return sizeof(types::UInt16 *);
+        return sizeof(unsigned short);
     }
     if (mxIsUint32(ptr))
     {
-        return sizeof(types::UInt32 *);
+        return sizeof(unsigned int);
     }
     if (mxIsUint64(ptr))
     {
-        return sizeof(types::UInt64 *);
+        return sizeof(unsigned long long);
     }
     if (mxIsCell(ptr))
     {
-        return sizeof(types::Cell *);
+        return sizeof(types::InternalType *);
     }
     if (mxIsStruct(ptr))
     {
-        return sizeof(types::Struct *);
+        return sizeof(types::SingleStruct *);
     }
     return 0;
 }
@@ -1289,38 +1429,230 @@ int mxGetElementSize(const mxArray * ptr)
 mxArray *mxCreateCharMatrixFromStrings(int m, const char **str)
 {
     int n = 0;
-
     for (int k = 0; k < m; k++)
     {
-        n = Max(n, (int)strlen(str[k]));
+        n = Max(n, ((int) strlen(str[k])));
     }
-    // TODO: is wchar_t** cast right?
-    types::String * ptr = new types::String(m, n, (wchar_t **) str);
+    wchar_t **strings = new wchar_t*[m];
+    for (int k = 0; k < m; k++)
+    {
+        strings[k] = to_wide_string(str[k]);
+    }
+    types::String *ptr = new types::String(m, n, strings);
     return (mxArray *) ptr;
 }
 
 int mexEvalString(const char *name)
 {
-    // FIXME : Better use directly YaSp engine here.
-    // 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();
-    // }
+    // TODO: It is almost copied from sci_execstr.cpp. Refactor needed!
+    int iErr = 0;
+    bool bErrCatch = false;
+    bool bMute = true;
+    Parser parser;
+    parser.parse(to_wide_string(name));
+    if(parser.getExitStatus() !=  Parser::Succeded)
+    {
+        //mexPrintf(wide_string_to_UTF8(parser.getErrorMessage()));
+        return 1;
+    }
+
+    Exp *pExp = parser.getTree();
+
+    if(pExp == NULL)
+    {
+        //mexPrintf("pExp is NULL");
+        return 1;
+    }
+
+    //save current prompt mode
+    int oldVal = ConfigVariable::getPromptMode();
+    if(bMute)
+    {
+        ConfigVariable::setPromptMode(-1);
+    }
+    std::list<Exp *>::iterator j;
+    std::list<Exp *>LExp = ((SeqExp*)pExp)->exps_get();
+
+    for(j = LExp.begin() ; j != LExp.end() ; j++)
+    {
+        try
+        {
+            //excecute script
+            ExecVisitor execMe;
+            (*j)->accept(execMe);
+
+            //to manage call without ()
+            if(execMe.result_get() != NULL && execMe.result_get()->getAsCallable())
+            {
+                Callable *pCall = execMe.result_get()->getAsCallable();
+                types::typed_list out;
+                types::typed_list in;
+                try
+                {
+                    ExecVisitor execCall;
+                    Function::ReturnValue Ret = pCall->call(in, 1, out, &execCall);
+                    if(Ret == Callable::OK)
+                    {
+                        if(out.size() == 0)
+                        {
+                            execMe.result_set(NULL);
+                        }
+                        else if(out.size() == 1)
+                        {
+                            out[0]->DecreaseRef();
+                            execMe.result_set(out[0]);
+                        }
+                        else
+                        {
+                            for(int i = 0 ; i < static_cast<int>(out.size()) ; i++)
+                            {
+                                out[i]->DecreaseRef();
+                                execMe.result_set(i, out[i]);
+                            }
+                        }
+                    }
+                    else if(Ret == Callable::Error)
+                    {
+                        if(ConfigVariable::getLastErrorFunction() == L"")
+                        {
+                            ConfigVariable::setLastErrorFunction(pCall->getName());
+                        }
+
+                        if(pCall->isMacro() || pCall->isMacroFile())
+                        {
+                            wchar_t szError[bsiz];
+                            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n"), (*j)->location_get().first_line, pCall->getName().c_str());
+                            throw ScilabMessage(szError);
+                        }
+                        else
+                        {
+                            throw ScilabMessage();
+                        }
+                    }
+                }
+                catch(ScilabMessage sm)
+                {
+                    wostringstream os;
+                    PrintVisitor printMe(os);
+                    (*j)->accept(printMe);
+                    os << std::endl << std::endl;
+                    if(ConfigVariable::getLastErrorFunction() == L"")
+                    {
+                        ConfigVariable::setLastErrorFunction(pCall->getName());
+                    }
+
+                    if(pCall->isMacro() || pCall->isMacroFile())
+                    {
+                        wstring szAllError;
+                        wchar_t szError[bsiz];
+                        os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n"), sm.GetErrorLocation().first_line, pCall->getName().c_str());
+                        szAllError = szError + os.str();
+                        os_swprintf(szError, bsiz, _W("in  execstr instruction    called by :\n"));
+                        szAllError += szError;
+                        throw ScilabMessage(szAllError);
+                    }
+                    else
+                    {
+                        sm.SetErrorMessage(sm.GetErrorMessage() + os.str());
+                        throw sm;
+                    }
+                }
+            }
+
+            //update ans variable.
+            if(execMe.result_get() != NULL && execMe.result_get()->isDeletable())
+            {
+                symbol::Context::getInstance()->put(symbol::Symbol(L"ans"), *execMe.result_get());
+                if((*j)->is_verbose() && bErrCatch == false)
+                {
+                    std::wostringstream ostr;
+                    ostr << L"ans = " << std::endl;
+                    ostr << std::endl;
+                    ostr << execMe.result_get()->toString(ConfigVariable::getFormat(), ConfigVariable::getConsoleWidth()) << std::endl;
+                    YaspWriteW(ostr.str().c_str());
+                }
+            }
+        }
+        catch(ScilabMessage sm)
+        {
+            if(bErrCatch  == false && bMute == false)
+            {
+                YaspErrorW(sm.GetErrorMessage().c_str());
+
+                CallExp* pCall = dynamic_cast<CallExp*>(*j);
+                if(pCall != NULL)
+                {//to print call expression only of it is a macro
+                    ExecVisitor execFunc;
+                    pCall->name_get().accept(execFunc);
+
+                    if(execFunc.result_get() != NULL &&
+                        (execFunc.result_get()->isMacro() || execFunc.result_get()->isMacroFile()))
+                    {
+                        wostringstream os;
+
+                        //add function failed
+                        PrintVisitor printMe(os);
+                        pCall->accept(printMe);
+                        os << std::endl;
+
+                        //add info on file failed
+                        wchar_t szError[bsiz];
+                        os_swprintf(szError, bsiz, _W("at line % 5d of exec file called by :\n"), (*j)->location_get().first_line);
+                        os << szError;
+
+                        if(ConfigVariable::getLastErrorFunction() == L"")
+                        {
+                            ConfigVariable::setLastErrorFunction(execFunc.result_get()->getAsCallable()->getName());
+                        }
+
+                        //restore previous prompt mode
+                        ConfigVariable::setPromptMode(oldVal);
+                        throw ScilabMessage(os.str(), 0, (*j)->location_get());
+                    }
+                }
+                throw ScilabMessage((*j)->location_get());
+            }
+            else
+            {
+                iErr = ConfigVariable::getLastErrorNumber();
+                break;
+            }
+        }
+        catch(ScilabError se)
+        {
+            if(ConfigVariable::getLastErrorMessage() == L"")
+            {
+                ConfigVariable::setLastErrorMessage(se.GetErrorMessage());
+                ConfigVariable::setLastErrorNumber(se.GetErrorNumber());
+                ConfigVariable::setLastErrorLine(se.GetErrorLocation().first_line);
+                ConfigVariable::setLastErrorFunction(wstring(L""));
+            }
+
+            //store message
+            iErr = ConfigVariable::getLastErrorNumber();
+            if(bErrCatch == false)
+            {
+                //in case of error, change mode to 2 ( prompt )
+                ConfigVariable::setPromptMode(2);
+                //write error
+                YaspErrorW(se.GetErrorMessage().c_str());
+                YaspErrorW(L"\n");
+
+                //write positino
+                wchar_t szError[bsiz];
+                os_swprintf(szError, bsiz, _W("at line % 5d of exec file called by :\n"), (*j)->location_get().first_line);
+                //restore previous prompt mode
+                ConfigVariable::setPromptMode(oldVal);
+                throw ScilabMessage(szError, 1, (*j)->location_get());
+            }
+            break;
+        }
+    }
+
+    //restore previous prompt mode
+    ConfigVariable::setPromptMode(oldVal);
+
+    delete parser.getTree();
     return 0;
 }
 
@@ -1331,76 +1663,65 @@ mxArray *mexGetArray(char *name, char *workspace)
 
 const mxArray *mexGetVariablePtr(const char *workspace, const char *var_name)
 {
-    mxArray *value = mexGetVariable(workspace, var_name);
-
-    if (value)
-    {
-        return mxDuplicateArray(value);
-    }
-    return NULL;
+    const mxArray *value = mexGetVariable(workspace, var_name);
+    return value;
 }
 
 mxArray *mexGetVariable(const char *workspace, const char *name)
 {
-    symbol::Context * context = symbol::Context::getInstance();
-    wchar_t *dest;
-
-    mbstowcs(dest, name, strlen(name));
-    types::InternalType * value = NULL;
-    if (strcmp(workspace, "base"))
+    symbol::Context *context = symbol::Context::getInstance();
+    wchar_t *key = to_wide_string(name);
+    types::InternalType *value = NULL;
+    if (strcmp(workspace, "base") == 0)
     {
-        value = context->get(*(new symbol::Symbol(dest)));
+        value = context->get(*(new symbol::Symbol(key)));
     }
-    else if (strcmp(workspace, "caller"))
+    else if (strcmp(workspace, "caller") == 0)
     {
-        value = context->getCurrentLevel(*(new symbol::Symbol(dest)));
+        value = context->getCurrentLevel(*(new symbol::Symbol(key)));
     }
-    else if (strcmp(workspace, "global"))
+    else if (strcmp(workspace, "global") == 0)
     {
-        value = context->getGlobalValue(*(new symbol::Symbol(dest)));
+        value = context->getGlobalValue(*(new symbol::Symbol(key)));
     }
+    FREE(key);
     return (mxArray *) value;
 }
 
-int mexPutArray(mxArray * array_ptr, char *workspace)
-{
-    /* obsolete */
-    mexPrintf(_("Function mexPutArray is obsolete, use mexPutVariable!\n"));
-    return 1;
-}
-
-int mexPutVariable(const char *workspace, char *var_name, mxArray * array_ptr)
+int mexPutVariable(const char *workspace, const char *varname, const mxArray *pm)
 {
-    symbol::Context * context = symbol::Context::getInstance();
-    wchar_t *dest;
-
-    mbstowcs(dest, var_name, strlen(var_name));
-    if (strcmp(workspace, "base"))
+    symbol::Context *context = symbol::Context::getInstance();
+    wchar_t *dest = to_wide_string(varname);
+    if (strcmp(workspace, "base") == 0)
     {
-        context->put(*(new symbol::Symbol(dest)), *(types::InternalType *) array_ptr);
+        context->put(*(new symbol::Symbol(dest)), *(types::InternalType *) pm);
     }
-    else if (strcmp(workspace, "caller"))
+    else if (strcmp(workspace, "caller") == 0)
     {
-        context->put_in_previous_scope(*(new symbol::Symbol(dest)), *(types::InternalType *) array_ptr);
+        context->put_in_previous_scope(*(new symbol::Symbol(dest)), *(types::InternalType *) pm);
     }
-    else if (strcmp(workspace, "global"))
+    else if (strcmp(workspace, "global") == 0)
     {
-        context->setGlobalValue(*(new symbol::Symbol(dest)), *(types::InternalType *) array_ptr);
+        context->setGlobalValue(*(new symbol::Symbol(dest)), *(types::InternalType *) pm);
     }
-    return NULL;
+    else
+    {
+        return 1;
+    }
+    return 0;
 }
 
 int mexPutFull(char *name, int m, int n, double *pr, double *pi)
 {
+    /* obsolete */
     mxArray *array_ptr = mxCreateDoubleMatrix(m, n, pi == NULL ? mxREAL : mxCOMPLEX);
-
     mxSetPr(array_ptr, pr);
     mxSetPi(array_ptr, pi);
     mexPutVariable("caller", name, array_ptr);
     return 0;
 }
 
-void mxSetName(mxArray * array_ptr, const char *name)
+void mxSetName(mxArray *array_ptr, const char *name)
 {
     /* obsolete */
     // FIXME
@@ -1408,65 +1729,119 @@ void mxSetName(mxArray * array_ptr, const char *name)
     exit(1);
 }
 
-void mxSetData(mxArray * array_ptr, void *data_ptr)
+void mxSetData(mxArray *array_ptr, void *data_ptr)
 {
-
     if (mxIsChar(array_ptr))
     {
         ((types::String *) array_ptr)->set((wchar_t **) data_ptr);
     }
+    else if (mxIsDouble(array_ptr))
+    {
+        ((types::Double *) array_ptr)->set((double *) data_ptr);
+    }
     else if (mxIsInt8(array_ptr))
     {
-        ((types::Int8 *) array_ptr)->set((char *)data_ptr);
+        ((types::Int8 *) array_ptr)->set((char *) data_ptr);
     }
     else if (mxIsInt16(array_ptr))
     {
-        ((types::Int16 *) array_ptr)->set((short *)data_ptr);
+        ((types::Int16 *) array_ptr)->set((short *) data_ptr);
     }
     else if (mxIsInt32(array_ptr))
     {
-        ((types::Int32 *) array_ptr)->set((int *)data_ptr);
+        ((types::Int32 *) array_ptr)->set((int *) data_ptr);
     }
     else if (mxIsInt64(array_ptr))
     {
-        ((types::Int64 *) array_ptr)->set((long long *)data_ptr);
+        ((types::Int64 *) array_ptr)->set((long long *) data_ptr);
     }
     else if (mxIsLogical(array_ptr))
     {
-        ((types::Bool *) array_ptr)->set((int *)data_ptr);
+        ((types::Bool *) array_ptr)->set((int *) data_ptr);
     }
     // else if (mxIsSingle(array_ptr)) {
     //   ((types::Float *) array_ptr)->set((float *) data_ptr);
     // }
     else if (mxIsUint8(array_ptr))
     {
-        ((types::UInt8 *) array_ptr)->set((unsigned char *)data_ptr);
+        ((types::UInt8 *) array_ptr)->set((unsigned char *) data_ptr);
+    }
+    else if (mxIsUint16(array_ptr))
+    {
+        ((types::UInt16 *) array_ptr)->set((unsigned short *) data_ptr);
+    }
+    else if (mxIsUint32(array_ptr))
+    {
+        ((types::UInt32 *) array_ptr)->set((unsigned int *) data_ptr);
+    }
+    else if (mxIsUint64(array_ptr))
+    {
+        ((types::UInt64 *) array_ptr)->set((unsigned long long *) data_ptr);
+    }
+}
+
+void mxSetImagData(mxArray *array_ptr, void *data_ptr)
+{
+    if (mxIsChar(array_ptr))
+    {
+        ((types::String *) array_ptr)->setImg((wchar_t **) data_ptr);
+    }
+    else if (mxIsDouble(array_ptr))
+    {
+        ((types::Double *) array_ptr)->setImg((double *) data_ptr);
+    }
+    else if (mxIsInt8(array_ptr))
+    {
+        ((types::Int8 *) array_ptr)->setImg((char *) data_ptr);
+    }
+    else if (mxIsInt16(array_ptr))
+    {
+        ((types::Int16 *) array_ptr)->setImg((short *) data_ptr);
+    }
+    else if (mxIsInt32(array_ptr))
+    {
+        ((types::Int32 *) array_ptr)->setImg((int *) data_ptr);
+    }
+    else if (mxIsInt64(array_ptr))
+    {
+        ((types::Int64 *) array_ptr)->setImg((long long *) data_ptr);
+    }
+    else if (mxIsLogical(array_ptr))
+    {
+        ((types::Bool *) array_ptr)->setImg((int *) data_ptr);
+    }
+    // else if (mxIsSingle(array_ptr)) {
+    //   ((types::Float *) array_ptr)->setImg((float *) data_ptr);
+    // }
+    else if (mxIsUint8(array_ptr))
+    {
+        ((types::UInt8 *) array_ptr)->setImg((unsigned char *) data_ptr);
     }
     else if (mxIsUint16(array_ptr))
     {
-        ((types::UInt16 *) array_ptr)->set((unsigned short *)data_ptr);
+        ((types::UInt16 *) array_ptr)->setImg((unsigned short *) data_ptr);
     }
     else if (mxIsUint32(array_ptr))
     {
-        ((types::UInt32 *) array_ptr)->set((unsigned int *)data_ptr);
+        ((types::UInt32 *) array_ptr)->setImg((unsigned int *) data_ptr);
     }
     else if (mxIsUint64(array_ptr))
     {
-        ((types::UInt64 *) array_ptr)->set((unsigned long long *)data_ptr);
+        ((types::UInt64 *) array_ptr)->setImg((unsigned long long *) data_ptr);
     }
 }
 
-void mxSetPr(mxArray * ptr, double *pr)
+void mxSetPr(mxArray *ptr, double *pr)
 {
     ((types::Double *) ptr)->set(pr);
 }
 
-void mxSetPi(mxArray * ptr, double *pi)
+void mxSetPi(mxArray *ptr, double *pi)
 {
     ((types::Double *) ptr)->setImg(pi);
 }
 
-const char *mxGetName(const mxArray * array_ptr)
+const char *mxGetName(const mxArray *array_ptr)
 {
     /* obsolete */
     // FIXME
@@ -1475,74 +1850,74 @@ const char *mxGetName(const mxArray * array_ptr)
     return 0;
 }
 
-int mxSetDimensions(mxArray * array_ptr, const int *dims, int ndim)
+int mxSetDimensions(mxArray *array_ptr, const int *dims, int ndim)
 {
     if (mxIsCell(array_ptr))
     {
-        ((types::Cell *) array_ptr)->resize((int *)dims, ndim);
+        ((types::Cell *) array_ptr)->resize((int *) dims, ndim);
     }
     else if (mxIsChar(array_ptr))
     {
-        ((types::String *) array_ptr)->resize((int *)dims, ndim);
+        ((types::String *) array_ptr)->resize((int *) dims, ndim);
     }
     else if (mxIsDouble(array_ptr))
     {
-        ((types::Double *) array_ptr)->resize((int *)dims, ndim);
+        ((types::Double *) array_ptr)->resize((int *) dims, ndim);
+    }
+     else if (mxIsFunction(array_ptr)) {
+         //((types::Function *) array_ptr)->resize((int *) dims, ndim);
     }
-    // else if (mxIsFunction(array_ptr)) {
-    //     ((types::Function *) array_ptr)->resize((int *) dims, ndim);
-    //}
     // else if (mxIsSparse(array_ptr)) {
     //     TODO: we don't have Sparse classes yet
     // }
     else if (mxIsInt8(array_ptr))
     {
-        ((types::Int8 *) array_ptr)->resize((int *)dims, ndim);
+        ((types::Int8 *) array_ptr)->resize((int *) dims, ndim);
     }
     else if (mxIsInt16(array_ptr))
     {
-        ((types::Int16 *) array_ptr)->resize((int *)dims, ndim);
+        ((types::Int16 *) array_ptr)->resize((int *) dims, ndim);
     }
     else if (mxIsInt32(array_ptr))
     {
-        ((types::Int32 *) array_ptr)->resize((int *)dims, ndim);
+        ((types::Int32 *) array_ptr)->resize((int *) dims, ndim);
     }
     else if (mxIsInt64(array_ptr))
     {
-        ((types::Int64 *) array_ptr)->resize((int *)dims, ndim);
+        ((types::Int64 *) array_ptr)->resize((int *) dims, ndim);
     }
     else if (mxIsLogical(array_ptr))
     {
-        ((types::Bool *) array_ptr)->resize((int *)dims, ndim);
+        ((types::Bool *) array_ptr)->resize((int *) dims, ndim);
     }
     // else if (mxIsSingle(array_ptr)) {
     //     ((types::Float *) array_ptr)->resize((int *) dims, ndim);
     // }
     else if (mxIsStruct(array_ptr))
     {
-        ((types::Struct *) array_ptr)->resize((int *)dims, ndim);
+        ((types::Struct *) array_ptr)->resize((int *) dims, ndim);
     }
     else if (mxIsUint8(array_ptr))
     {
-        ((types::UInt8 *) array_ptr)->resize((int *)dims, ndim);
+        ((types::UInt8 *) array_ptr)->resize((int *) dims, ndim);
     }
     else if (mxIsUint16(array_ptr))
     {
-        ((types::UInt16 *) array_ptr)->resize((int *)dims, ndim);
+        ((types::UInt16 *) array_ptr)->resize((int *) dims, ndim);
     }
     else if (mxIsUint32(array_ptr))
     {
-        ((types::UInt32 *) array_ptr)->resize((int *)dims, ndim);
+        ((types::UInt32 *) array_ptr)->resize((int *) dims, ndim);
     }
     else if (mxIsUint64(array_ptr))
     {
-        ((types::UInt64 *) array_ptr)->resize((int *)dims, ndim);
+        ((types::UInt64 *) array_ptr)->resize((int *) dims, ndim);
     }
 
     return 0;
 }
 
-const char *mxGetClassName(const mxArray * ptr)
+const char *mxGetClassName(const mxArray *ptr)
 {
     if (mxIsDouble(ptr))
     {
@@ -1596,29 +1971,33 @@ const char *mxGetClassName(const mxArray * ptr)
     {
         return "struct";
     }
+    if (mxIsFunction(ptr))
+    {
+        return "function_handle";
+    }
     return "unknown";
 }
 
-void mxSetCell(mxArray * array_ptr, int lindex, mxArray * value)
+void mxSetCell(mxArray *array_ptr, int lindex, mxArray *value)
 {
     ((types::Cell *) array_ptr)->set(lindex, (types::InternalType *) value);
 }
 
-int mxGetNzmax(const mxArray * ptr)
+int mxGetNzmax(const mxArray *ptr)
 {
     // TODO: sparse
     return 0;
 }
 
-mxLogical *mxGetLogicals(const mxArray * ptr)
+mxLogical *mxGetLogicals(const mxArray *ptr)
 {
-    types::InternalType * pIT = (types::InternalType *) ptr;
+    types::InternalType *pIT = (types::InternalType *) ptr;
     if (pIT == NULL)
     {
         return NULL;
     }
 
-    types::Bool * pB = pIT->getAs < types::Bool > ();
+    types::Bool *pB = pIT->getAs<types::Bool>();
     if (pB == NULL)
     {
         return NULL;
@@ -1645,52 +2024,52 @@ int mexCheck(char *str, int nbvars)
 * C functions for Fortran  mexfunctions
 ****************************************************/
 
-double *C2F(mxgetpr) (mxArray * ptr)
+double *C2F(mxgetpr) (mxArray *ptr)
 {
     return mxGetPr(ptr);
 }
 
-double *C2F(mxgetpi) (mxArray * ptr)
+double *C2F(mxgetpi) (mxArray *ptr)
 {
     return mxGetPi(ptr);
 }
 
-int C2F(mxgetm) (mxArray * ptr)
+int C2F(mxgetm) (mxArray *ptr)
 {
     return mxGetM(ptr);
 }
 
-int C2F(mxgetn) (mxArray * ptr)
+int C2F(mxgetn) (mxArray *ptr)
 {
     return mxGetN(ptr);
 }
 
-int C2F(mxisstring) (mxArray * ptr)
+int C2F(mxisstring) (mxArray *ptr)
 {
     return mxIsString(ptr);
 }
 
-int C2F(mxisnumeric) (mxArray * ptr)
+int C2F(mxisnumeric) (mxArray *ptr)
 {
     return mxIsNumeric(ptr);
 }
 
-int C2F(mxisfull) (mxArray * ptr)
+int C2F(mxisfull) (mxArray *ptr)
 {
     return mxIsFull(ptr);
 }
 
-int C2F(mxissparse) (mxArray * ptr)
+int C2F(mxissparse) (mxArray *ptr)
 {
     return mxIsSparse(ptr);
 }
 
-int C2F(mxiscomplex) (mxArray * ptr)
+int C2F(mxiscomplex) (mxArray *ptr)
 {
     return mxIsComplex(ptr);
 }
 
-double C2F(mxgetscalar) (mxArray * ptr)
+double C2F(mxgetscalar) (mxArray *ptr)
 {
     return mxGetScalar(ptr);
 }
@@ -1724,12 +2103,12 @@ unsigned long int C2F(mxcalloc) (unsigned int *n, unsigned int *size)
     return 0;
 }
 
-int C2F(mxgetstring) (mxArray * ptr, char *str, int *strl)
+int C2F(mxgetstring) (mxArray *ptr, char *str, int *strl)
 {
     return mxGetString(ptr, str, *strl);
 }
 
-void C2F(mxfreematrix) (mxArray * ptr)
+void C2F(mxfreematrix) (mxArray *ptr)
 {
     mxFreeMatrix(ptr);
 }
@@ -1740,40 +2119,34 @@ mxArray *C2F(mxcreatestring) (char *string, long int l)
     return mxCreateString(string);
 }
 
-int C2F(mxcopyreal8toptr) (double *y, mxArray * ptr, int *n)
+int C2F(mxcopyreal8toptr) (double *y, mxArray *ptr, int *n)
 {
     double *pr = mxGetPr(ptr);
-
     memcpy(y, pr, (*n) * sizeof(double));
     return 0;
 }
 
-int C2F(mxcopycomplex16toptr) (double *y, mxArray * ptr, mxArray * pti, int *n)
+int C2F(mxcopycomplex16toptr) (double *y, mxArray *ptr, mxArray *pti, int *n)
 {
     // FIXME : Wrap this one to the C one
     return 0;
 }
 
-int C2F(mxcopyptrtoreal8) (mxArray * ptr, double *y, int *n)
+int C2F(mxcopyptrtoreal8) (mxArray *ptr, double *y, int *n)
 {
     double *pr = mxGetPr(ptr);
-
     memcpy(pr, y, (*n) * sizeof(double));
     return 0;
 }
 
-int C2F(mxcopyptrtocomplex16) (mxArray * ptr, mxArray * pti, double *y, int *n)
+int C2F(mxcopyptrtocomplex16) (mxArray *ptr, mxArray *pti, double *y, int *n)
 {
     // FIXME : Wrap this one to the C one
     return 0;
 }
 
-/* mxCreateLogicalArray
- * 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);  */
index ac4c13b..d0235ac 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;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(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;../../../parse/includes;../../../system_env/includes;../../../api_scilab/includes;../../../threads/includes;../../../operations/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;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(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;../../../parse/includes;../../../system_env/includes;../../../api_scilab/includes;../../../threads/includes;../../../operations/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;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(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;../../../parse/includes;../../../system_env/includes;../../../api_scilab/includes;../../../threads/includes;../../../operations/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;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(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;../../../parse/includes;../../../system_env/includes;../../../api_scilab/includes;../../../threads/includes;../../../operations/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
@@ -275,6 +275,12 @@ del libmattemp.def &gt;nul
     <ProjectReference Include="..\..\..\abstractSyntaxTree\abstractSyntaxTree-tools\abstractSyntaxTree-tools.vcxproj">
       <Project>{1f4a0344-99ed-461b-bd53-1593788fb34d}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\abstractSyntaxTree\abstractSyntaxTree.vcxproj">
+      <Project>{0d3fa25b-8116-44ec-a45e-260789daa3d9}</Project>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\api_scilab\api_scilab.vcxproj">
+      <Project>{43c5bab1-1dca-4743-a183-77e0d42fe7d0}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\data_structures\src\c\data_structures.vcxproj">
       <Project>{b7a168a0-dfc0-4c6d-b0cc-6079912a4a76}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
@@ -291,10 +297,16 @@ del libmattemp.def &gt;nul
       <Project>{ecffeb0c-1eda-45ee-9a10-b18143852e17}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\operations\operations.vcxproj">
+      <Project>{1bb396f7-ce61-4cfc-9c22-266b2cfb2e74}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\output_stream\src\c\output_stream.vcxproj">
       <Project>{a5911cd7-f8e8-440c-a23e-4843a0636f3a}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\parse\parse.vcxproj">
+      <Project>{74d43792-dbfc-47f0-adbc-4d7a20cdada2}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\string\src\c\string.vcxproj">
       <Project>{8d45767a-9b03-4905-97f6-d2f3f79141ea}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
@@ -302,9 +314,15 @@ del libmattemp.def &gt;nul
     <ProjectReference Include="..\..\..\symbol\symbol.vcxproj">
       <Project>{2c60033b-0dbd-4ca4-80d3-176c9be9ce2f}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\system_env\system_env.vcxproj">
+      <Project>{7ca60aef-9afa-4d06-af28-613c0aa27640}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\types\types.vcxproj">
       <Project>{64e090da-dcb5-4f4d-93d7-e88ddec9c2ef}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\types\typesmacro\typesmacro.vcxproj">
+      <Project>{9252a034-7f22-4cb1-a634-4577da69f2d0}</Project>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\cpp\mexlib.cpp" />
index e6b4e46..4ac952f 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;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(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;../../../parse/includes;../../../system_env/includes;../../../api_scilab/includes;../../../threads/includes;../../../operations/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;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(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;../../../parse/includes;../../../system_env/includes;../../../api_scilab/includes;../../../threads/includes;../../../operations/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;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(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;../../../parse/includes;../../../system_env/includes;../../../api_scilab/includes;../../../threads/includes;../../../operations/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;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(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;../../../parse/includes;../../../system_env/includes;../../../api_scilab/includes;../../../threads/includes;../../../operations/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
@@ -280,6 +280,12 @@ del libmextemp.def &gt;nul
     <ProjectReference Include="..\..\..\abstractSyntaxTree\abstractSyntaxTree-tools\abstractSyntaxTree-tools.vcxproj">
       <Project>{1f4a0344-99ed-461b-bd53-1593788fb34d}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\abstractSyntaxTree\abstractSyntaxTree.vcxproj">
+      <Project>{0d3fa25b-8116-44ec-a45e-260789daa3d9}</Project>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\api_scilab\api_scilab.vcxproj">
+      <Project>{43c5bab1-1dca-4743-a183-77e0d42fe7d0}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\data_structures\src\c\data_structures.vcxproj">
       <Project>{b7a168a0-dfc0-4c6d-b0cc-6079912a4a76}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
@@ -296,10 +302,16 @@ del libmextemp.def &gt;nul
       <Project>{ecffeb0c-1eda-45ee-9a10-b18143852e17}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\operations\operations.vcxproj">
+      <Project>{1bb396f7-ce61-4cfc-9c22-266b2cfb2e74}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\output_stream\src\c\output_stream.vcxproj">
       <Project>{a5911cd7-f8e8-440c-a23e-4843a0636f3a}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\parse\parse.vcxproj">
+      <Project>{74d43792-dbfc-47f0-adbc-4d7a20cdada2}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\string\src\c\string.vcxproj">
       <Project>{8d45767a-9b03-4905-97f6-d2f3f79141ea}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
@@ -307,9 +319,15 @@ del libmextemp.def &gt;nul
     <ProjectReference Include="..\..\..\symbol\symbol.vcxproj">
       <Project>{2c60033b-0dbd-4ca4-80d3-176c9be9ce2f}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\system_env\system_env.vcxproj">
+      <Project>{7ca60aef-9afa-4d06-af28-613c0aa27640}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\types\types.vcxproj">
       <Project>{64e090da-dcb5-4f4d-93d7-e88ddec9c2ef}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\types\typesmacro\typesmacro.vcxproj">
+      <Project>{9252a034-7f22-4cb1-a634-4577da69f2d0}</Project>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
index 785db42..4954c7f 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;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(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;../../../parse/includes;../../../system_env/includes;../../../api_scilab/includes;../../../threads/includes;../../../operations/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;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(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;../../../parse/includes;../../../system_env/includes;../../../api_scilab/includes;../../../threads/includes;../../../operations/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;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(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;../../../parse/includes;../../../system_env/includes;../../../api_scilab/includes;../../../threads/includes;../../../operations/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;../../../types/includes;../../../abstractSyntaxTree/includes;../../../symbol/includes;%(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;../../../parse/includes;../../../system_env/includes;../../../api_scilab/includes;../../../threads/includes;../../../operations/includes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>mexFunction=mex_libmx;mexfunction_=mexlibmx_;FORDLL;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
@@ -276,6 +276,12 @@ del libmxtemp.def &gt;nul
     <ProjectReference Include="..\..\..\abstractSyntaxTree\abstractSyntaxTree-tools\abstractSyntaxTree-tools.vcxproj">
       <Project>{1f4a0344-99ed-461b-bd53-1593788fb34d}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\abstractSyntaxTree\abstractSyntaxTree.vcxproj">
+      <Project>{0d3fa25b-8116-44ec-a45e-260789daa3d9}</Project>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\api_scilab\api_scilab.vcxproj">
+      <Project>{43c5bab1-1dca-4743-a183-77e0d42fe7d0}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\data_structures\src\c\data_structures.vcxproj">
       <Project>{b7a168a0-dfc0-4c6d-b0cc-6079912a4a76}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
@@ -292,10 +298,16 @@ del libmxtemp.def &gt;nul
       <Project>{ecffeb0c-1eda-45ee-9a10-b18143852e17}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\operations\operations.vcxproj">
+      <Project>{1bb396f7-ce61-4cfc-9c22-266b2cfb2e74}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\output_stream\src\c\output_stream.vcxproj">
       <Project>{a5911cd7-f8e8-440c-a23e-4843a0636f3a}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\parse\parse.vcxproj">
+      <Project>{74d43792-dbfc-47f0-adbc-4d7a20cdada2}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\string\src\c\string.vcxproj">
       <Project>{8d45767a-9b03-4905-97f6-d2f3f79141ea}</Project>
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
@@ -303,9 +315,18 @@ del libmxtemp.def &gt;nul
     <ProjectReference Include="..\..\..\symbol\symbol.vcxproj">
       <Project>{2c60033b-0dbd-4ca4-80d3-176c9be9ce2f}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\system_env\system_env.vcxproj">
+      <Project>{7ca60aef-9afa-4d06-af28-613c0aa27640}</Project>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\threads\threads.vcxproj">
+      <Project>{50a1ffc8-adc2-4d9e-a2d0-5dcd63188ae9}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\types\types.vcxproj">
       <Project>{64e090da-dcb5-4f4d-93d7-e88ddec9c2ef}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\types\typesmacro\typesmacro.vcxproj">
+      <Project>{9252a034-7f22-4cb1-a634-4577da69f2d0}</Project>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\cpp\mexlib.cpp" />
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexEvalString.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexEvalString.linux.dia.ref
new file mode 100644 (file)
index 0000000..97bdb1b
--- /dev/null
@@ -0,0 +1,62 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexEvalString mex functions
+
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    char *string = mxArrayToString(prhs[0]);';
+       '    plhs[0] = mxCreateDoubleScalar(mexEvalString(string));';
+       '}'],'mexevalString.c');
+ilib_mex_build('libmextest',['evalString','mexevalString','cmex'], 'mexevalString.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 mexevalString.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+r = evalString('printf ""mexEvalString works!\n"";');
+mexEvalString works!
+
+if r <> 0 then pause end
+
+global a;
+
+r = evalString('a = 1;');
+
+if a <> 1 then pause end
+
+if r <> 0 then pause end
+
+r = evalString('b =;');
+
+if r <> 1 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexEvalString.tst b/scilab/modules/mexlib/tests/unit_tests/mexEvalString.tst
new file mode 100644 (file)
index 0000000..4002fe7
--- /dev/null
@@ -0,0 +1,33 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mexEvalString mex functions
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    char *string = mxArrayToString(prhs[0]);';
+       '    plhs[0] = mxCreateDoubleScalar(mexEvalString(string));';
+       '}'],'mexevalString.c');
+ilib_mex_build('libmextest',['evalString','mexevalString','cmex'], 'mexevalString.c',[],'Makelib','','','');
+exec('loader.sce');
+
+r = evalString('printf ""mexEvalString works!\n"";');
+if r <> 0 then pause end
+
+global a;
+r = evalString('a = 1;');
+if a <> 1 then pause end
+if r <> 0 then pause end
+
+r = evalString('b =;');
+if r <> 1 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexEvalString.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexEvalString.win.dia.ref
new file mode 100644 (file)
index 0000000..4dc68b5
--- /dev/null
@@ -0,0 +1,62 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexEvalString mex functions
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    char *string = mxArrayToString(prhs[0]);';
+       '    plhs[0] = mxCreateDoubleScalar(mexEvalString(string));';
+       '}'],'mexevalString.c');
+
+ilib_mex_build('libmextest',['evalString','mexevalString','cmex'], 'mexevalString.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexevalString.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+r = evalString('printf ""mexEvalString works!\n"";');
+mexEvalString works!
+
+if r <> 0 then pause end
+
+global a;
+
+r = evalString('a = 1;');
+
+if a <> 1 then pause end
+
+if r <> 0 then pause end
+
+r = evalString('b =;');
+
+if r <> 1 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexGetArray.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexGetArray.linux.dia.ref
new file mode 100644 (file)
index 0000000..f21f30c
--- /dev/null
@@ -0,0 +1,65 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexGetArray mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *workspace = mxArrayToString(prhs[0]);';
+        '    char *name = mxArrayToString(prhs[1]);';
+        '    mxArray *pOut = mexGetArray(name, workspace);';
+        '    plhs[0] = pOut != NULL ? pOut : mxCreateString(""NULL"");';
+        '}'],'mexgetArray.c');
+ilib_mex_build('libmextest', ['getArray', 'mexgetArray', 'cmex'], 'mexgetArray.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 mexgetArray.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+global globalvar;
+
+globalvar = "my global var";
+
+callervar = "my caller var";
+
+if getArray("global", "globalvar") <> "my global var" then pause end
+
+if getArray("caller", "globalvar") <> "NULL" then pause end
+
+if getArray("base", "globalvar") <> "my global var" then pause end
+
+if getArray("global", "callervar") <> "NULL" then pause end
+
+if getArray("caller", "callervar") <> "my caller var" then pause end
+
+if getArray("base", "callervar") <> "my caller var" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexGetArray.tst b/scilab/modules/mexlib/tests/unit_tests/mexGetArray.tst
new file mode 100644 (file)
index 0000000..1dc213d
--- /dev/null
@@ -0,0 +1,34 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mexGetArray mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *workspace = mxArrayToString(prhs[0]);';
+        '    char *name = mxArrayToString(prhs[1]);';
+        '    mxArray *pOut = mexGetArray(name, workspace);';
+        '    plhs[0] = pOut != NULL ? pOut : mxCreateString(""NULL"");';
+        '}'],'mexgetArray.c');
+ilib_mex_build('libmextest', ['getArray', 'mexgetArray', 'cmex'], 'mexgetArray.c', [], 'Makelib', '', '', '');
+exec('loader.sce');
+
+global globalvar;
+globalvar = "my global var";
+callervar = "my caller var";
+if getArray("global", "globalvar") <> "my global var" then pause end
+if getArray("caller", "globalvar") <> "NULL" then pause end
+if getArray("base", "globalvar") <> "my global var" then pause end
+if getArray("global", "callervar") <> "NULL" then pause end
+if getArray("caller", "callervar") <> "my caller var" then pause end
+if getArray("base", "callervar") <> "my caller var" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexGetArray.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexGetArray.win.dia.ref
new file mode 100644 (file)
index 0000000..ce11f27
--- /dev/null
@@ -0,0 +1,65 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexGetArray mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *workspace = mxArrayToString(prhs[0]);';
+        '    char *name = mxArrayToString(prhs[1]);';
+        '    mxArray *pOut = mexGetArray(name, workspace);';
+        '    plhs[0] = pOut != NULL ? pOut : mxCreateString(""NULL"");';
+        '}'],'mexgetArray.c');
+
+ilib_mex_build('libmextest', ['getArray', 'mexgetArray', 'cmex'], 'mexgetArray.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetArray.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+global globalvar;
+
+globalvar = "my global var";
+
+callervar = "my caller var";
+
+if getArray("global", "globalvar") <> "my global var" then pause end
+
+if getArray("caller", "globalvar") <> "NULL" then pause end
+
+if getArray("base", "globalvar") <> "my global var" then pause end
+
+if getArray("global", "callervar") <> "NULL" then pause end
+
+if getArray("caller", "callervar") <> "my caller var" then pause end
+
+if getArray("base", "callervar") <> "my caller var" then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexGetVariable.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexGetVariable.linux.dia.ref
new file mode 100644 (file)
index 0000000..69ad176
--- /dev/null
@@ -0,0 +1,65 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexGetVariable mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *workspace = mxArrayToString(prhs[0]);';
+        '    char *name = mxArrayToString(prhs[1]);';
+        '    mxArray *pOut = mexGetVariable(workspace, name);';
+        '    plhs[0] = pOut != NULL ? pOut : mxCreateString(""NULL"");';
+        '}'],'mexgetVariable.c');
+ilib_mex_build('libmextest', ['getVariable', 'mexgetVariable', 'cmex'], 'mexgetVariable.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 mexgetVariable.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+global globalvar;
+
+globalvar = "my global var";
+
+callervar = "my caller var";
+
+if getVariable("global", "globalvar") <> "my global var" then pause end
+
+if getVariable("caller", "globalvar") <> "NULL" then pause end
+
+if getVariable("base", "globalvar") <> "my global var" then pause end
+
+if getVariable("global", "callervar") <> "NULL" then pause end
+
+if getVariable("caller", "callervar") <> "my caller var" then pause end
+
+if getVariable("base", "callervar") <> "my caller var" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexGetVariable.tst b/scilab/modules/mexlib/tests/unit_tests/mexGetVariable.tst
new file mode 100644 (file)
index 0000000..22b2346
--- /dev/null
@@ -0,0 +1,34 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mexGetVariable mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *workspace = mxArrayToString(prhs[0]);';
+        '    char *name = mxArrayToString(prhs[1]);';
+        '    mxArray *pOut = mexGetVariable(workspace, name);';
+        '    plhs[0] = pOut != NULL ? pOut : mxCreateString(""NULL"");';
+        '}'],'mexgetVariable.c');
+ilib_mex_build('libmextest', ['getVariable', 'mexgetVariable', 'cmex'], 'mexgetVariable.c', [], 'Makelib', '', '', '');
+exec('loader.sce');
+
+global globalvar;
+globalvar = "my global var";
+callervar = "my caller var";
+if getVariable("global", "globalvar") <> "my global var" then pause end
+if getVariable("caller", "globalvar") <> "NULL" then pause end
+if getVariable("base", "globalvar") <> "my global var" then pause end
+if getVariable("global", "callervar") <> "NULL" then pause end
+if getVariable("caller", "callervar") <> "my caller var" then pause end
+if getVariable("base", "callervar") <> "my caller var" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexGetVariable.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexGetVariable.win.dia.ref
new file mode 100644 (file)
index 0000000..b463a67
--- /dev/null
@@ -0,0 +1,65 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexGetVariable mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *workspace = mxArrayToString(prhs[0]);';
+        '    char *name = mxArrayToString(prhs[1]);';
+        '    mxArray *pOut = mexGetVariable(workspace, name);';
+        '    plhs[0] = pOut != NULL ? pOut : mxCreateString(""NULL"");';
+        '}'],'mexgetVariable.c');
+
+ilib_mex_build('libmextest', ['getVariable', 'mexgetVariable', 'cmex'], 'mexgetVariable.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetVariable.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+global globalvar;
+
+globalvar = "my global var";
+
+callervar = "my caller var";
+
+if getVariable("global", "globalvar") <> "my global var" then pause end
+
+if getVariable("caller", "globalvar") <> "NULL" then pause end
+
+if getVariable("base", "globalvar") <> "my global var" then pause end
+
+if getVariable("global", "callervar") <> "NULL" then pause end
+
+if getVariable("caller", "callervar") <> "my caller var" then pause end
+
+if getVariable("base", "callervar") <> "my caller var" then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexGetVariablePtr.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexGetVariablePtr.linux.dia.ref
new file mode 100644 (file)
index 0000000..5b6698f
--- /dev/null
@@ -0,0 +1,65 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexGetVariablePtr mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *workspace = mxArrayToString(prhs[0]);';
+        '    char *name = mxArrayToString(prhs[1]);';
+        '    mxArray *pOut = mexGetVariablePtr(workspace, name);';
+        '    plhs[0] = pOut != NULL ? pOut : mxCreateString(""NULL"");';
+        '}'],'mexgetVariablePtr.c');
+ilib_mex_build('libmextest', ['getVariablePtr', 'mexgetVariablePtr', 'cmex'], 'mexgetVariablePtr.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 mexgetVariablePtr.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+global globalvar;
+
+globalvar = "my global var";
+
+callervar = "my caller var";
+
+if getVariablePtr("global", "globalvar") <> "my global var" then pause end
+
+if getVariablePtr("caller", "globalvar") <> "NULL" then pause end
+
+if getVariablePtr("base", "globalvar") <> "my global var" then pause end
+
+if getVariablePtr("global", "callervar") <> "NULL" then pause end
+
+if getVariablePtr("caller", "callervar") <> "my caller var" then pause end
+
+if getVariablePtr("base", "callervar") <> "my caller var" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexGetVariablePtr.tst b/scilab/modules/mexlib/tests/unit_tests/mexGetVariablePtr.tst
new file mode 100644 (file)
index 0000000..5d85b94
--- /dev/null
@@ -0,0 +1,34 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mexGetVariablePtr mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *workspace = mxArrayToString(prhs[0]);';
+        '    char *name = mxArrayToString(prhs[1]);';
+        '    mxArray *pOut = mexGetVariablePtr(workspace, name);';
+        '    plhs[0] = pOut != NULL ? pOut : mxCreateString(""NULL"");';
+        '}'],'mexgetVariablePtr.c');
+ilib_mex_build('libmextest', ['getVariablePtr', 'mexgetVariablePtr', 'cmex'], 'mexgetVariablePtr.c', [], 'Makelib', '', '', '');
+exec('loader.sce');
+
+global globalvar;
+globalvar = "my global var";
+callervar = "my caller var";
+if getVariablePtr("global", "globalvar") <> "my global var" then pause end
+if getVariablePtr("caller", "globalvar") <> "NULL" then pause end
+if getVariablePtr("base", "globalvar") <> "my global var" then pause end
+if getVariablePtr("global", "callervar") <> "NULL" then pause end
+if getVariablePtr("caller", "callervar") <> "my caller var" then pause end
+if getVariablePtr("base", "callervar") <> "my caller var" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexGetVariablePtr.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexGetVariablePtr.win.dia.ref
new file mode 100644 (file)
index 0000000..44b4299
--- /dev/null
@@ -0,0 +1,65 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexGetVariablePtr mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *workspace = mxArrayToString(prhs[0]);';
+        '    char *name = mxArrayToString(prhs[1]);';
+        '    mxArray *pOut = mexGetVariablePtr(workspace, name);';
+        '    plhs[0] = pOut != NULL ? pOut : mxCreateString(""NULL"");';
+        '}'],'mexgetVariablePtr.c');
+
+ilib_mex_build('libmextest', ['getVariablePtr', 'mexgetVariablePtr', 'cmex'], 'mexgetVariablePtr.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetVariablePtr.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+global globalvar;
+
+globalvar = "my global var";
+
+callervar = "my caller var";
+
+if getVariablePtr("global", "globalvar") <> "my global var" then pause end
+
+if getVariablePtr("caller", "globalvar") <> "NULL" then pause end
+
+if getVariablePtr("base", "globalvar") <> "my global var" then pause end
+
+if getVariablePtr("global", "callervar") <> "NULL" then pause end
+
+if getVariablePtr("caller", "callervar") <> "my caller var" then pause end
+
+if getVariablePtr("base", "callervar") <> "my caller var" then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexIsGlobal.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexIsGlobal.linux.dia.ref
new file mode 100644 (file)
index 0000000..0cdd979
--- /dev/null
@@ -0,0 +1,55 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexIsGlobal mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    plhs[0] = mxCreateLogicalScalar(mexIsGlobal(prhs[0]));';
+        '}'],'mexisGlobal.c');
+
+ilib_mex_build('libmextest', ['isGlobal', 'mexisGlobal', 'cmex'], 'mexisGlobal.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 mexisGlobal.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+global globalvar;
+globalvar = 1;
+localvar = "s";
+
+if isGlobal(globalvar) <> %t then pause end
+
+if isGlobal(localvar) <> %f then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexIsGlobal.tst b/scilab/modules/mexlib/tests/unit_tests/mexIsGlobal.tst
new file mode 100644 (file)
index 0000000..372e269
--- /dev/null
@@ -0,0 +1,27 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mexIsGlobal mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    plhs[0] = mxCreateLogicalScalar(mexIsGlobal(prhs[0]));';
+        '}'],'mexisGlobal.c');
+ilib_mex_build('libmextest', ['isGlobal', 'mexisGlobal', 'cmex'], 'mexisGlobal.c', [], 'Makelib', '', '', '');
+exec('loader.sce');
+
+global globalvar;
+globalvar = 1;
+localvar = "s";
+if isGlobal(globalvar) <> %t then pause end
+if isGlobal(localvar) <> %f then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexIsGlobal.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexIsGlobal.win.dia.ref
new file mode 100644 (file)
index 0000000..e3b9454
--- /dev/null
@@ -0,0 +1,54 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexIsGlobal mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    plhs[0] = mxCreateLogicalScalar(mexIsGlobal(prhs[0]));';
+        '}'],'mexisGlobal.c');
+
+ilib_mex_build('libmextest', ['isGlobal', 'mexisGlobal', 'cmex'], 'mexisGlobal.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexisGlobal.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+global globalvar;
+
+globalvar = 1;
+
+localvar = "s";
+
+if isGlobal(globalvar) <> %t then pause end
+
+if isGlobal(localvar) <> %f then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexPrintf.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexPrintf.linux.dia.ref
new file mode 100644 (file)
index 0000000..f8b7101
--- /dev/null
@@ -0,0 +1,53 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexIsGlobal mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    mexPrintf(""The quick brown fox jumps over the lazy dog.\n"");';
+        '    mexPrintf(""Some UTF-8 chars are áãâéíóúü.\n"");';
+        '    mexPrintf(""Printing %s %s."", ""with"", ""parameters"");';
+        '}'],'mexprintf.c');
+
+ilib_mex_build('libmextest', ['mprintf', 'mexprintf', 'cmex'], 'mexprintf.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 mexprintf.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+mprintf();
+The quick brown fox jumps over the lazy dog.
+Some UTF-8 chars are áãâéíóúü.
+Printing with parameters.
\ No newline at end of file
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexPrintf.tst b/scilab/modules/mexlib/tests/unit_tests/mexPrintf.tst
new file mode 100644 (file)
index 0000000..e506824
--- /dev/null
@@ -0,0 +1,25 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mexIsGlobal mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    mexPrintf(""The quick brown fox jumps over the lazy dog.\n"");';
+        '    mexPrintf(""Some UTF-8 chars are áãâéíóúü.\n"");';
+        '    mexPrintf(""Printing %s %s."", ""with"", ""parameters"");';
+        '}'],'mexprintf.c');
+ilib_mex_build('libmextest', ['mprintf', 'mexprintf', 'cmex'], 'mexprintf.c', [], 'Makelib', '', '', '');
+exec('loader.sce');
+
+mprintf();
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexPrintf.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexPrintf.win.dia.ref
new file mode 100644 (file)
index 0000000..4b8385f
--- /dev/null
@@ -0,0 +1,50 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexIsGlobal mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    mexPrintf(""The quick brown fox jumps over the lazy dog.\n"");';
+        '    mexPrintf(""Some UTF-8 chars are áãâéíóúü.\n"");';
+        '    mexPrintf(""Printing %s %s."", ""with"", ""parameters"");';
+        '}'],'mexprintf.c');
+
+ilib_mex_build('libmextest', ['mprintf', 'mexprintf', 'cmex'], 'mexprintf.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexprintf.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+mprintf();
+The quick brown fox jumps over the lazy dog.
+Some UTF-8 chars are áãâéíóúü.
+Printing with parameters.
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexPutVariable.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexPutVariable.linux.dia.ref
new file mode 100644 (file)
index 0000000..ecca3d5
--- /dev/null
@@ -0,0 +1,66 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexPutVariable mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *workspace = mxArrayToString(prhs[0]);';
+        '    char *name = mxArrayToString(prhs[1]);';
+        '    mxArray *pOut = mexPutVariable(workspace, name, prhs[2]);';
+        '}'],'mexputVariable.c');
+ilib_mex_build('libmextest', ['putVariable', 'mexputVariable', 'cmex'], 'mexputVariable.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 mexputVariable.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+global globalvar;
+
+putVariable("global", "globalvar", 32);
+
+if globalvar <> 32 then pause end
+
+if isglobal('globalvar') <> %t then pause end
+
+othervar = 1;
+
+putVariable("base", "othervar", 3);
+
+if othervar <> 3 then pause end
+
+if isglobal('othervar') <> %f then pause end
+
+putVariable("caller", "defined_in_C", 0);
+
+if exists('defined_in_C') <> 1 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexPutVariable.tst b/scilab/modules/mexlib/tests/unit_tests/mexPutVariable.tst
new file mode 100644 (file)
index 0000000..23935d3
--- /dev/null
@@ -0,0 +1,37 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mexPutVariable mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *workspace = mxArrayToString(prhs[0]);';
+        '    char *name = mxArrayToString(prhs[1]);';
+        '    mxArray *pOut = mexPutVariable(workspace, name, prhs[2]);';
+        '}'],'mexputVariable.c');
+ilib_mex_build('libmextest', ['putVariable', 'mexputVariable', 'cmex'], 'mexputVariable.c', [], 'Makelib', '', '', '');
+exec('loader.sce');
+
+global globalvar;
+putVariable("global", "globalvar", 32);
+if globalvar <> 32 then pause end
+if isglobal('globalvar') <> %t then pause end
+
+othervar = 1;
+putVariable("base", "othervar", 3);
+if othervar <> 3 then pause end
+if isglobal('othervar') <> %f then pause end
+
+putVariable("caller", "defined_in_C", 0);
+if exists('defined_in_C') <> 1 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexPutVariable.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexPutVariable.win.dia.ref
new file mode 100644 (file)
index 0000000..a8bd130
--- /dev/null
@@ -0,0 +1,66 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mexPutVariable mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *workspace = mxArrayToString(prhs[0]);';
+        '    char *name = mxArrayToString(prhs[1]);';
+        '    mxArray *pOut = mexPutVariable(workspace, name, prhs[2]);';
+        '}'],'mexputVariable.c');
+
+ilib_mex_build('libmextest', ['putVariable', 'mexputVariable', 'cmex'], 'mexputVariable.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexputVariable.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+global globalvar;
+
+putVariable("global", "globalvar", 32);
+
+if globalvar <> 32 then pause end
+
+if isglobal('globalvar') <> %t then pause end
+
+othervar = 1;
+
+putVariable("base", "othervar", 3);
+
+if othervar <> 3 then pause end
+
+if isglobal('othervar') <> %f then pause end
+
+putVariable("caller", "defined_in_C", 0);
+
+if exists('defined_in_C') <> 1 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxAddField.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxAddField.linux.dia.ref
new file mode 100644 (file)
index 0000000..53fadd3
--- /dev/null
@@ -0,0 +1,52 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxAddField mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    mxArray *ptr = prhs[0];'
+        '    int fieldnumber = mxAddField(ptr, ""another"");';
+        '    mxSetFieldByNumber(ptr, 0, fieldnumber, mxCreateDoubleScalar(3));';
+        '}'],'mexaddField.c');
+ilib_mex_build('libmextest', ['addField', 'mexaddField', 'cmex'], 'mexaddField.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 mexaddField.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+s = struct();
+
+addField(s);
+
+if s("another") <> 3 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxAddField.tst b/scilab/modules/mexlib/tests/unit_tests/mxAddField.tst
new file mode 100644 (file)
index 0000000..7a5b12d
--- /dev/null
@@ -0,0 +1,27 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxAddField mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    mxArray *ptr = prhs[0];'
+        '    int fieldnumber = mxAddField(ptr, ""another"");';
+        '    mxSetFieldByNumber(ptr, 0, fieldnumber, mxCreateDoubleScalar(3));';
+        '}'],'mexaddField.c');
+ilib_mex_build('libmextest', ['addField', 'mexaddField', 'cmex'], 'mexaddField.c', [], 'Makelib', '', '', '');
+exec('loader.sce');
+
+s = struct();
+addField(s);
+if s("another") <> 3 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxAddField.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxAddField.win.dia.ref
new file mode 100644 (file)
index 0000000..47b728e
--- /dev/null
@@ -0,0 +1,52 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxAddField mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    mxArray *ptr = prhs[0];'
+        '    int fieldnumber = mxAddField(ptr, ""another"");';
+        '    mxSetFieldByNumber(ptr, 0, fieldnumber, mxCreateDoubleScalar(3));';
+        '}'],'mexaddField.c');
+
+ilib_mex_build('libmextest', ['addField', 'mexaddField', 'cmex'], 'mexaddField.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexaddField.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+s = struct();
+
+addField(s);
+
+if s("another") <> 3 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxArrayToString.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxArrayToString.linux.dia.ref
new file mode 100644 (file)
index 0000000..5ea7f08
--- /dev/null
@@ -0,0 +1,49 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxArrayToString mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *str = mxArrayToString(prhs[0]);';
+        '    mexPrintf(""%s"", str);';
+        '}'],'mexArrayToString.c');
+ilib_mex_build('libmextest', ['arrayToString', 'mexArrayToString', 'cmex'], 'mexArrayToString.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 mexArrayToString.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+arrayToString("hello world");
+hello world
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxArrayToString.tst b/scilab/modules/mexlib/tests/unit_tests/mxArrayToString.tst
new file mode 100644 (file)
index 0000000..f3bc99b
--- /dev/null
@@ -0,0 +1,24 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxArrayToString mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *str = mxArrayToString(prhs[0]);';
+        '    mexPrintf(""%s"", str);';
+        '}'],'mexArrayToString.c');
+ilib_mex_build('libmextest', ['arrayToString', 'mexArrayToString', 'cmex'], 'mexArrayToString.c', [], 'Makelib', '', '', '');
+exec('loader.sce');
+
+arrayToString("hello world");
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxArrayToString.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxArrayToString.win.dia.ref
new file mode 100644 (file)
index 0000000..e019c05
--- /dev/null
@@ -0,0 +1,47 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxArrayToString mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    char *str = mxArrayToString(prhs[0]);';
+        '    mexPrintf(""%s"", str);';
+        '}'],'mexArrayToString.c');
+
+ilib_mex_build('libmextest', ['arrayToString', 'mexArrayToString', 'cmex'], 'mexArrayToString.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexArrayToString.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+arrayToString("hello world");
+hello world
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxAssert.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxAssert.linux.dia.ref
new file mode 100644 (file)
index 0000000..52e09cd
--- /dev/null
@@ -0,0 +1,50 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxAssert mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxAssert(mxGetScalar(prhs[0]), mxGetChars(prhs[1]));';
+       '}'],'mexAssert.c');
+ilib_mex_build('libmextest',['assert','mexAssert','cmex'], 'mexAssert.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 mexAssert.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+assert(1, 'This is true');
+
+assert(0, 'This is false and throws an exception.');
+Assertion Error: This is false and throws an exception.
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxAssert.tst b/scilab/modules/mexlib/tests/unit_tests/mxAssert.tst
new file mode 100644 (file)
index 0000000..7e55c68
--- /dev/null
@@ -0,0 +1,26 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// <-- INTERACTIVE TEST -->
+// ============================================================================
+// Unitary tests for mxAssert mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxAssert(mxGetScalar(prhs[0]), mxGetChars(prhs[1]));';
+       '}'],'mexAssert.c');
+ilib_mex_build('libmextest',['assert','mexAssert','cmex'], 'mexAssert.c',[],'Makelib','','-D NDEBUG','');
+exec('loader.sce');
+
+assert(1, 'This is true');
+assert(0, 'This is false and throws an exception.');
+assert(1, 'This assert is never executed');
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCalcSingleSubscript.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCalcSingleSubscript.linux.dia.ref
new file mode 100644 (file)
index 0000000..7c9f3c6
--- /dev/null
@@ -0,0 +1,82 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCalcSingleSubscript mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    int *dims = mxGetData(prhs[2]);';
+        '    int ndim = mxGetScalar(prhs[1]);';
+        '    plhs[0] = mxCreateDoubleScalar(mxCalcSingleSubscript(prhs[0], ndim, dims));';
+        '}'],'mexcalcSingleSubscript.c');
+ilib_mex_build('libmextest', ['calcSingleSubscript', 'mexcalcSingleSubscript', 'cmex'], 'mexcalcSingleSubscript.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 mexcalcSingleSubscript.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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 = zeros(3, 3);
+
+r = calcSingleSubscript(a, 2, int32([0 0]));
+
+if r <> 0 then pause end
+
+r = calcSingleSubscript(a, 2, int32([1 1]));
+
+if r <> 4 then pause end
+
+r = calcSingleSubscript(a, 2, int32([2 2]));
+
+if r <> 8 then pause end
+
+b = zeros(4, 2, 3);
+
+r = calcSingleSubscript(b, 3, int32([0 0 0]));
+
+if r <> 0 then pause end
+
+r = calcSingleSubscript(b, 2, int32([0 0]));
+
+if r <> 0 then pause end
+
+r = calcSingleSubscript(b, 3, int32([3 0 2]));
+
+if r <> 19 then pause end
+
+r = calcSingleSubscript(b, 3, int32([1 1 1]));
+
+if r <> 13 then pause end
+
+r = calcSingleSubscript(b, 3, int32([3 1 2]));
+
+if r <> 23 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCalcSingleSubscript.tst b/scilab/modules/mexlib/tests/unit_tests/mxCalcSingleSubscript.tst
new file mode 100644 (file)
index 0000000..86d7fb6
--- /dev/null
@@ -0,0 +1,43 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxCalcSingleSubscript mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    int *dims = mxGetData(prhs[2]);';
+        '    int ndim = mxGetScalar(prhs[1]);';
+        '    plhs[0] = mxCreateDoubleScalar(mxCalcSingleSubscript(prhs[0], ndim, dims));';
+        '}'],'mexcalcSingleSubscript.c');
+ilib_mex_build('libmextest', ['calcSingleSubscript', 'mexcalcSingleSubscript', 'cmex'], 'mexcalcSingleSubscript.c', [], 'Makelib', '', '', '');
+exec('loader.sce');
+
+a = zeros(3, 3);
+r = calcSingleSubscript(a, 2, int32([0 0]));
+if r <> 0 then pause end
+r = calcSingleSubscript(a, 2, int32([1 1]));
+if r <> 4 then pause end
+r = calcSingleSubscript(a, 2, int32([2 2]));
+if r <> 8 then pause end
+
+b = zeros(4, 2, 3);
+r = calcSingleSubscript(b, 3, int32([0 0 0]));
+if r <> 0 then pause end
+r = calcSingleSubscript(b, 2, int32([0 0]));
+if r <> 0 then pause end
+r = calcSingleSubscript(b, 3, int32([3 0 2]));
+if r <> 19 then pause end
+r = calcSingleSubscript(b, 3, int32([1 1 1]));
+if r <> 13 then pause end
+r = calcSingleSubscript(b, 3, int32([3 1 2]));
+if r <> 23 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCalcSingleSubscript.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCalcSingleSubscript.win.dia.ref
new file mode 100644 (file)
index 0000000..78f9021
--- /dev/null
@@ -0,0 +1,82 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCalcSingleSubscript mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '    int *dims = mxGetData(prhs[2]);';
+        '    int ndim = mxGetScalar(prhs[1]);';
+        '    plhs[0] = mxCreateDoubleScalar(mxCalcSingleSubscript(prhs[0], ndim, dims));';
+        '}'],'mexcalcSingleSubscript.c');
+
+ilib_mex_build('libmextest', ['calcSingleSubscript', 'mexcalcSingleSubscript', 'cmex'], 'mexcalcSingleSubscript.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexcalcSingleSubscript.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = zeros(3, 3);
+
+r = calcSingleSubscript(a, 2, int32([0 0]));
+
+if r <> 0 then pause end
+
+r = calcSingleSubscript(a, 2, int32([1 1]));
+
+if r <> 4 then pause end
+
+r = calcSingleSubscript(a, 2, int32([2 2]));
+
+if r <> 8 then pause end
+
+b = zeros(4, 2, 3);
+
+r = calcSingleSubscript(b, 3, int32([0 0 0]));
+
+if r <> 0 then pause end
+
+r = calcSingleSubscript(b, 2, int32([0 0]));
+
+if r <> 0 then pause end
+
+r = calcSingleSubscript(b, 3, int32([3 0 2]));
+
+if r <> 19 then pause end
+
+r = calcSingleSubscript(b, 3, int32([1 1 1]));
+
+if r <> 13 then pause end
+
+r = calcSingleSubscript(b, 3, int32([3 1 2]));
+
+if r <> 23 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCheckTypes.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCheckTypes.linux.dia.ref
new file mode 100644 (file)
index 0000000..54f7f8d
--- /dev/null
@@ -0,0 +1,125 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxIsCell, mxIsChar, mxIsDouble, mxIsFunction,
+
+// mxIsInt8, mxIsInt16, mxIsInt32, mxIsInt64,
+
+// mxIsUint8, mxIsUint16, mxIsUint32, mxIsUint64,
+
+// mxIsLogical, mxIsStruct and mxIsSingle mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    if (mxIsCell(prhs[0])) {';
+       '        mexPrintf(""cell"");';
+       '    }'
+       '    if (mxIsChar(prhs[0])) {';
+       '        mexPrintf(""char"");';
+       '    }'
+       '    if (mxIsDouble(prhs[0])) {';
+       '        mexPrintf(""double"");';
+       '    }'
+       '    if (mxIsFunction(prhs[0])) {';
+       '        mexPrintf(""function_handle"");';
+       '    }'
+       '    if (mxIsInt8(prhs[0])) {';
+       '        mexPrintf(""int8"");';
+       '    }'
+       '    if (mxIsInt16(prhs[0])) {';
+       '        mexPrintf(""int16"");';
+       '    }'
+       '    if (mxIsInt32(prhs[0])) {';
+       '        mexPrintf(""int32"");';
+       '    }'
+       '    if (mxIsInt64(prhs[0])) {';
+       '        mexPrintf(""int64"");';
+       '    }'
+       '    if (mxIsLogical(prhs[0])) {';
+       '        mexPrintf(""logical"");';
+       '    }'
+       '    if (mxIsSingle(prhs[0])) {';
+       '        mexPrintf(""single"");';
+       '    }'
+       '    if (mxIsStruct(prhs[0])) {';
+       '        mexPrintf(""struct"");';
+       '    }'
+       '    if (mxIsUint8(prhs[0])) {';
+       '        mexPrintf(""uint8"");';
+       '    }'
+       '    if (mxIsUint16(prhs[0])) {';
+       '        mexPrintf(""uint16"");';
+       '    }'
+       '    if (mxIsUint32(prhs[0])) {';
+       '        mexPrintf(""uint32"");';
+       '    }'
+       '    if (mxIsUint64(prhs[0])) {';
+       '        mexPrintf(""uint64"");';
+       '    }'
+       '}'],'mexcheckTypes.c');
+
+ilib_mex_build('libmextest',['printClass','mexcheckTypes','cmex'], 'mexcheckTypes.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 mexcheckTypes.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+printClass(cell());
+cell
+printClass('s');
+char
+printClass(1);
+double
+printClass(sum);
+function_handle
+printClass(int8(1));
+int8
+printClass(int16(1));
+int16
+printClass(int32(1));
+int32
+printClass(int64(1));
+int64
+printClass(%t);
+logical
+printClass(struct());
+struct
+printClass(uint8(1));
+uint8
+printClass(uint16(1));
+uint16
+printClass(uint32(1));
+uint32
+printClass(uint64(1));
+uint64
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCheckTypes.tst b/scilab/modules/mexlib/tests/unit_tests/mxCheckTypes.tst
new file mode 100644 (file)
index 0000000..f0f6b58
--- /dev/null
@@ -0,0 +1,85 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxIsCell, mxIsChar, mxIsDouble, mxIsFunction,
+// mxIsInt8, mxIsInt16, mxIsInt32, mxIsInt64,
+// mxIsUint8, mxIsUint16, mxIsUint32, mxIsUint64,
+// mxIsLogical, mxIsStruct and mxIsSingle mex function
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    if (mxIsCell(prhs[0])) {';
+       '        mexPrintf(""cell"");';
+       '    }'
+       '    if (mxIsChar(prhs[0])) {';
+       '        mexPrintf(""char"");';
+       '    }'
+       '    if (mxIsDouble(prhs[0])) {';
+       '        mexPrintf(""double"");';
+       '    }'
+       '    if (mxIsFunction(prhs[0])) {';
+       '        mexPrintf(""function_handle"");';
+       '    }'
+       '    if (mxIsInt8(prhs[0])) {';
+       '        mexPrintf(""int8"");';
+       '    }'
+       '    if (mxIsInt16(prhs[0])) {';
+       '        mexPrintf(""int16"");';
+       '    }'
+       '    if (mxIsInt32(prhs[0])) {';
+       '        mexPrintf(""int32"");';
+       '    }'
+       '    if (mxIsInt64(prhs[0])) {';
+       '        mexPrintf(""int64"");';
+       '    }'
+       '    if (mxIsLogical(prhs[0])) {';
+       '        mexPrintf(""logical"");';
+       '    }'
+       '    if (mxIsSingle(prhs[0])) {';
+       '        mexPrintf(""single"");';
+       '    }'
+       '    if (mxIsStruct(prhs[0])) {';
+       '        mexPrintf(""struct"");';
+       '    }'
+       '    if (mxIsUint8(prhs[0])) {';
+       '        mexPrintf(""uint8"");';
+       '    }'
+       '    if (mxIsUint16(prhs[0])) {';
+       '        mexPrintf(""uint16"");';
+       '    }'
+       '    if (mxIsUint32(prhs[0])) {';
+       '        mexPrintf(""uint32"");';
+       '    }'
+       '    if (mxIsUint64(prhs[0])) {';
+       '        mexPrintf(""uint64"");';
+       '    }'
+       '}'],'mexcheckTypes.c');
+
+ilib_mex_build('libmextest',['printClass','mexcheckTypes','cmex'], 'mexcheckTypes.c',[],'Makelib','','','');
+exec('loader.sce');
+
+printClass(cell());
+printClass('s');
+printClass(1);
+printClass(sum);
+printClass(int8(1));
+printClass(int16(1));
+printClass(int32(1));
+printClass(int64(1));
+printClass(%t);
+printClass(struct());
+printClass(uint8(1));
+printClass(uint16(1));
+printClass(uint32(1));
+printClass(uint64(1));
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCheckTypes.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCheckTypes.win.dia.ref
new file mode 100644 (file)
index 0000000..7098741
--- /dev/null
@@ -0,0 +1,122 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxIsCell, mxIsChar, mxIsDouble, mxIsFunction,
+
+// mxIsInt8, mxIsInt16, mxIsInt32, mxIsInt64,
+
+// mxIsUint8, mxIsUint16, mxIsUint32, mxIsUint64,
+
+// mxIsLogical, mxIsStruct and mxIsSingle mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    if (mxIsCell(prhs[0])) {';
+       '        mexPrintf(""cell"");';
+       '    }'
+       '    if (mxIsChar(prhs[0])) {';
+       '        mexPrintf(""char"");';
+       '    }'
+       '    if (mxIsDouble(prhs[0])) {';
+       '        mexPrintf(""double"");';
+       '    }'
+       '    if (mxIsFunction(prhs[0])) {';
+       '        mexPrintf(""function_handle"");';
+       '    }'
+       '    if (mxIsInt8(prhs[0])) {';
+       '        mexPrintf(""int8"");';
+       '    }'
+       '    if (mxIsInt16(prhs[0])) {';
+       '        mexPrintf(""int16"");';
+       '    }'
+       '    if (mxIsInt32(prhs[0])) {';
+       '        mexPrintf(""int32"");';
+       '    }'
+       '    if (mxIsInt64(prhs[0])) {';
+       '        mexPrintf(""int64"");';
+       '    }'
+       '    if (mxIsLogical(prhs[0])) {';
+       '        mexPrintf(""logical"");';
+       '    }'
+       '    if (mxIsSingle(prhs[0])) {';
+       '        mexPrintf(""single"");';
+       '    }'
+       '    if (mxIsStruct(prhs[0])) {';
+       '        mexPrintf(""struct"");';
+       '    }'
+       '    if (mxIsUint8(prhs[0])) {';
+       '        mexPrintf(""uint8"");';
+       '    }'
+       '    if (mxIsUint16(prhs[0])) {';
+       '        mexPrintf(""uint16"");';
+       '    }'
+       '    if (mxIsUint32(prhs[0])) {';
+       '        mexPrintf(""uint32"");';
+       '    }'
+       '    if (mxIsUint64(prhs[0])) {';
+       '        mexPrintf(""uint64"");';
+       '    }'
+       '}'],'mexcheckTypes.c');
+
+ilib_mex_build('libmextest',['printClass','mexcheckTypes','cmex'], 'mexcheckTypes.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexcheckTypes.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+printClass(cell());
+cell
+printClass('s');
+char
+printClass(1);
+double
+printClass(sum);
+function_handle
+printClass(int8(1));
+int8
+printClass(int16(1));
+int16
+printClass(int32(1));
+int32
+printClass(int64(1));
+int64
+printClass(%t);
+logical
+printClass(struct());
+struct
+printClass(uint8(1));
+uint8
+printClass(uint16(1));
+uint16
+printClass(uint32(1));
+uint32
+printClass(uint64(1));
+uint64
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateCell.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateCell.linux.dia.ref
new file mode 100644 (file)
index 0000000..65dbba7
--- /dev/null
@@ -0,0 +1,63 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateCellArray and mxCreateCellMatrix mex functions
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxArray *pOut1 = mxCreateCellMatrix(2, 2);';
+       '    int dims[2] = {3, 3};';
+       '    mxArray *pOut2 = mxCreateCellArray(2, dims);';
+       '    plhs[0] = pOut1;';
+       '    plhs[1] = pOut2;';
+       '}'],'mexCreateCell.c');
+ilib_mex_build('libmextest',['createCell','mexCreateCell','cmex'], 'mexCreateCell.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 mexCreateCell.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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] = createCell()
+
+out2  =
+
+  [0x0 constant]  [0x0 constant]  [0x0 constant]
+  [0x0 constant]  [0x0 constant]  [0x0 constant]
+  [0x0 constant]  [0x0 constant]  [0x0 constant]
+
+out1  =
+
+  [0x0 constant]  [0x0 constant]
+  [0x0 constant]  [0x0 constant]
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateCell.tst b/scilab/modules/mexlib/tests/unit_tests/mxCreateCell.tst
new file mode 100644 (file)
index 0000000..f5f30e9
--- /dev/null
@@ -0,0 +1,29 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxCreateCellArray and mxCreateCellMatrix mex functions
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxArray *pOut1 = mxCreateCellMatrix(2, 2);';
+       '    int dims[2] = {3, 3};';
+       '    mxArray *pOut2 = mxCreateCellArray(2, dims);';
+       '    plhs[0] = pOut1;';
+       '    plhs[1] = pOut2;';
+       '}'],'mexCreateCell.c');
+ilib_mex_build('libmextest',['createCell','mexCreateCell','cmex'], 'mexCreateCell.c',[],'Makelib','','','');
+exec('loader.sce');
+
+[out1, out2] = createCell()
+if size(out1) <> [2, 2] then pause end;
+if size(out2) <> [3, 3] then pause end;
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateCell.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateCell.win.dia.ref
new file mode 100644 (file)
index 0000000..4e287f8
--- /dev/null
@@ -0,0 +1,65 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateCellArray and mxCreateCellMatrix mex functions
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxArray *pOut1 = mxCreateCellMatrix(2, 2);';
+       '    int dims[2] = {3, 3};';
+       '    mxArray *pOut2 = mxCreateCellArray(2, dims);';
+       '    plhs[0] = pOut1;';
+       '    plhs[1] = pOut2;';
+       '}'],'mexCreateCell.c');
+
+ilib_mex_build('libmextest',['createCell','mexCreateCell','cmex'], 'mexCreateCell.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexCreateCell.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+[out1, out2] = createCell()
+out2  = 
+
+  [0x0 constant]  [0x0 constant]  [0x0 constant]
+  [0x0 constant]  [0x0 constant]  [0x0 constant]
+  [0x0 constant]  [0x0 constant]  [0x0 constant]
+
+out1  = 
+
+  [0x0 constant]  [0x0 constant]
+  [0x0 constant]  [0x0 constant]
+
+
+if size(out1) <> [2, 2] then pause end;
+
+if size(out2) <> [3, 3] then pause end;
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalArray.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalArray.linux.dia.ref
new file mode 100644 (file)
index 0000000..0a33788
--- /dev/null
@@ -0,0 +1,54 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateLogicalArray mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int ndim = (int) mxGetScalar(prhs[0]);';
+        '   int *dims = (int *) mxGetData(prhs[1]);';
+        '   plhs[0] = mxCreateLogicalArray(ndim, dims);';
+        '}'],'mexCreateLogicalArray.c');
+ilib_mex_build('libmextest',['createLogicalArray', 'mexCreateLogicalArray', 'cmex'], 'mexCreateLogicalArray.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 mexCreateLogicalArray.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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 = createLogicalArray(4, int32([2 2 2 2]));
+
+if size(a, "*") <> 16 then pause end
+
+if typeof(a) <> "boolean" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalArray.tst b/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalArray.tst
new file mode 100644 (file)
index 0000000..388799e
--- /dev/null
@@ -0,0 +1,28 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxCreateLogicalArray mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int ndim = (int) mxGetScalar(prhs[0]);';
+        '   int *dims = (int *) mxGetData(prhs[1]);';
+        '   plhs[0] = mxCreateLogicalArray(ndim, dims);';
+        '}'],'mexCreateLogicalArray.c');
+ilib_mex_build('libmextest',['createLogicalArray', 'mexCreateLogicalArray', 'cmex'], 'mexCreateLogicalArray.c', [], 'Makelib', '', '', '');
+exec('loader.sce');
+
+a = createLogicalArray(4, int32([2 2 2 2]));
+if size(a, "*") <> 16 then pause end
+if typeof(a) <> "boolean" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalArray.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalArray.win.dia.ref
new file mode 100644 (file)
index 0000000..039ddd5
--- /dev/null
@@ -0,0 +1,53 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateLogicalArray mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl([ '#include ""mex.h""';
+        '';
+        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+        '{';
+        '   int ndim = (int) mxGetScalar(prhs[0]);';
+        '   int *dims = (int *) mxGetData(prhs[1]);';
+        '   plhs[0] = mxCreateLogicalArray(ndim, dims);';
+        '}'],'mexCreateLogicalArray.c');
+
+ilib_mex_build('libmextest',['createLogicalArray', 'mexCreateLogicalArray', 'cmex'], 'mexCreateLogicalArray.c', [], 'Makelib', '', '', '');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexCreateLogicalArray.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = createLogicalArray(4, int32([2 2 2 2]));
+
+if size(a, "*") <> 16 then pause end
+
+if typeof(a) <> "boolean" then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateStruct.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateStruct.linux.dia.ref
new file mode 100644 (file)
index 0000000..22d5e1b
--- /dev/null
@@ -0,0 +1,56 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateStructMatrix and mxCreateStructArray mex functions
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int dims[2] = {3, 3};';
+       '    char *fields[2];';
+       '    fields[0] = ""f1"";';
+       '    fields[1] = ""f2"";';
+       '    plhs[0] = mxCreateStructArray(2, dims, 2, fields);';
+       '    plhs[1] = mxCreateStructMatrix(2, 2, 2, fields);';
+       '}'],'mexcreateStruct.c');
+ilib_mex_build('libmextest',['createStruct','mexcreateStruct','cmex'], 'mexcreateStruct.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 mexcreateStruct.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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] = createStruct();
+
+if size(out1, "*") <> 9 then pause end
+
+if size(out2, "*") <> 4 then pause end
\ No newline at end of file
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateStruct.tst b/scilab/modules/mexlib/tests/unit_tests/mxCreateStruct.tst
new file mode 100644 (file)
index 0000000..8b4ca8e
--- /dev/null
@@ -0,0 +1,33 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxCreateStructMatrix and mxCreateStructArray mex functions
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int dims[2] = {3, 3};';
+       '    char *fields[2];';
+       '    fields[0] = ""f1"";';
+       '    fields[1] = ""f2"";';
+       '    plhs[0] = mxCreateStructArray(2, dims, 2, fields);';
+       '    plhs[1] = mxCreateStructMatrix(2, 2, 2, fields);';
+       '}'],'mexcreateStruct.c');
+ilib_mex_build('libmextest',['createStruct','mexcreateStruct','cmex'], 'mexcreateStruct.c',[],'Makelib','','','');
+exec('loader.sce');
+
+[out1, out2] = createStruct();
+
+if size(out1, "*") <> 9 then pause end
+
+if size(out2, "*") <> 4 then pause end
\ No newline at end of file
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxCreateStruct.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxCreateStruct.win.dia.ref
new file mode 100644 (file)
index 0000000..319d066
--- /dev/null
@@ -0,0 +1,55 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxCreateStructMatrix and mxCreateStructArray mex functions
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int dims[2] = {3, 3};';
+       '    char *fields[2];';
+       '    fields[0] = ""f1"";';
+       '    fields[1] = ""f2"";';
+       '    plhs[0] = mxCreateStructArray(2, dims, 2, fields);';
+       '    plhs[1] = mxCreateStructMatrix(2, 2, 2, fields);';
+       '}'],'mexcreateStruct.c');
+
+ilib_mex_build('libmextest',['createStruct','mexcreateStruct','cmex'], 'mexcreateStruct.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexcreateStruct.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+[out1, out2] = createStruct();
+
+if size(out1, "*") <> 9 then pause end
+
+if size(out2, "*") <> 4 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetChars.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetChars.linux.dia.ref
new file mode 100644 (file)
index 0000000..05c8e21
--- /dev/null
@@ -0,0 +1,50 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetChars mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    char *chars = mxGetChars(prhs[0]);';
+       '    plhs[0] = mxCreateString(chars);';
+       '}'],'mexgetChars.c');
+ilib_mex_build('libmextest',['getChars','mexgetChars','cmex'], 'mexgetChars.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 mexgetChars.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+r = getChars("hello world");
+
+if r <> "hello world" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetChars.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetChars.tst
new file mode 100644 (file)
index 0000000..a2e5b20
--- /dev/null
@@ -0,0 +1,25 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetChars mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    char *chars = mxGetChars(prhs[0]);';
+       '    plhs[0] = mxCreateString(chars);';
+       '}'],'mexgetChars.c');
+ilib_mex_build('libmextest',['getChars','mexgetChars','cmex'], 'mexgetChars.c',[],'Makelib','','','');
+exec('loader.sce');
+
+r = getChars("hello world");
+if r <> "hello world" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetChars.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetChars.win.dia.ref
new file mode 100644 (file)
index 0000000..6ff48fc
--- /dev/null
@@ -0,0 +1,49 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetChars mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    char *chars = mxGetChars(prhs[0]);';
+       '    plhs[0] = mxCreateString(chars);';
+       '}'],'mexgetChars.c');
+
+ilib_mex_build('libmextest',['getChars','mexgetChars','cmex'], 'mexgetChars.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetChars.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+r = getChars("hello world");
+
+if r <> "hello world" then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetClassID.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetClassID.linux.dia.ref
new file mode 100644 (file)
index 0000000..fb1f92d
--- /dev/null
@@ -0,0 +1,119 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetClassID mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    if (mxGetClassID(prhs[0]) == mxCELL_CLASS) {';
+       '        mexPrintf(""cell"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxCHAR_CLASS) {';
+       '        mexPrintf(""char"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxDOUBLE_CLASS) {';
+       '        mexPrintf(""double"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxFUNCTION_CLASS) {';
+       '        mexPrintf(""function_handle"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxINT8_CLASS) {';
+       '        mexPrintf(""int8"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxINT16_CLASS) {';
+       '        mexPrintf(""int16"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxINT32_CLASS) {';
+       '        mexPrintf(""int32"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxINT64_CLASS) {';
+       '        mexPrintf(""int64"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxLOGICAL_CLASS) {';
+       '        mexPrintf(""logical"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxSINGLE_CLASS) {';
+       '        mexPrintf(""single"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxSTRUCT_CLASS) {';
+       '        mexPrintf(""struct"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxUINT8_CLASS) {';
+       '        mexPrintf(""uint8"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxUINT16_CLASS) {';
+       '        mexPrintf(""uint16"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxUINT32_CLASS) {';
+       '        mexPrintf(""uint32"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxUINT64_CLASS) {';
+       '        mexPrintf(""uint64"");';
+       '    }'
+       '}'],'mexgetClassID.c');
+
+ilib_mex_build('libmextest',['printClass','mexgetClassID','cmex'], 'mexgetClassID.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 mexgetClassID.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+printClass(cell());
+cell
+printClass('s');
+char
+printClass(1);
+double
+printClass(sum);
+function_handle
+printClass(int8(1));
+int8
+printClass(int16(1));
+int16
+printClass(int32(1));
+int32
+printClass(int64(1));
+int64
+printClass(%t);
+logical
+printClass(struct());
+struct
+printClass(uint8(1));
+uint8
+printClass(uint16(1));
+uint16
+printClass(uint32(1));
+uint32
+printClass(uint64(1));
+uint64
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetClassID.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetClassID.tst
new file mode 100644 (file)
index 0000000..1f68856
--- /dev/null
@@ -0,0 +1,82 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetClassID mex function
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    if (mxGetClassID(prhs[0]) == mxCELL_CLASS) {';
+       '        mexPrintf(""cell"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxCHAR_CLASS) {';
+       '        mexPrintf(""char"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxDOUBLE_CLASS) {';
+       '        mexPrintf(""double"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxFUNCTION_CLASS) {';
+       '        mexPrintf(""function_handle"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxINT8_CLASS) {';
+       '        mexPrintf(""int8"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxINT16_CLASS) {';
+       '        mexPrintf(""int16"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxINT32_CLASS) {';
+       '        mexPrintf(""int32"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxINT64_CLASS) {';
+       '        mexPrintf(""int64"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxLOGICAL_CLASS) {';
+       '        mexPrintf(""logical"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxSINGLE_CLASS) {';
+       '        mexPrintf(""single"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxSTRUCT_CLASS) {';
+       '        mexPrintf(""struct"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxUINT8_CLASS) {';
+       '        mexPrintf(""uint8"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxUINT16_CLASS) {';
+       '        mexPrintf(""uint16"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxUINT32_CLASS) {';
+       '        mexPrintf(""uint32"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxUINT64_CLASS) {';
+       '        mexPrintf(""uint64"");';
+       '    }'
+       '}'],'mexgetClassID.c');
+
+ilib_mex_build('libmextest',['printClass','mexgetClassID','cmex'], 'mexgetClassID.c',[],'Makelib','','','');
+exec('loader.sce');
+
+printClass(cell());
+printClass('s');
+printClass(1);
+printClass(sum);
+printClass(int8(1));
+printClass(int16(1));
+printClass(int32(1));
+printClass(int64(1));
+printClass(%t);
+printClass(struct());
+printClass(uint8(1));
+printClass(uint16(1));
+printClass(uint32(1));
+printClass(uint64(1));
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetClassID.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetClassID.win.dia.ref
new file mode 100644 (file)
index 0000000..4216d3d
--- /dev/null
@@ -0,0 +1,116 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetClassID mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    if (mxGetClassID(prhs[0]) == mxCELL_CLASS) {';
+       '        mexPrintf(""cell"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxCHAR_CLASS) {';
+       '        mexPrintf(""char"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxDOUBLE_CLASS) {';
+       '        mexPrintf(""double"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxFUNCTION_CLASS) {';
+       '        mexPrintf(""function_handle"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxINT8_CLASS) {';
+       '        mexPrintf(""int8"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxINT16_CLASS) {';
+       '        mexPrintf(""int16"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxINT32_CLASS) {';
+       '        mexPrintf(""int32"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxINT64_CLASS) {';
+       '        mexPrintf(""int64"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxLOGICAL_CLASS) {';
+       '        mexPrintf(""logical"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxSINGLE_CLASS) {';
+       '        mexPrintf(""single"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxSTRUCT_CLASS) {';
+       '        mexPrintf(""struct"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxUINT8_CLASS) {';
+       '        mexPrintf(""uint8"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxUINT16_CLASS) {';
+       '        mexPrintf(""uint16"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxUINT32_CLASS) {';
+       '        mexPrintf(""uint32"");';
+       '    }'
+       '    if (mxGetClassID(prhs[0]) == mxUINT64_CLASS) {';
+       '        mexPrintf(""uint64"");';
+       '    }'
+       '}'],'mexgetClassID.c');
+
+ilib_mex_build('libmextest',['printClass','mexgetClassID','cmex'], 'mexgetClassID.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetClassID.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+printClass(cell());
+cell
+printClass('s');
+char
+printClass(1);
+double
+printClass(sum);
+function_handle
+printClass(int8(1));
+int8
+printClass(int16(1));
+int16
+printClass(int32(1));
+int32
+printClass(int64(1));
+int64
+printClass(%t);
+logical
+printClass(struct());
+struct
+printClass(uint8(1));
+uint8
+printClass(uint16(1));
+uint16
+printClass(uint32(1));
+uint32
+printClass(uint64(1));
+uint64
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetClassName.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetClassName.linux.dia.ref
new file mode 100644 (file)
index 0000000..83f310b
--- /dev/null
@@ -0,0 +1,75 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetClassName mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mexPrintf(mxGetClassName(prhs[0]));';
+       '}'],'mexgetClassName.c');
+
+ilib_mex_build('libmextest',['printClassName','mexgetClassName','cmex'], 'mexgetClassName.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 mexgetClassName.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+printClassName(cell());
+cell
+printClassName('s');
+char
+printClassName(1);
+double
+printClassName(sum);
+function_handle
+printClassName(int8(1));
+int8
+printClassName(int16(1));
+int16
+printClassName(int32(1));
+int32
+printClassName(int64(1));
+int64
+printClassName(%t);
+unknown
+printClassName(struct());
+struct
+printClassName(uint8(1));
+uint8
+printClassName(uint16(1));
+uint16
+printClassName(uint32(1));
+uint32
+printClassName(uint64(1));
+uint64
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetClassName.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetClassName.tst
new file mode 100644 (file)
index 0000000..8a58e00
--- /dev/null
@@ -0,0 +1,38 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetClassName mex function
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mexPrintf(mxGetClassName(prhs[0]));';
+       '}'],'mexgetClassName.c');
+
+ilib_mex_build('libmextest',['printClassName','mexgetClassName','cmex'], 'mexgetClassName.c',[],'Makelib','','','');
+exec('loader.sce');
+
+printClassName(cell());
+printClassName('s');
+printClassName(1);
+printClassName(sum);
+printClassName(int8(1));
+printClassName(int16(1));
+printClassName(int32(1));
+printClassName(int64(1));
+printClassName(%t);
+printClassName(struct());
+printClassName(uint8(1));
+printClassName(uint16(1));
+printClassName(uint32(1));
+printClassName(uint64(1));
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetClassName.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetClassName.win.dia.ref
new file mode 100644 (file)
index 0000000..8161e88
--- /dev/null
@@ -0,0 +1,72 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetClassName mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mexPrintf(mxGetClassName(prhs[0]));';
+       '}'],'mexgetClassName.c');
+
+ilib_mex_build('libmextest',['printClassName','mexgetClassName','cmex'], 'mexgetClassName.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetClassName.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+printClassName(cell());
+cell
+printClassName('s');
+char
+printClassName(1);
+double
+printClassName(sum);
+function_handle
+printClassName(int8(1));
+int8
+printClassName(int16(1));
+int16
+printClassName(int32(1));
+int32
+printClassName(int64(1));
+int64
+printClassName(%t);
+unknown
+printClassName(struct());
+struct
+printClassName(uint8(1));
+uint8
+printClassName(uint16(1));
+uint16
+printClassName(uint32(1));
+uint32
+printClassName(uint64(1));
+uint64
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetDimensions.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetDimensions.linux.dia.ref
new file mode 100644 (file)
index 0000000..3711135
--- /dev/null
@@ -0,0 +1,60 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetDimensions mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int ndim = mxGetNumberOfDimensions(prhs[0]);';
+       '    int *dims = mxGetDimensions(prhs[0]);';
+       '    mxArray *ptr = mxCreateNumericMatrix(1, ndim, mxINT32_CLASS, mxREAL);';
+       '    mxSetPr(ptr, dims);';
+       '    plhs[0] = ptr;';
+       '}'],'mexgetDimensions.c');
+
+ilib_mex_build('libmextest',['getDimensions','mexgetDimensions','cmex'], 'mexgetDimensions.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 mexgetDimensions.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+if getDimensions([1]) <> [1 1] then pause end
+
+if getDimensions([1 1 1]) <> [1 3] then pause end
+
+if getDimensions([1;1;1]) <> [3 1] then pause end
+
+if getDimensions([1 1;2 2;3 3]) <> [3 2] then pause end
+
+if getDimensions(zeros(4, 2, 3)) <> [4 2 3] then pause end
\ No newline at end of file
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetDimensions.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetDimensions.tst
new file mode 100644 (file)
index 0000000..f31d3b3
--- /dev/null
@@ -0,0 +1,31 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetDimensions mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int ndim = mxGetNumberOfDimensions(prhs[0]);';
+       '    int *dims = mxGetDimensions(prhs[0]);';
+       '    mxArray *ptr = mxCreateNumericMatrix(1, ndim, mxINT32_CLASS, mxREAL);';
+       '    mxSetPr(ptr, dims);';
+       '    plhs[0] = ptr;';
+       '}'],'mexgetDimensions.c');
+ilib_mex_build('libmextest',['getDimensions','mexgetDimensions','cmex'], 'mexgetDimensions.c',[],'Makelib','','','');
+exec('loader.sce');
+
+if getDimensions([1]) <> [1 1] then pause end
+if getDimensions([1 1 1]) <> [1 3] then pause end
+if getDimensions([1;1;1]) <> [3 1] then pause end
+if getDimensions([1 1;2 2;3 3]) <> [3 2] then pause end
+if getDimensions(zeros(4, 2, 3)) <> [4 2 3] then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetDimensions.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetDimensions.win.dia.ref
new file mode 100644 (file)
index 0000000..827ce71
--- /dev/null
@@ -0,0 +1,58 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetDimensions mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int ndim = mxGetNumberOfDimensions(prhs[0]);';
+       '    int *dims = mxGetDimensions(prhs[0]);';
+       '    mxArray *ptr = mxCreateNumericMatrix(1, ndim, mxINT32_CLASS, mxREAL);';
+       '    mxSetPr(ptr, dims);';
+       '    plhs[0] = ptr;';
+       '}'],'mexgetDimensions.c');
+
+ilib_mex_build('libmextest',['getDimensions','mexgetDimensions','cmex'], 'mexgetDimensions.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetDimensions.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+if getDimensions([1]) <> [1 1] then pause end
+
+if getDimensions([1 1 1]) <> [1 3] then pause end
+
+if getDimensions([1;1;1]) <> [3 1] then pause end
+
+if getDimensions([1 1;2 2;3 3]) <> [3 2] then pause end
+
+if getDimensions(zeros(4, 2, 3)) <> [4 2 3] then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetField.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetField.linux.dia.ref
new file mode 100644 (file)
index 0000000..857c31a
--- /dev/null
@@ -0,0 +1,63 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetField mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxArray *value = mxGetField(prhs[0], 0, ""a"");';
+       '    if (value == NULL) value = mxCreateDoubleScalar(-1);';
+       '    plhs[0] = value;';
+       '}'],'mexgetField.c');
+ilib_mex_build('libmextest',['getField','mexgetField','cmex'], 'mexgetField.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 mexgetField.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+c = struct("a", 5, "b", 2);
+
+r = getField(c);
+
+if r <> 5 then pause end
+
+c = struct("b", 32);
+
+r = getField(c);
+
+if r <> -1 then pause end
+
+r = getField(1);
+
+if r <> -1 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetField.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetField.tst
new file mode 100644 (file)
index 0000000..6a2fd92
--- /dev/null
@@ -0,0 +1,34 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetField mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxArray *value = mxGetField(prhs[0], 0, ""a"");';
+       '    if (value == NULL) value = mxCreateDoubleScalar(-1);';
+       '    plhs[0] = value;';
+       '}'],'mexgetField.c');
+ilib_mex_build('libmextest',['getField','mexgetField','cmex'], 'mexgetField.c',[],'Makelib','','','');
+exec('loader.sce');
+
+c = struct("a", 5, "b", 2);
+r = getField(c);
+if r <> 5 then pause end
+
+c = struct("b", 32);
+r = getField(c);
+if r <> -1 then pause end
+
+r = getField(1);
+if r <> -1 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetField.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetField.win.dia.ref
new file mode 100644 (file)
index 0000000..225f79c
--- /dev/null
@@ -0,0 +1,62 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetField mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxArray *value = mxGetField(prhs[0], 0, ""a"");';
+       '    if (value == NULL) value = mxCreateDoubleScalar(-1);';
+       '    plhs[0] = value;';
+       '}'],'mexgetField.c');
+
+ilib_mex_build('libmextest',['getField','mexgetField','cmex'], 'mexgetField.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetField.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+c = struct("a", 5, "b", 2);
+
+r = getField(c);
+
+if r <> 5 then pause end
+
+c = struct("b", 32);
+
+r = getField(c);
+
+if r <> -1 then pause end
+
+r = getField(1);
+
+if r <> -1 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetFieldByNumber.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetFieldByNumber.linux.dia.ref
new file mode 100644 (file)
index 0000000..2ea6afe
--- /dev/null
@@ -0,0 +1,63 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetFieldByNumber mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxArray *value = mxGetFieldByNumber(prhs[0], 0, 1);';
+       '    if (value == NULL) value = mxCreateDoubleScalar(-1);';
+       '    plhs[0] = value;';
+       '}'],'mexgetFieldByNumber.c');
+ilib_mex_build('libmextest',['getFieldByNumber','mexgetFieldByNumber','cmex'], 'mexgetFieldByNumber.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 mexgetFieldByNumber.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+c = struct("a", 5, "b", 2);
+
+r = getFieldByNumber(c);
+
+if r <> 2 then pause end
+
+c = struct("b", 32);
+
+r = getFieldByNumber(c);
+
+if r <> -1 then pause end
+
+r = getFieldByNumber(1);
+
+if r <> -1 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetFieldByNumber.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetFieldByNumber.tst
new file mode 100644 (file)
index 0000000..051355e
--- /dev/null
@@ -0,0 +1,34 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetFieldByNumber mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxArray *value = mxGetFieldByNumber(prhs[0], 0, 1);';
+       '    if (value == NULL) value = mxCreateDoubleScalar(-1);';
+       '    plhs[0] = value;';
+       '}'],'mexgetFieldByNumber.c');
+ilib_mex_build('libmextest',['getFieldByNumber','mexgetFieldByNumber','cmex'], 'mexgetFieldByNumber.c',[],'Makelib','','','');
+exec('loader.sce');
+
+c = struct("a", 5, "b", 2);
+r = getFieldByNumber(c);
+if r <> 2 then pause end
+
+c = struct("b", 32);
+r = getFieldByNumber(c);
+if r <> -1 then pause end
+
+r = getFieldByNumber(1);
+if r <> -1 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetFieldByNumber.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetFieldByNumber.win.dia.ref
new file mode 100644 (file)
index 0000000..3f9cfbf
--- /dev/null
@@ -0,0 +1,62 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetFieldByNumber mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxArray *value = mxGetFieldByNumber(prhs[0], 0, 1);';
+       '    if (value == NULL) value = mxCreateDoubleScalar(-1);';
+       '    plhs[0] = value;';
+       '}'],'mexgetFieldByNumber.c');
+
+ilib_mex_build('libmextest',['getFieldByNumber','mexgetFieldByNumber','cmex'], 'mexgetFieldByNumber.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetFieldByNumber.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+c = struct("a", 5, "b", 2);
+
+r = getFieldByNumber(c);
+
+if r <> 2 then pause end
+
+c = struct("b", 32);
+
+r = getFieldByNumber(c);
+
+if r <> -1 then pause end
+
+r = getFieldByNumber(1);
+
+if r <> -1 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetFieldNameByNumber.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetFieldNameByNumber.linux.dia.ref
new file mode 100644 (file)
index 0000000..a464b85
--- /dev/null
@@ -0,0 +1,55 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetFieldNameByNumber mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int fieldnum = mxGetScalar(prhs[1]);';
+       '    char *fieldname = mxGetFieldNameByNumber(prhs[0], fieldnum);';
+       '    plhs[0] = mxCreateString(fieldname != NULL ? fieldname : """");';
+       '}'],'mexGetFieldNameByNumber.c');
+ilib_mex_build('libmextest',['getFieldNameByNumber','mexGetFieldNameByNumber','cmex'], 'mexGetFieldNameByNumber.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 mexGetFieldNameByNumber.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+s = struct("a", 1, "b", 2);
+
+if getFieldNameByNumber(s, 0) <> "a" then pause end
+
+if getFieldNameByNumber(s, 1) <> "b" then pause end
+
+if getFieldNameByNumber(s, 2) <> "" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetFieldNameByNumber.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetFieldNameByNumber.tst
new file mode 100644 (file)
index 0000000..f36ed28
--- /dev/null
@@ -0,0 +1,28 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetFieldNameByNumber mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int fieldnum = mxGetScalar(prhs[1]);';
+       '    char *fieldname = mxGetFieldNameByNumber(prhs[0], fieldnum);';
+       '    plhs[0] = mxCreateString(fieldname != NULL ? fieldname : """");';
+       '}'],'mexGetFieldNameByNumber.c');
+ilib_mex_build('libmextest',['getFieldNameByNumber','mexGetFieldNameByNumber','cmex'], 'mexGetFieldNameByNumber.c',[],'Makelib','','','');
+exec('loader.sce');
+
+s = struct("a", 1, "b", 2);
+if getFieldNameByNumber(s, 0) <> "a" then pause end
+if getFieldNameByNumber(s, 1) <> "b" then pause end
+if getFieldNameByNumber(s, 2) <> "" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetFieldNameByNumber.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetFieldNameByNumber.win.dia.ref
new file mode 100644 (file)
index 0000000..25a27e5
--- /dev/null
@@ -0,0 +1,54 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetFieldNameByNumber mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int fieldnum = mxGetScalar(prhs[1]);';
+       '    char *fieldname = mxGetFieldNameByNumber(prhs[0], fieldnum);';
+       '    plhs[0] = mxCreateString(fieldname != NULL ? fieldname : """");';
+       '}'],'mexGetFieldNameByNumber.c');
+
+ilib_mex_build('libmextest',['getFieldNameByNumber','mexGetFieldNameByNumber','cmex'], 'mexGetFieldNameByNumber.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexGetFieldNameByNumber.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+s = struct("a", 1, "b", 2);
+
+if getFieldNameByNumber(s, 0) <> "a" then pause end
+
+if getFieldNameByNumber(s, 1) <> "b" then pause end
+
+if getFieldNameByNumber(s, 2) <> "" then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetFieldNumber.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetFieldNumber.linux.dia.ref
new file mode 100644 (file)
index 0000000..7810ea4
--- /dev/null
@@ -0,0 +1,68 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetFieldNumber mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int num = mxGetFieldNumber(prhs[0], ""a"");';
+       '    plhs[0] = mxCreateDoubleScalar(num);';
+       '}'],'mexgetFieldNumber.c');
+ilib_mex_build('libmextest',['getFieldNumber','mexgetFieldNumber','cmex'], 'mexgetFieldNumber.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 mexgetFieldNumber.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+c = struct("a", 3, "b", 1, "1", 2);
+
+r = getFieldNumber(c);
+
+if r <> 1 then pause end
+
+c = struct("a", 5, "b", 3);
+
+r = getFieldNumber(c);
+
+if r <> 0 then pause end
+
+c = struct("b", 32);
+
+r = getFieldNumber(c);
+
+if r <> -1 then pause end
+
+r = getFieldNumber("not_a_struct");
+
+if r <> -1 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetFieldNumber.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetFieldNumber.tst
new file mode 100644 (file)
index 0000000..5f11d37
--- /dev/null
@@ -0,0 +1,37 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetFieldNumber mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int num = mxGetFieldNumber(prhs[0], ""a"");';
+       '    plhs[0] = mxCreateDoubleScalar(num);';
+       '}'],'mexgetFieldNumber.c');
+ilib_mex_build('libmextest',['getFieldNumber','mexgetFieldNumber','cmex'], 'mexgetFieldNumber.c',[],'Makelib','','','');
+exec('loader.sce');
+
+c = struct("a", 3, "b", 1, "1", 2);
+r = getFieldNumber(c);
+if r <> 1 then pause end
+
+c = struct("a", 5, "b", 3);
+r = getFieldNumber(c);
+if r <> 0 then pause end
+
+c = struct("b", 32);
+r = getFieldNumber(c);
+if r <> -1 then pause end
+
+r = getFieldNumber("not_a_struct");
+if r <> -1 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetFieldNumber.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetFieldNumber.win.dia.ref
new file mode 100644 (file)
index 0000000..663b858
--- /dev/null
@@ -0,0 +1,67 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetFieldNumber mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int num = mxGetFieldNumber(prhs[0], ""a"");';
+       '    plhs[0] = mxCreateDoubleScalar(num);';
+       '}'],'mexgetFieldNumber.c');
+
+ilib_mex_build('libmextest',['getFieldNumber','mexgetFieldNumber','cmex'], 'mexgetFieldNumber.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetFieldNumber.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+c = struct("a", 3, "b", 1, "1", 2);
+
+r = getFieldNumber(c);
+
+if r <> 1 then pause end
+
+c = struct("a", 5, "b", 3);
+
+r = getFieldNumber(c);
+
+if r <> 0 then pause end
+
+c = struct("b", 32);
+
+r = getFieldNumber(c);
+
+if r <> -1 then pause end
+
+r = getFieldNumber("not_a_struct");
+
+if r <> -1 then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetInf.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetInf.linux.dia.ref
new file mode 100644 (file)
index 0000000..9bc595c
--- /dev/null
@@ -0,0 +1,52 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetInf mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    double dblInf = mxGetInf();';
+       '    mxArray* pOut = mxCreateDoubleScalar(dblInf);';
+       '    plhs[0] = pOut;';
+       '}'],'mexgetInf.c');
+
+ilib_mex_build('libmextest',['getInf','mexgetInf','cmex'], 'mexgetInf.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 mexgetInf.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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 = getInf();
+
+if a <> %inf then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetInf.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetInf.tst
new file mode 100644 (file)
index 0000000..cb4b44b
--- /dev/null
@@ -0,0 +1,26 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetInf mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    double dblInf = mxGetInf();';
+       '    mxArray* pOut = mxCreateDoubleScalar(dblInf);';
+       '    plhs[0] = pOut;';
+       '}'],'mexgetInf.c');
+ilib_mex_build('libmextest',['getInf','mexgetInf','cmex'], 'mexgetInf.c',[],'Makelib','','','');
+exec('loader.sce');
+
+a = getInf();
+if a <> %inf then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetInf.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetInf.win.dia.ref
new file mode 100644 (file)
index 0000000..55f4b54
--- /dev/null
@@ -0,0 +1,50 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetInf mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    double dblInf = mxGetInf();';
+       '    mxArray* pOut = mxCreateDoubleScalar(dblInf);';
+       '    plhs[0] = pOut;';
+       '}'],'mexgetInf.c');
+
+ilib_mex_build('libmextest',['getInf','mexgetInf','cmex'], 'mexgetInf.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetInf.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = getInf();
+
+if a <> %inf then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetLogicals.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetLogicals.linux.dia.ref
new file mode 100644 (file)
index 0000000..79b3096
--- /dev/null
@@ -0,0 +1,53 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetLogicals mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxLogical *logicals = mxGetLogicals(prhs[0]);';
+       '    plhs[0] = mxCreateLogicalScalar(logicals[0]);';
+       '    plhs[1] = mxCreateLogicalScalar(logicals[1]);';
+       '}'],'mexgetLogicals.c');
+ilib_mex_build('libmextest',['getLogicals','mexgetLogicals','cmex'], 'mexgetLogicals.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 mexgetLogicals.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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] = getLogicals([%t %f]);
+
+if out1 <> %t then pause end
+
+if out2 <> %f then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetLogicals.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetLogicals.tst
new file mode 100644 (file)
index 0000000..f22eb5e
--- /dev/null
@@ -0,0 +1,28 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetLogicals mex function
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxLogical *logicals = mxGetLogicals(prhs[0]);';
+       '    plhs[0] = mxCreateLogicalScalar(logicals[0]);';
+       '    plhs[1] = mxCreateLogicalScalar(logicals[1]);';
+       '}'],'mexgetLogicals.c');
+ilib_mex_build('libmextest',['getLogicals','mexgetLogicals','cmex'], 'mexgetLogicals.c',[],'Makelib','','','');
+exec('loader.sce');
+
+[out1, out2] = getLogicals([%t %f]);
+if out1 <> %t then pause end
+if out2 <> %f then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetLogicals.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetLogicals.win.dia.ref
new file mode 100644 (file)
index 0000000..23dad90
--- /dev/null
@@ -0,0 +1,52 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetLogicals mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    mxLogical *logicals = mxGetLogicals(prhs[0]);';
+       '    plhs[0] = mxCreateLogicalScalar(logicals[0]);';
+       '    plhs[1] = mxCreateLogicalScalar(logicals[1]);';
+       '}'],'mexgetLogicals.c');
+
+ilib_mex_build('libmextest',['getLogicals','mexgetLogicals','cmex'], 'mexgetLogicals.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetLogicals.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+[out1, out2] = getLogicals([%t %f]);
+
+if out1 <> %t then pause end
+
+if out2 <> %f then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetNaN.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetNaN.linux.dia.ref
new file mode 100644 (file)
index 0000000..06a7a65
--- /dev/null
@@ -0,0 +1,52 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetNaN mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    double dblNaN = mxGetNaN();';
+       '    mxArray* pOut = mxCreateDoubleScalar(dblNaN);';
+       '    plhs[0] = pOut;';
+       '}'],'mexgetNaN.c');
+
+ilib_mex_build('libmextest',['getNaN','mexgetNaN','cmex'], 'mexgetNaN.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 mexgetNaN.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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 = getNaN();
+
+if isnan(a) <> %t then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetNaN.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetNaN.tst
new file mode 100644 (file)
index 0000000..b1ff6d6
--- /dev/null
@@ -0,0 +1,26 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetNaN mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    double dblNaN = mxGetNaN();';
+       '    mxArray* pOut = mxCreateDoubleScalar(dblNaN);';
+       '    plhs[0] = pOut;';
+       '}'],'mexgetNaN.c');
+ilib_mex_build('libmextest',['getNaN','mexgetNaN','cmex'], 'mexgetNaN.c',[],'Makelib','','','');
+exec('loader.sce');
+
+a = getNaN();
+if isnan(a) <> %t then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetNaN.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetNaN.win.dia.ref
new file mode 100644 (file)
index 0000000..2e33021
--- /dev/null
@@ -0,0 +1,50 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetNaN mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    double dblNaN = mxGetNaN();';
+       '    mxArray* pOut = mxCreateDoubleScalar(dblNaN);';
+       '    plhs[0] = pOut;';
+       '}'],'mexgetNaN.c');
+
+ilib_mex_build('libmextest',['getNaN','mexgetNaN','cmex'], 'mexgetNaN.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetNaN.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+a = getNaN();
+
+if isnan(a) <> %t then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfFields.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfFields.linux.dia.ref
new file mode 100644 (file)
index 0000000..ea8ea21
--- /dev/null
@@ -0,0 +1,68 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetNumberOfFields mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int num = mxGetNumberOfFields(prhs[0]);';
+       '    plhs[0] = mxCreateDoubleScalar(num);';
+       '}'],'mexgetNumberOfFields.c');
+ilib_mex_build('libmextest',['getNumberOfFields','mexgetNumberOfFields','cmex'], 'mexgetNumberOfFields.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 mexgetNumberOfFields.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+c = struct("a", 5, "b", 3, "e", 1, "another key", "hello");
+
+r = getNumberOfFields(c);
+
+if r <> 4 then pause end
+
+c = struct("a", 5, "b", 3);
+
+r = getNumberOfFields(c);
+
+if r <> 2 then pause end
+
+c = struct("b", 32);
+
+r = getNumberOfFields(c);
+
+if r <> 1 then pause end
+
+r = getNumberOfFields("not_a_struct");
+
+if r <> 0 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfFields.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfFields.tst
new file mode 100644 (file)
index 0000000..7511492
--- /dev/null
@@ -0,0 +1,37 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetNumberOfFields mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int num = mxGetNumberOfFields(prhs[0]);';
+       '    plhs[0] = mxCreateDoubleScalar(num);';
+       '}'],'mexgetNumberOfFields.c');
+ilib_mex_build('libmextest',['getNumberOfFields','mexgetNumberOfFields','cmex'], 'mexgetNumberOfFields.c',[],'Makelib','','','');
+exec('loader.sce');
+
+c = struct("a", 5, "b", 3, "e", 1, "another key", "hello");
+r = getNumberOfFields(c);
+if r <> 4 then pause end
+
+c = struct("a", 5, "b", 3);
+r = getNumberOfFields(c);
+if r <> 2 then pause end
+
+c = struct("b", 32);
+r = getNumberOfFields(c);
+if r <> 1 then pause end
+
+r = getNumberOfFields("not_a_struct");
+if r <> 0 then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfFields.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfFields.win.dia.ref
new file mode 100644 (file)
index 0000000..b2362da
--- /dev/null
@@ -0,0 +1,67 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetNumberOfFields mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int num = mxGetNumberOfFields(prhs[0]);';
+       '    plhs[0] = mxCreateDoubleScalar(num);';
+       '}'],'mexgetNumberOfFields.c');
+
+ilib_mex_build('libmextest',['getNumberOfFields','mexgetNumberOfFields','cmex'], 'mexgetNumberOfFields.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetNumberOfFields.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+c = struct("a", 5, "b", 3, "e", 1, "another key", "hello");
+
+r = getNumberOfFields(c);
+
+if r <> 4 then pause end
+
+c = struct("a", 5, "b", 3);
+
+r = getNumberOfFields(c);
+
+if r <> 2 then pause end
+
+c = struct("b", 32);
+
+r = getNumberOfFields(c);
+
+if r <> 1 then pause end
+
+r = getNumberOfFields("not_a_struct");
+
+if r <> 0 then pause end
+
index d47dde6..e688c4c 100644 (file)
@@ -36,7 +36,7 @@ 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(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
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetSetData.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetSetData.linux.dia.ref
new file mode 100644 (file)
index 0000000..851853e
--- /dev/null
@@ -0,0 +1,86 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetData and mxSetData mex functions
+
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    void *data = mxGetData(prhs[0]);';
+       '    mxSetData(prhs[0], data);';
+       '    plhs[0] = prhs[0];';
+       '}'],'mexGetSetData.c');
+ilib_mex_build('libmextest',['getSetData','mexGetSetData','cmex'], 'mexGetSetData.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 mexGetSetData.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+r = getSetData(double(1));
+
+if r(1) <> 1 then pause end
+
+r = getSetData(int8(2));
+
+if r(1) <> 2 then pause end
+
+r = getSetData(int16(3));
+
+if r(1) <> 3 then pause end
+
+r = getSetData(int32(4));
+
+if r(1) <> 4 then pause end
+
+r = getSetData(int64(5));
+
+if r(1) <> 5 then pause end
+
+r = getSetData(uint8(6));
+
+if r(1) <> 6 then pause end
+
+r = getSetData(uint16(7));
+
+if r(1) <> 7 then pause end
+
+r = getSetData(uint32(8));
+
+if r(1) <> 8 then pause end
+
+r = getSetData(uint64(9));
+
+if r(1) <> 9 then pause end
+
+r = getSetData(%t);
+
+if r(1) <> %t then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetSetData.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetSetData.tst
new file mode 100644 (file)
index 0000000..54f6bca
--- /dev/null
@@ -0,0 +1,44 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetData and mxSetData mex functions
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    void *data = mxGetData(prhs[0]);';
+       '    mxSetData(prhs[0], data);';
+       '    plhs[0] = prhs[0];';
+       '}'],'mexGetSetData.c');
+ilib_mex_build('libmextest',['getSetData','mexGetSetData','cmex'], 'mexGetSetData.c',[],'Makelib','','','');
+exec('loader.sce');
+
+r = getSetData(double(1));
+if r(1) <> 1 then pause end
+r = getSetData(int8(2));
+if r(1) <> 2 then pause end
+r = getSetData(int16(3));
+if r(1) <> 3 then pause end
+r = getSetData(int32(4));
+if r(1) <> 4 then pause end
+r = getSetData(int64(5));
+if r(1) <> 5 then pause end
+r = getSetData(uint8(6));
+if r(1) <> 6 then pause end
+r = getSetData(uint16(7));
+if r(1) <> 7 then pause end
+r = getSetData(uint32(8));
+if r(1) <> 8 then pause end
+r = getSetData(uint64(9));
+if r(1) <> 9 then pause end
+r = getSetData(%t);
+if r(1) <> %t then pause end
\ No newline at end of file
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetSetData.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetSetData.win.dia.ref
new file mode 100644 (file)
index 0000000..ad80c89
--- /dev/null
@@ -0,0 +1,86 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetData and mxSetData mex functions
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    void *data = mxGetData(prhs[0]);';
+       '    mxSetData(prhs[0], data);';
+       '    plhs[0] = prhs[0];';
+       '}'],'mexGetSetData.c');
+
+ilib_mex_build('libmextest',['getSetData','mexGetSetData','cmex'], 'mexGetSetData.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexGetSetData.c
+   Building shared library (be patient)
+   Generate a cleaner file
+
+exec('loader.sce');
+Shared archive loaded.
+Link done.
+
+r = getSetData(double(1));
+
+if r(1) <> 1 then pause end
+
+r = getSetData(int8(2));
+
+if r(1) <> 2 then pause end
+
+r = getSetData(int16(3));
+
+if r(1) <> 3 then pause end
+
+r = getSetData(int32(4));
+
+if r(1) <> 4 then pause end
+
+r = getSetData(int64(5));
+
+if r(1) <> 5 then pause end
+
+r = getSetData(uint8(6));
+
+if r(1) <> 6 then pause end
+
+r = getSetData(uint16(7));
+
+if r(1) <> 7 then pause end
+
+r = getSetData(uint32(8));
+
+if r(1) <> 8 then pause end
+
+r = getSetData(uint64(9));
+
+if r(1) <> 9 then pause end
+
+r = getSetData(%t);
+
+if r(1) <> %t then pause end
+
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetString.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetString.linux.dia.ref
new file mode 100644 (file)
index 0000000..8b9ef03
--- /dev/null
@@ -0,0 +1,61 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetString mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int strl = 20;';
+       '    char string[strl];';
+       '    plhs[0] = mxCreateDoubleScalar(mxGetString(prhs[0], string, strl));';
+       '    plhs[1] = mxCreateString(string);';
+       '}'],'mexgetString.c');
+
+ilib_mex_build('libmextest',['getString','mexgetString','cmex'], 'mexgetString.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 mexgetString.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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] = getString("String to copy.");
+
+if out1 <> 0 then pause end
+
+if out2 <> "String to copy." then pause end
+
+[out3, out4] = getString("A string bigger than 20 chars.");
+
+if out3 <> 1 then pause end
+
+if out4 <> "A string bigger tha" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetString.tst b/scilab/modules/mexlib/tests/unit_tests/mxGetString.tst
new file mode 100644 (file)
index 0000000..13dabae
--- /dev/null
@@ -0,0 +1,32 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
+// ============================================================================
+// Unitary tests for mxGetString mex function
+// ============================================================================
+
+cd(TMPDIR);
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int strl = 20;';
+       '    char string[strl];';
+       '    plhs[0] = mxCreateDoubleScalar(mxGetString(prhs[0], string, strl));';
+       '    plhs[1] = mxCreateString(string);';
+       '}'],'mexgetString.c');
+ilib_mex_build('libmextest',['getString','mexgetString','cmex'], 'mexgetString.c',[],'Makelib','','','');
+exec('loader.sce');
+
+[out1, out2] = getString("String to copy.");
+if out1 <> 0 then pause end
+if out2 <> "String to copy." then pause end
+
+[out3, out4] = getString("A string bigger than 20 chars.");
+if out3 <> 1 then pause end
+if out4 <> "A string bigger tha" then pause end
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxGetString.win.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxGetString.win.dia.ref
new file mode 100644 (file)
index 0000000..eb178b5
--- /dev/null
@@ -0,0 +1,61 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxGetString mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    int strl = 20;';
+       '    char string[strl];';
+       '    plhs[0] = mxCreateDoubleScalar(mxGetString(prhs[0], string, strl));';
+       '    plhs[1] = mxCreateString(string);';
+       '}'],'mexgetString.c');
+
+ilib_mex_build('libmextest',['getString','mexgetString','cmex'], 'mexgetString.c',[],'Makelib','','','');
+   Generate a gateway file
+   Generate a loader file
+   Generate a Makefile: Makelib
+   Running the makefile
+   Compilation of mexgetString.c
+   Building shared library (be patient)
+
+!------------- Compile file mexgetString.c --------------                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              !
+!                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      !
+!      IF NOT EXIST  Release mkdir Release                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  !
+!                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      !
+!      cl -D__MSC__ -DFORDLL -D_WIN64 -c -DSTRICT -D_CRT_SECURE_NO_DEPRECATE -D__MAKEFILEVC__ -nologo -I"SCI/libs/MALLOC/includes"  -I"SCI/modules/core/includes"  -I"SCI/modules/api_scilab/includes"  -I"SCI/modules/call_scilab/includes"  -I"SCI/modules/output_stream/includes"  -I"SCI/modules/jvm/includes"  -I"SCI/modules/localization/includes"  -I"SCI/modules/dynamic_link/includes"  -I"SCI/modules/mexlib/includes"  -I"SCI/modules/time/includes"  -I"SCI/modules/windows_tools/includes"  -I"SCI/libs/f2c"  -I"SCI/libs/hashtable"  -I"SCI/libs/intl"  -I"SCI/modules/operations/includes"  -I"SCI/modules/symbol/includes"  -I"SCI/modules/types/includes" -W3 -Gd -Z7 -O2 -MT /Fo"Release/" /Fd"Release/" -DFORDLL  -Dmexfunction_=mexmexgetString_ -DmexFunction=mex_mexgetString mexgetString.c  !
+!                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      !
+!mexgetString.c                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        !
+!                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      !
+!mexgetString.c(5) : error C2057: expected constant expression                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         !
+!                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      !
+!mexgetString.c(5) : error C2466: cannot allocate an array of constant size 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          !
+!                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      !
+!mexgetString.c(5) : error C2133: 'string' : unknown size                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              !
+!                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      !
+!NMAKE : fatal error U1077: '"C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\BIN\amd64\cl.EXE"' : return code '0x2'                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            !
+!                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      !
+!Stop.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 !
+
+<--Error on the test script file
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxIsClass.linux.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxIsClass.linux.dia.ref
new file mode 100644 (file)
index 0000000..bd19aca
--- /dev/null
@@ -0,0 +1,119 @@
+
+// ============================================================================
+
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+
+// Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
+
+//
+
+//  This file is distributed under the same license as the Scilab package.
+
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+// <-- ENGLISH IMPOSED -->
+
+// ============================================================================
+
+// Unitary tests for mxIsClass mex function
+
+// ============================================================================
+
+cd(TMPDIR);
+
+mputl(['#include ""mex.h""';
+       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
+       '{';
+       '    if (mxIsClass(prhs[0], ""cell"")) {';
+       '        mexPrintf(""cell"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""char"")) {';
+       '        mexPrintf(""char"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""double"")) {';
+       '        mexPrintf(""double"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""function_handle"")) {';
+       '        mexPrintf(""function_handle"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""int8"")) {';
+       '        mexPrintf(""int8"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""int16"")) {';
+       '        mexPrintf(""int16"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""int32"")) {';
+       '        mexPrintf(""int32"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""int64"")) {';
+       '        mexPrintf(""int64"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""logical"")) {';
+       '        mexPrintf(""logical"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""single"")) {';
+       '        mexPrintf(""single"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""struct"")) {';
+       '        mexPrintf(""struct"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""uint8"")) {';
+       '        mexPrintf(""uint8"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""uint16"")) {';
+       '        mexPrintf(""uint16"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""uint32"")) {';
+       '        mexPrintf(""uint32"");';
+       '    }'
+       '    if (mxIsClass(prhs[0], ""uint64"")) {';
+       '        mexPrintf(""uint64"");';
+       '    }'
+       '}'],'mexisClass.c');
+
+ilib_mex_build('libmextest',['printClass','mexisClass','cmex'], 'mexisClass.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 mexisClass.c to TMPDIR
+   ilib_gen_Make: Copy libmextest.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.
+
+printClass(cell());
+cell
+printClass('s');
+char
+printClass(1);
+double
+printClass(sum);
+function_handle