update mexlib module 21/16321/5
Antoine ELIAS [Fri, 3 Apr 2015 13:54:49 +0000 (15:54 +0200)]
test_run mexlib

Change-Id: Ib4505725fa706bedfa20b80c031eeb186b79d1a7

153 files changed:
scilab/modules/ast/includes/symbol/variables.hxx
scilab/modules/ast/includes/system_env/configvariable.hxx
scilab/modules/ast/src/cpp/symbol/context.cpp
scilab/modules/ast/src/cpp/system_env/configvariable.cpp
scilab/modules/ast/src/cpp/types/function.cpp
scilab/modules/core/sci_gateway/cpp/sci_clearfun.cpp
scilab/modules/core/sci_gateway/cpp/sci_funptr.cpp
scilab/modules/core/sci_gateway/cpp/sci_newfun.cpp
scilab/modules/functions/sci_gateway/cpp/sci_execstr.cpp
scilab/modules/mexlib/includes/mex.h
scilab/modules/mexlib/src/cpp/mexlib.cpp
scilab/modules/mexlib/src/cpp/mexlib.h [deleted file]
scilab/modules/mexlib/src/libmat/libmat.vcxproj
scilab/modules/mexlib/src/libmat/libmat.vcxproj.filters
scilab/modules/mexlib/src/libmex/libmex.vcxproj
scilab/modules/mexlib/src/libmex/libmex.vcxproj.filters
scilab/modules/mexlib/src/libmx/libmx.vcxproj
scilab/modules/mexlib/src/libmx/libmx.vcxproj.filters
scilab/modules/mexlib/tests/nonreg_tests/bug_5292.dia.ref
scilab/modules/mexlib/tests/nonreg_tests/bug_5292.tst
scilab/modules/mexlib/tests/nonreg_tests/bug_614.dia.ref
scilab/modules/mexlib/tests/nonreg_tests/bug_614.tst
scilab/modules/mexlib/tests/unit_tests/mexAtExit.tst
scilab/modules/mexlib/tests/unit_tests/mexCall.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexCall.tst
scilab/modules/mexlib/tests/unit_tests/mexErrMsgTxt.tst
scilab/modules/mexlib/tests/unit_tests/mexEvalString.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexEvalString.tst
scilab/modules/mexlib/tests/unit_tests/mexFunctionName.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexFunctionName.tst
scilab/modules/mexlib/tests/unit_tests/mexGetArray.dia.ref [deleted file]
scilab/modules/mexlib/tests/unit_tests/mexGetArray.tst [deleted file]
scilab/modules/mexlib/tests/unit_tests/mexGetVariable.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexGetVariable.tst
scilab/modules/mexlib/tests/unit_tests/mexGetVariablePtr.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexGetVariablePtr.tst
scilab/modules/mexlib/tests/unit_tests/mexIsGlobal.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexIsGlobal.tst
scilab/modules/mexlib/tests/unit_tests/mexPrintf.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexPrintf.tst
scilab/modules/mexlib/tests/unit_tests/mexPutFull.dia.ref [deleted file]
scilab/modules/mexlib/tests/unit_tests/mexPutFull.tst [deleted file]
scilab/modules/mexlib/tests/unit_tests/mexPutVariable.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexPutVariable.tst
scilab/modules/mexlib/tests/unit_tests/mexWarnMsgTxt.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexWarnMsgTxt.tst
scilab/modules/mexlib/tests/unit_tests/mxAddField.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxAddField.tst
scilab/modules/mexlib/tests/unit_tests/mxArrayToString.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxArrayToString.tst
scilab/modules/mexlib/tests/unit_tests/mxAssert.tst
scilab/modules/mexlib/tests/unit_tests/mxAssertS.tst
scilab/modules/mexlib/tests/unit_tests/mxCalcSingleSubscript.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCalcSingleSubscript.tst
scilab/modules/mexlib/tests/unit_tests/mxCheckTypes.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCheckTypes.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateCell.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateCell.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateCharArray.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateCharArray.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateCharMatrixFromStrings.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateCharMatrixFromStrings.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateDouble.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateDouble.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalArray.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalArray.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalMatrix.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalMatrix.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalScalar.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalScalar.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateNumericArray.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateNumericArray.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateString.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateString.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateStruct.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateStruct.tst
scilab/modules/mexlib/tests/unit_tests/mxDestroyArray.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxDestroyArray.tst
scilab/modules/mexlib/tests/unit_tests/mxDuplicateArray.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxDuplicateArray.tst
scilab/modules/mexlib/tests/unit_tests/mxFreeMatrix.dia.ref [deleted file]
scilab/modules/mexlib/tests/unit_tests/mxFreeMatrix.tst [deleted file]
scilab/modules/mexlib/tests/unit_tests/mxGetChars.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetChars.tst
scilab/modules/mexlib/tests/unit_tests/mxGetClassID.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetClassID.tst
scilab/modules/mexlib/tests/unit_tests/mxGetClassName.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetClassName.tst
scilab/modules/mexlib/tests/unit_tests/mxGetDimensions.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetDimensions.tst
scilab/modules/mexlib/tests/unit_tests/mxGetElementSize.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetElementSize.tst
scilab/modules/mexlib/tests/unit_tests/mxGetEps.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetEps.tst
scilab/modules/mexlib/tests/unit_tests/mxGetField.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetField.tst
scilab/modules/mexlib/tests/unit_tests/mxGetFieldByNumber.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetFieldByNumber.tst
scilab/modules/mexlib/tests/unit_tests/mxGetFieldNameByNumber.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetFieldNameByNumber.tst
scilab/modules/mexlib/tests/unit_tests/mxGetFieldNumber.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetFieldNumber.tst
scilab/modules/mexlib/tests/unit_tests/mxGetInf.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetInf.tst
scilab/modules/mexlib/tests/unit_tests/mxGetLogicals.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetLogicals.tst
scilab/modules/mexlib/tests/unit_tests/mxGetNaN.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetNaN.tst
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfDimensions.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfDimensions.tst
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfElements.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfElements.tst
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfFields.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfFields.tst
scilab/modules/mexlib/tests/unit_tests/mxGetScalar.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetScalar.tst
scilab/modules/mexlib/tests/unit_tests/mxGetSetData.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetSetData.tst
scilab/modules/mexlib/tests/unit_tests/mxGetSetImagData.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetSetImagData.tst
scilab/modules/mexlib/tests/unit_tests/mxGetSetMN.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetSetMN.tst
scilab/modules/mexlib/tests/unit_tests/mxGetSetPri.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetSetPri.tst
scilab/modules/mexlib/tests/unit_tests/mxGetString.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetString.tst
scilab/modules/mexlib/tests/unit_tests/mxIsClass.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsClass.tst
scilab/modules/mexlib/tests/unit_tests/mxIsComplex.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsComplex.tst
scilab/modules/mexlib/tests/unit_tests/mxIsEmpty.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsEmpty.tst
scilab/modules/mexlib/tests/unit_tests/mxIsFinite.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsFinite.tst
scilab/modules/mexlib/tests/unit_tests/mxIsInf.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsInf.tst
scilab/modules/mexlib/tests/unit_tests/mxIsLogicalScalar.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsLogicalScalar.tst
scilab/modules/mexlib/tests/unit_tests/mxIsNaN.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsNaN.tst
scilab/modules/mexlib/tests/unit_tests/mxMalloc.dia.ref [deleted file]
scilab/modules/mexlib/tests/unit_tests/mxMalloc.tst
scilab/modules/mexlib/tests/unit_tests/mxSetCell.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxSetCell.tst
scilab/modules/mexlib/tests/unit_tests/mxSetClearLogical.dia.ref [deleted file]
scilab/modules/mexlib/tests/unit_tests/mxSetClearLogical.tst [deleted file]
scilab/modules/mexlib/tests/unit_tests/mxSetDimensions.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxSetDimensions.tst
scilab/modules/mexlib/tests/unit_tests/mxSetField.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxSetField.tst
scilab/modules/mexlib/tests/unit_tests/mxSetFieldByNumber.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxSetFieldByNumber.tst
scilab/modules/windows_tools/src/c/scilab_windows/WndThread.c

index f9c1b99..874d71f 100644 (file)
@@ -56,6 +56,11 @@ struct Variable
         }
     }
 
+    void put(ScopedVariable* pSV)
+    {
+        stack.push(pSV);
+    }
+
     void put(types::InternalType* _pIT, int _iLevel)
     {
         if (isGlobal() && isGlobalVisible(_iLevel))
@@ -155,7 +160,6 @@ struct Variable
             stack.push(new ScopedVariable(_iLevel, types::Double::Empty()));
         }
 
-
         top()->m_globalVisible = _bVisible;
     }
 
@@ -256,8 +260,7 @@ struct Variables
                 ScopedVariable* pSave = it->second->top();
                 it->second->pop();
                 types::InternalType* pIT = getAllButCurrentLevel(_key, _iLevel);
-                it->second->put(pSave->m_pIT, pSave->m_iLevel);
-                delete pSave;
+                it->second->put(pSave);
                 return pIT;
             }
         }
@@ -465,9 +468,8 @@ struct Variables
             _var->pop();
             putInPreviousScope(_var, _pIT, _iLevel);
             //decresef ref before, increase it in put
-            pVar->m_pIT->DecreaseRef();
-            _var->put(pVar->m_pIT, pVar->m_iLevel);
-            delete pVar;
+            //pVar->m_pIT->DecreaseRef();
+            _var->put(pVar);
         }
         else
         {
index 3e86275..5c746c8 100644 (file)
@@ -252,7 +252,7 @@ public :
 
     typedef struct
     {
-         wchar_t* pwstLibraryName;      /** name of dynamic library **/
+        wchar_t* pwstLibraryName;      /** name of dynamic library **/
         DynLibHandle hLib;              /** handle of the library **/
     } DynamicLibraryStr;
 
@@ -417,6 +417,13 @@ private:
 public:
     static void setDivideByZero(bool _dividebyzero);
     static bool isDivideByZero(void);
+
+    //mex info
+private:
+    static std::string mexFunctionName;
+public:
+    static void setMexFunctionName(const std::string& name);
+    static std::string& getMexFunctionName();
 };
 
 #endif /* !__CONFIGVARIABLE_HXX__ */
index b047f80..fa1e78b 100644 (file)
@@ -171,7 +171,7 @@ types::InternalType* Context::get(const Symbol& _key, int _iLevel)
         {
             if (it->second->empty() == false)
             {
-                return it->second->top()->m_pIT;
+                pIT = it->second->get();
             }
         }
     }
@@ -185,7 +185,6 @@ types::InternalType* Context::get(const Symbol& _key, int _iLevel)
             pIT = libraries.get(_key, _iLevel);
         }
     }
-
     return pIT;
 }
 
index 109e785..843dc6c 100644 (file)
@@ -1221,3 +1221,15 @@ bool ConfigVariable::isDivideByZero(void)
 /*
 ** \}
 */
+
+//mex info
+std::string ConfigVariable::mexFunctionName;
+void ConfigVariable::setMexFunctionName(const std::string& name)
+{
+    mexFunctionName = name;
+}
+
+std::string& ConfigVariable::getMexFunctionName()
+{
+    return mexFunctionName;
+}
index df48d36..a4a6df5 100644 (file)
@@ -336,18 +336,31 @@ Function::ReturnValue WrapMexFunction::call(typed_list &in, optional_list &/*opt
 
     ReturnValue retVal = Callable::OK;
 
+    char* name = wide_string_to_UTF8(getName().c_str());
+    ConfigVariable::setMexFunctionName(name);
+    FREE(name);
+
     int nlhs = _iRetCount;
     int** plhs = new int*[nlhs];
     memset(plhs, 0x00, sizeof(int*) * nlhs);
 
     int nrhs = (int)in.size();
     int** prhs = new int*[nrhs];
-    for (int i = 0 ; i < nrhs ; i++)
+    for (int i = 0; i < nrhs; i++)
     {
         prhs[i] = (int*)(in[i]);
     }
 
-    m_pOldFunc(nlhs, plhs, nrhs, prhs);
+    try
+    {
+        m_pOldFunc(nlhs, plhs, nrhs, prhs);
+    }
+    catch (ast::ScilabError& se)
+    {
+        delete[] plhs;
+        delete[] prhs;
+        throw se;
+    }
 
     if (_iRetCount == 1 && plhs[0] == NULL)
     {
@@ -355,11 +368,13 @@ Function::ReturnValue WrapMexFunction::call(typed_list &in, optional_list &/*opt
         return retVal;
     }
 
-    for (int i = 0 ; i < nlhs ; i++)
+    for (int i = 0; i < nlhs; i++)
     {
         out.push_back((types::InternalType*)plhs[i]);
     }
 
+    delete[] plhs;
+    delete[] prhs;
     return retVal;
 }
 
index 61ed23f..736e549 100644 (file)
@@ -81,9 +81,8 @@ Function::ReturnValue sci_clearfun(types::typed_list &in, int _iRetCount, types:
         {
             pSV = stack.top();
             stack.pop();
-            pSV->m_pIT->DecreaseRef();
-            pVar->put(pSV->m_pIT, pSV->m_iLevel);
-            delete pSV;
+            //pSV->m_pIT->DecreaseRef();
+            pVar->put(pSV);
         }
     }
 
index bc612b3..e01c2b8 100644 (file)
@@ -75,9 +75,8 @@ Function::ReturnValue sci_funptr(types::typed_list &in, int _iRetCount, types::t
         {
             pSV = stack.top();
             stack.pop();
-            pSV->m_pIT->DecreaseRef();
-            pVar->put(pSV->m_pIT, pSV->m_iLevel);
-            delete pSV;
+            //pSV->m_pIT->DecreaseRef();
+            pVar->put(pSV);
         }
     }
 
@@ -91,4 +90,4 @@ Function::ReturnValue sci_funptr(types::typed_list &in, int _iRetCount, types::t
     }
 
     return Function::OK;
-}
\ No newline at end of file
+}
index f65f4ab..24d3aed 100644 (file)
@@ -126,9 +126,8 @@ Function::ReturnValue sci_newfun(types::typed_list &in, int _iRetCount, types::t
         {
             pSV = stack.top();
             stack.pop();
-            pSV->m_pIT->DecreaseRef();
-            pVar->put(pSV->m_pIT, pSV->m_iLevel);
-            delete pSV;
+            //pSV->m_pIT->DecreaseRef();
+            pVar->put(pSV);
         }
     }
 
@@ -170,11 +169,11 @@ Function::ReturnValue sci_newfun(types::typed_list &in, int _iRetCount, types::t
         {
             pSV = stack.top();
             stack.pop();
-            pSV->m_pIT->DecreaseRef();
-            pVar->put(pSV->m_pIT, pSV->m_iLevel);
-            delete pSV;
+            //pSV->m_pIT->DecreaseRef();
+            pVar->put(pSV);
         }
     }
+    
     return Function::OK;
 }
 /*--------------------------------------------------------------------------*/
index 1cc80a1..db3b5fc 100644 (file)
@@ -208,7 +208,7 @@ Function::ReturnValue sci_execstr(types::typed_list &in, int _iRetCount, types::
 
     types::ThreadId* pThreadMe = ConfigVariable::getThread(__GetCurrentThreadKey());
 
-    for (ast::exps_t::iterator j = LExp.begin(), itEnd = LExp.end(); j != itEnd ; ++j)
+    for (ast::exps_t::iterator j = LExp.begin(), itEnd = LExp.end(); j != itEnd; ++j)
     {
         try
         {
@@ -248,7 +248,7 @@ Function::ReturnValue sci_execstr(types::typed_list &in, int _iRetCount, types::
                         }
                         else
                         {
-                            for (int i = 0 ; i < static_cast<int>(out.size()) ; i++)
+                            for (int i = 0; i < static_cast<int>(out.size()); i++)
                             {
                                 out[i]->DecreaseRef();
                                 execMe.setResult(i, out[i]);
@@ -310,7 +310,7 @@ Function::ReturnValue sci_execstr(types::typed_list &in, int _iRetCount, types::
             {
                 InternalType* pITAns = execMe.getResult();
                 symbol::Context::getInstance()->put(symbol::Symbol(L"ans"), pITAns);
-                if ( (*j)->isVerbose() && bErrCatch == false)
+                if ((*j)->isVerbose() && bErrCatch == false)
                 {
                     std::wostringstream ostr;
                     ostr << L" ans  =" << std::endl;
@@ -330,7 +330,7 @@ Function::ReturnValue sci_execstr(types::typed_list &in, int _iRetCount, types::
         catch (ScilabMessage sm)
         {
             ConfigVariable::setSilentError(iOldSilentError);
-            if (bErrCatch  == false && bMute == false)
+            if (bErrCatch == false && bMute == false)
             {
                 scilabErrorW(sm.GetErrorMessage().c_str());
 
index a89b00a..a0530df 100644 (file)
@@ -1,17 +1,17 @@
 
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) INRIA
- * Copyright (C) ENPC
- *  Copyright (C) 2011-2011 - DIGITEO - Bruno JOFRET
- *
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at
- * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
- *
- */
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) INRIA
+* Copyright (C) ENPC
+*  Copyright (C) 2011-2011 - DIGITEO - Bruno JOFRET
+*
+* This file must be used under the terms of the CeCILL.
+* This source file is licensed as described in the file COPYING, which
+* you should have received as part of this distribution.  The terms
+* are also available at
+* http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
+*
+*/
 
 #ifdef __cplusplus
 extern "C" {
@@ -20,296 +20,222 @@ extern "C" {
 #ifndef SCI_MEX
 #define SCI_MEX
 
-#ifdef WIN32
-#include <stddef.h> /*for LCC */
-#endif
-
 #include <stdio.h>
 #include "machine.h"
 #include <assert.h>
 
-    typedef int Matrix;
-    typedef unsigned long int vraiptrst;
+//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);}
+#define mxAssertS(/* int */expr, /*char* */error_msesage) assert(expr);
+
 
 #ifndef __cplusplus
-    typedef int bool;
+typedef int bool;
 #endif
 
-#ifndef __DEF_MXARRAY__
-#define __DEF_MXARRAY__
-    typedef bool mxLogical;
-    typedef int mxArray;
-    typedef char mxChar;
-    typedef int mwSize;
-    typedef int mwIndex;
-    typedef int mwSignedIndex;
-    typedef mxArray *mwPointer;
-#endif
+typedef int mxArray;
 
-#define mxCreateFull mxCreateDoubleMatrix
-
-    /* mexGetMatrixPtr - mexGetArrayPtr : NOT IN MATLAB API - V6.4 compatible */
-#define mexGetMatrixPtr(name) mexGetArrayPtr(name, "caller")
-
-    /* mexGetArray : NOT IN MATLAB API - V6.4 compatible */
-#define mexGetArrayPtr(name,type) mexGetArray(name,type)
-
-    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);
-
-    /* prototypes */
-
-    /* mexInfo: NOT IN MATLAB API - SCILAB SPECIFIC ? */
-    void mexInfo(char *);
-
-    /* mexCheck: NOT IN MATLAB API - SCILAB SPECIFIC ? */
-    int mexCheck(char *, int);
-
-    mxArray *mxCreateCharMatrixFromStrings(int m, const char **str);
-    mxArray *mxCreateString(const char *string);
-    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 *mxCreateCharArray(int ND, const int *size);
-
-    mxArray *mxCreateCellArray(int ND, const int *size);
-    mxArray *mxCreateCellMatrix(int m, int n);
-
-    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);
-
-    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);
-    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);
-
-    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);
-    /* 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);
-    /* 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(void (*func)(void));
-    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(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);
-    /* 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 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);
-    void *mxCalloc(size_t n, size_t size);
-    void *mxMalloc(size_t nsize);
-    void mxFree(void *ptr);
-    void mxDestroyArray(mxArray *ptr);
-
-    /* mxCalloc_m : NOT IN MATLAB API - SCILAB SPECIFIC ? */
-    void *mxCalloc_m(unsigned int n, unsigned int size);
-    /* mxMalloc_m : NOT IN MATLAB API - SCILAB SPECIFIC ? */
-    void *mxMalloc_m(unsigned int nsize);
-    /* 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 mexErrMsgTxt(const char *error_msg);
-    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);
-
-    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
-    {
-        mxCELL_CLASS = 1,
-        mxSTRUCT_CLASS,
-        mxOBJECT_CLASS,
-        mxCHAR_CLASS,
-        mxSPARSE_CLASS,
-        mxDOUBLE_CLASS,
-        mxSINGLE_CLASS,
-        mxINT8_CLASS,
-        mxUINT8_CLASS,
-        mxINT16_CLASS,
-        mxUINT16_CLASS,
-        mxINT32_CLASS,
-        mxUINT32_CLASS,
-        mxINT64_CLASS,
-        mxUINT64_CLASS,
-        mxLOGICAL_CLASS,
-        mxFUNCTION_CLASS,
-        mxUNKNOWN_CLASS = 0
-    } mxClassID;
-
-    typedef enum
-    {mxREAL, mxCOMPLEX} mxComplexity;
-
-    mxClassID mxGetClassID(const mxArray *ptr);
-    /* mxGetName: NOT IN MATLAB API - v6.4 compatible */
-    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);
-    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);
-    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);
-
-    /* typedef uint16_T mxChar; */
-
-    /* typedef short int mxChar; */
-
-#define INT8_T   char
-#define UINT8_T  unsigned char
-#define INT16_T  short
-#define UINT16_T unsigned short
-#define INT32_T  int
-#define UINT32_T unsigned int
-#define REAL32_T float
-
-    typedef INT8_T int8_T;
-    typedef UINT8_T uint8_T;
-    typedef INT16_T int16_T;
-    typedef UINT16_T uint16_T;
-    typedef INT32_T int32_T;
-    typedef UINT32_T uint32_T;
-    typedef REAL32_T real32_T;
-
-#endif                          /* SCI_MEX  */
+typedef int mwSize;
+typedef int mwIndex;
+typedef int mwSignedIndex;
 
-#ifdef __cplusplus
-}
-#endif
+typedef char mxChar;
+typedef int mxLogical;
 
-/* generic mexfunction name */
-#ifdef __cplusplus
-extern "C"
+typedef enum
 {
-    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);}
-#define mxAssertS(/* int */expr, /*char* */error_msesage) assert(expr);
+    mxUNKNOWN_CLASS,
+    mxCELL_CLASS,
+    mxSTRUCT_CLASS,
+    mxLOGICAL_CLASS,
+    mxCHAR_CLASS,
+    mxVOID_CLASS,
+    mxDOUBLE_CLASS,
+    mxSINGLE_CLASS,
+    mxINT8_CLASS,
+    mxUINT8_CLASS,
+    mxINT16_CLASS,
+    mxUINT16_CLASS,
+    mxINT32_CLASS,
+    mxUINT32_CLASS,
+    mxINT64_CLASS,
+    mxUINT64_CLASS,
+    mxFUNCTION_CLASS
+} mxClassID;
+
+typedef enum
+{
+    mxREAL = 0, mxCOMPLEX
+} mxComplexity;
+
+//Create or Delete Array
+mxArray *mxCreateDoubleMatrix(int m, int n, mxComplexity it);
+mxArray *mxCreateDoubleScalar(double value);
+mxArray *mxCreateNumericMatrix(int m, int n, mxClassID classid, mxComplexity flag);
+mxArray *mxCreateNumericArray(int ndim, const int *dims, mxClassID classid, mxComplexity flag);
+mxArray *mxCreateUninitNumericMatrix(size_t m, size_t n, mxClassID classid, mxComplexity ComplexFlag);
+mxArray *mxCreateUninitNumericArray(size_t ndim, size_t *dims, mxClassID classid, mxComplexity ComplexFlag);
+
+mxArray *mxCreateString(const char *string);
+mxArray *mxCreateCharMatrixFromStrings(int m, const char **str);
+mxArray *mxCreateCharArray(int ND, const int *size);
+
+mxArray *mxCreateLogicalScalar(mxLogical value);
+mxArray *mxCreateLogicalMatrix(int m, int n);
+mxArray *mxCreateLogicalArray(mwSize ndim, const mwSize *dims);
+mxArray *mxCreateSparseLogicalMatrix(mwSize m, mwSize n, mwSize nzmax);
+
+mxArray *mxCreateSparse(int m, int n, int nzmax, mxComplexity cmplx);
+
+mxArray *mxCreateStructMatrix(int m, int n, int nfields, const char **field_names);
+mxArray *mxCreateStructArray(int ndim, const int *dims, int nfields, const char **field_names);
+
+mxArray *mxCreateCellArray(int ND, const int *size);
+mxArray *mxCreateCellMatrix(int m, int n);
+
+void mxDestroyArray(mxArray *ptr);
+mxArray *mxDuplicateArray(const mxArray *ptr);
+
+void *mxCalloc(size_t n, size_t size);
+void *mxMalloc(size_t nsize);
+void *mxRealloc(void *ptr, mwSize size);
+void mxFree(void *ptr);
+
+//Validate Data
+int mxIsDouble(const mxArray *ptr);
+int mxIsSingle(const mxArray *ptr);
+int mxIsComplex(const mxArray *ptr);
+int mxIsNumeric(const mxArray *ptr);
+int mxIsInt64(const mxArray *ptr);
+int mxIsUint64(const mxArray *ptr);
+int mxIsInt32(const mxArray *ptr);
+int mxIsUint32(const mxArray *ptr);
+int mxIsInt16(const mxArray *ptr);
+int mxIsUint16(const mxArray *ptr);
+int mxIsInt8(const mxArray *ptr);
+int mxIsUint8(const mxArray *ptr);
+int mxIsScalar(const mxArray *array_ptr);
+
+int mxIsChar(const mxArray *ptr);
+
+int mxIsLogical(const mxArray *ptr);
+int mxIsLogicalScalar(const mxArray *ptr);
+int mxIsLogicalScalarTrue(const mxArray *ptr);
+
+int mxIsStruct(const mxArray *ptr);
+
+int mxIsCell(const mxArray *ptr);
+
+int mxIsClass(const mxArray *ptr, const char *name);
+
+int mxIsInf(double x);
+int mxIsFinite(double x);
+int mxIsNaN(double x);
+int mxIsEmpty(const mxArray *ptr);
+int mxIsSparse(const mxArray *ptr);
+
+int mxIsFromGlobalWS(const mxArray *pm);
+
+//Convert Data Types
+char *mxArrayToString(const mxArray *array_ptr);
+char *mxArrayToUTF8String(const mxArray *array_ptr);
+int mxGetString(const mxArray *ptr, char *str, int strl);
+
+int mxSetClassName(mxArray *array_ptr, const char *classname);
+
+//Access Data
+int mxGetNumberOfDimensions(const mxArray *ptr);
+int mxGetElementSize(const mxArray *ptr);
+mwSize *mxGetDimensions(const mxArray *pm);
+int mxSetDimensions(mxArray *array_ptr, const int *dims, int ndim);
+int mxGetNumberOfElements(const mxArray *ptr);
+int mxCalcSingleSubscript(const mxArray *ptr, int nsubs, const int *subs);
+int mxGetM(const mxArray *ptr);
+void mxSetM(mxArray *ptr, int m);
+int mxGetN(const mxArray *ptr);
+void mxSetN(mxArray *ptr, int n);
+
+double mxGetScalar(const mxArray *ptr);
+double *mxGetPr(const mxArray *ptr);
+void mxSetPr(mxArray *array_ptr, double *pr);
+double *mxGetPi(const mxArray *ptr);
+void mxSetPi(mxArray *array_ptr, double *pi);
+void *mxGetData(const mxArray *ptr);
+void mxSetData(mxArray *array_ptr, void *pr);
+void *mxGetImagData(const mxArray *ptr);
+void mxSetImagData(mxArray *array_ptr, void *data_ptr);
 
 mxChar *mxGetChars(mxArray *array_ptr);
+
+mxLogical *mxGetLogicals(const mxArray *ptr);
+
+mxClassID mxGetClassID(const mxArray *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);
+//mxSetClassName is already defined early
 
-// new functions to be implemented
-mxArray *mxCreateSparseLogicalMatrix(mwSize m, mwSize n, mwSize nzmax);
 mxArray *mxGetProperty(const mxArray *pa, mwIndex index, const char *propname);
 void mxSetProperty(mxArray *pa, mwIndex index, const char *propname, const mxArray *value);
-bool mxIsFromGlobalWS(const mxArray *pm);
+
+mxArray *mxGetField(const mxArray *pa, int i, const char *fieldname);
+void mxSetField(mxArray *pa, int i, const char *fieldname, mxArray *value);
+int mxGetNumberOfFields(const mxArray *ptr);
+const char *mxGetFieldNameByNumber(const mxArray *array_ptr, int field_number);
+int mxGetFieldNumber(const mxArray *ptr, const char *string);
+mxArray *mxGetFieldByNumber(const mxArray *ptr, int index, int field_number);
+void mxSetFieldByNumber(mxArray *array_ptr, int index, int field_number, mxArray *value);
+int mxAddField(mxArray *pm, const char *fieldname);
 void mxRemoveField(mxArray *pm, int fieldnumber);
-int mxSetClassName(mxArray *array_ptr, const char *classname);
-void mexWarnMsgIdAndTxt(const char *warningid, const char *warningmsg, ...);
-void mexErrMsgIdAndTxt(const char *errorid, const char *errormsg, ...);
+
+mxArray *mxGetCell(const mxArray *ptr, int index);
+void mxSetCell(mxArray *pa, int i, mxArray *value);
+
+int mxGetNzmax(const mxArray *ptr);
+void mxSetNzmax(mxArray *array_ptr, int nzmax);
+int *mxGetIr(const mxArray *ptr);
+void mxSetIr(mxArray *array_ptr, int *ir_data);
+int *mxGetJc(const mxArray *ptr);
+void mxSetJc(mxArray *array_ptr, int *jc_data);
+
+//MEX Library
+#ifdef __cplusplus
+extern "C" void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]);
+#endif
+//not a real mex function, just used to set caller name
+void setmexFunctionName(const char* name);
+const char *mexFunctionName(void);
+int mexAtExit(void(*func)(void));
+
+int mexCallMATLAB(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name);
 mxArray *mexCallMATLABWithTrap(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[], const char *functionName);
+int mexEvalString(const char *name);
 mxArray *mexEvalStringWithTrap(const char *command);
-void mexSetTrapFlag(int trapflag);
+
 const mxArray *mexGet(double handle, const char *property);
 int mexSet(double handle, const char *property, mxArray *value);
-bool mexIsLocked(void);
+mxArray *mexGetVariable(const char *workspace, const char *name);
+const mxArray *mexGetVariablePtr(const char *workspace, const char *name);
+int mexPutVariable(const char *workspace, const char *varname, const mxArray *pm);
+int mexIsGlobal(const mxArray *ptr);
+
+int mexPrintf(const char *format, ...);
+
+void mexSetTrapFlag(int trapflag);
+void mexErrMsgIdAndTxt(const char *errorid, const char *errormsg, ...);
+void mexWarnMsgIdAndTxt(const char *warningid, const char *warningmsg, ...);
+void mexErrMsgTxt(const char *error_msg);
+void mexWarnMsgTxt(const char *error_msg);
+
+int mexIsLocked(void);
 void mexLock(void);
 void mexUnlock(void);
 void mexMakeArrayPersistent(mxArray *pm);
+void mexMakeMemoryPersistent(void *ptr);
+
+//Data Types
+double mxGetInf(void);
+double mxGetNaN(void);
+double mxGetEps(void);
+#endif
+#ifdef __cplusplus
+}
+#endif
index 147c5c5..b47c635 100644 (file)
@@ -48,6 +48,7 @@
 #include <stdarg.h>
 
 #include <limits>
+#include <list>
 
 #include "scilabWrite.hxx"
 #include "context.hxx"
@@ -72,705 +73,389 @@ extern "C"
 {
 #include "machine.h"
 #include "mex.h"
-#include "freeArrayOfString.h"
 #include "os_string.h"
+#include "freeArrayOfString.h"
 }
 
-#ifdef getType
-#undef getType
-#endif
+//#ifdef getType
+//#undef getType
+//#endif
+//
+//#ifdef isComplex
+//#undef isComplex
+//#endif
 
-#ifdef isComplex
-#undef isComplex
-#endif
-
-using namespace ast;
-static char *the_current_mex_name;
 static void (*exitFcn)(void);
 
-mxClassID mxGetClassID(const mxArray *ptr)
+static int mexCallSCILAB(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name)
 {
-    types::InternalType *pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
+    wchar_t* pwst = to_wide_string(name);
+    symbol::Context *context = symbol::Context::getInstance();
+    symbol::Symbol *symbol = new symbol::Symbol(pwst);
+    FREE(pwst);
+
+    InternalType *value = context->get(*symbol);
+    Function *func = value->getAs<Function>();
+    if (func == NULL)
     {
-        return mxUNKNOWN_CLASS;
+        return 1;
     }
-    types::InternalType::ScilabType type = pIT->getType();
 
-    switch (type)
+    typed_list in;
+    typed_list out;
+    optional_list opt;
+    for (int i = 0; i < nrhs; i++)
     {
-        case types::InternalType::ScilabInt8:
-            return mxINT8_CLASS;
-        case types::InternalType::ScilabUInt8:
-            return mxUINT8_CLASS;
-        case types::InternalType::ScilabInt16:
-            return mxINT16_CLASS;
-        case types::InternalType::ScilabUInt16:
-            return mxUINT16_CLASS;
-        case types::InternalType::ScilabInt32:
-            return mxINT32_CLASS;
-        case types::InternalType::ScilabUInt32:
-            return mxUINT32_CLASS;
-        case types::InternalType::ScilabInt64:
-            return mxINT64_CLASS;
-        case types::InternalType::ScilabUInt64:
-            return mxUINT64_CLASS;
-        case types::InternalType::ScilabString:
-            return mxCHAR_CLASS;
-        case types::InternalType::ScilabDouble:
-            return mxDOUBLE_CLASS;
-        case types::InternalType::ScilabBool:
-            return mxLOGICAL_CLASS;
-        case types::InternalType::ScilabFloat:
-            return mxSINGLE_CLASS;
-        case types::InternalType::ScilabStruct:
-            return mxSTRUCT_CLASS;
-        case types::InternalType::ScilabCell:
-            return mxCELL_CLASS;
-        case types::InternalType::ScilabFunction:
-            return mxFUNCTION_CLASS;
-        default:
-            return mxUNKNOWN_CLASS;
+        in.push_back((InternalType*)prhs[i]);
     }
-}
 
-bool mxIsInt8(const mxArray *ptr)
-{
-    return mxGetClassID(ptr) == mxINT8_CLASS;
-}
+    func->call(in, opt, nlhs, out, NULL);
 
-bool mxIsInt16(const mxArray *ptr)
-{
-    return mxGetClassID(ptr) == mxINT16_CLASS;
+    for (int i = 0; i < nlhs; i++)
+    {
+        plhs[i] = (mxArray *) (out[i]);
+    }
+
+    return 0;
 }
 
-bool mxIsInt32(const mxArray *ptr)
+//Validated
+
+//Create or Delete Array
+mxArray *mxCreateDoubleMatrix(int m, int n, mxComplexity complexFlag)
 {
-    return mxGetClassID(ptr) == mxINT32_CLASS;
+    Double *ptr = new Double(m, n, complexFlag == mxCOMPLEX);
+    return (mxArray *)ptr;
 }
 
-bool mxIsInt64(const mxArray *ptr)
+mxArray *mxCreateDoubleScalar(double value)
 {
-    return mxGetClassID(ptr) == mxINT64_CLASS;
+    mxArray *ptr = mxCreateDoubleMatrix(1, 1, mxREAL);
+
+    ((Double *)ptr)->set(0, value);
+    return ptr;
 }
 
-bool mxIsUint8(const mxArray *ptr)
+mxArray *mxCreateNumericMatrix(int m, int n, mxClassID CLASS, mxComplexity complexFlag)
 {
-    return mxGetClassID(ptr) == mxUINT8_CLASS;
+    int dims[2] = {m, n};
+    return mxCreateNumericArray(2, dims, CLASS, complexFlag);
 }
 
-bool mxIsUint16(const mxArray *ptr)
+mxArray *mxCreateNumericArray(int ndim, const int *dims, mxClassID CLASS, mxComplexity complexFlag)
 {
-    return mxGetClassID(ptr) == mxUINT16_CLASS;
+    GenericType *ptr;
+
+    switch (CLASS)
+    {
+        case mxDOUBLE_CLASS:
+            ptr = new Double(ndim, (int *)dims, complexFlag == mxCOMPLEX);
+            break;
+        case mxINT8_CLASS:
+            ptr = new Int8(ndim, (int *)dims);
+            break;
+        case mxUINT8_CLASS:
+            ptr = new UInt8(ndim, (int *)dims);
+            break;
+        case mxINT16_CLASS:
+            ptr = new Int16(ndim, (int *)dims);
+            break;
+        case mxUINT16_CLASS:
+            ptr = new UInt16(ndim, (int *)dims);
+            break;
+        case mxINT32_CLASS:
+            ptr = new Int32(ndim, (int *)dims);
+            break;
+        case mxUINT32_CLASS:
+            ptr = new UInt32(ndim, (int *)dims);
+            break;
+        case mxINT64_CLASS:
+            ptr = new Int64(ndim, (int *)dims);
+            break;
+        case mxUINT64_CLASS:
+            ptr = new UInt64(ndim, (int *)dims);
+            break;
+        default:
+            ptr = NULL;
+    }
+    return (mxArray *)ptr;
 }
 
-bool mxIsUint32(const mxArray *ptr)
+mxArray *mxCreateUninitNumericMatrix(size_t m, size_t n, mxClassID classid, mxComplexity ComplexFlag)
 {
-    return mxGetClassID(ptr) == mxUINT32_CLASS;
+    //TODO
+    return NULL;
 }
 
-bool mxIsUint64(const mxArray *ptr)
+mxArray *mxCreateUninitNumericArray(size_t ndim, size_t *dims, mxClassID classid, mxComplexity ComplexFlag)
 {
-    return mxGetClassID(ptr) == mxUINT64_CLASS;
+    //TODO
+    return NULL;
 }
 
-bool mxIsFunction(const mxArray *ptr)
+mxArray *mxCreateString(const char *string)
 {
-    return mxGetClassID(ptr) == mxFUNCTION_CLASS;
+    String *ptr = new String(string);
+    return (mxArray *)ptr;
 }
 
-double mxGetEps(void)
+mxArray *mxCreateCharMatrixFromStrings(int m, const char **str)
 {
-    types::InternalType *pITEps = symbol::Context::getInstance()->get(symbol::Symbol(L"%eps"));
-    if (pITEps && pITEps->isDouble())
+    int n = 1;
+    wchar_t** strings = NULL;
+    strings = (wchar_t**)MALLOC(sizeof(wchar_t*) * m);
+    for (int k = 0; k < m; k++)
     {
-        return pITEps->getAs<types::Double>()->get(0);
+        strings[k] = to_wide_string(str[k]);
     }
-
-    return -1;
+    String *ptr = new String(m, n, strings);
+    freeArrayOfWideString(strings, m);
+    return (mxArray *)ptr;
 }
 
-double mxGetInf(void)
+mxArray *mxCreateCharArray(int ndim, const int *dims)
 {
-    types::InternalType *pITInf = symbol::Context::getInstance()->get(symbol::Symbol(L"%inf"));
-    if (pITInf && pITInf->isDouble())
+    if (ndim == 0 || ndim == 1)
     {
-        return pITInf->getAs<types::Double>()->get(0);
+        ndim = 2;
     }
+    String *ptr = new String(ndim, (int *)dims);
 
-    return -1;
+    int size = ptr->getSize();
+    for (int i = 0; i < size; ++i)
+    {
+        ptr->set(i, L"");
+    }
+    return (mxArray *)ptr;
 }
 
-double mxGetNaN(void)
+mxArray *mxCreateLogicalScalar(mxLogical value)
 {
-    types::InternalType *pITInf = symbol::Context::getInstance()->get(symbol::Symbol(L"%nan"));
-    if (pITInf)
-    {
-        return pITInf->getAs<types::Double>()->get(0);
-    }
+    mxArray *ptr = mxCreateLogicalMatrix(1, 1);
 
-    return -1;
+    ((Bool *)ptr)->set(0, value);
+    return ptr;
 }
 
-bool mxIsInf(double x)
+mxArray *mxCreateLogicalMatrix(int m, int n)
 {
-    if (x == x + 1)
-    {
-        return 1;
-    }
-    else
-    {
-        return 0;
-    }
+    Bool *ptr = new Bool(m, n);
+    return (mxArray *)ptr;
 }
 
-bool mxIsFinite(double x)
+mxArray *mxCreateLogicalArray(int ndim, const int *dims)
 {
-    if (x < x + 1)
-    {
-        return 1;
-    }
-    else
-    {
-        return 0;
-    }
+    Bool *ptr = new Bool(ndim, (int *)dims);
+    return (mxArray *)ptr;
 }
 
-bool mxIsNaN(double x)
+mxArray *mxCreateSparseLogicalMatrix(mwSize m, mwSize n, mwSize nzmax)
 {
-    if (x != x)
-    {
-        return 1;
-    }
-    else
-    {
-        return 0;
-    }
+    //TODO
+    return NULL;
 }
 
-int mxGetNumberOfElements(const mxArray *ptr)
+mxArray *mxCreateSparse(int m, int n, int nzmax, mxComplexity cmplx)
 {
-    types::InternalType *pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
-    {
-        return 0;
-    }
-
-    types::GenericType *pGT = dynamic_cast<types::GenericType *>(pIT);
-    if (pGT == NULL)
-    {
-        return 0;
-    }
-
-    return pGT->getSize();
+    //TODO
+    return NULL;
 }
 
-double *mxGetPr(const mxArray *ptr)
+mxArray *mxCreateStructMatrix(int m, int n, int nfields, const char **field_names)
 {
-    types::InternalType *pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
-    {
-        return NULL;
-    }
+    int dims[2] = {m, n};
+    return mxCreateStructArray(2, dims, nfields, field_names);
+}
 
-    types::Double *pD = dynamic_cast<types::Double *>(pIT);
-    if (pD == NULL)
+mxArray *mxCreateStructArray(int ndim, const int *dims, int nfields, const char **field_names)
+{
+    Struct *ptr = new Struct(ndim, (int *)dims);
+    for (int i = 0; i < nfields; i++)
     {
-        return NULL;
+        wchar_t *name = to_wide_string(field_names[i]);
+        ptr->addField(name);
+        FREE(name);
     }
-
-    return pD->get();
+    return (mxArray *)ptr;
 }
 
-double *mxGetPi(const mxArray *ptr)
+mxArray *mxCreateCellArray(int ndim, const int *dims)
 {
-    return ((types::Double *) ptr)->getImg();
+    Cell *ptr = new Cell(ndim, (int *)dims);
+    return (mxArray *)ptr;
 }
 
-int mxGetNumberOfDimensions(const mxArray *ptr)
+mxArray *mxCreateCellMatrix(int m, int n)
 {
-    types::InternalType *pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
-    {
-        return 0;
-    }
-
-    types::GenericType *pGT = pIT->getAs<types::GenericType>();
-    if (pGT == NULL)
-    {
-        //InternalType but not GenericType, so mono dimension type.
-        return 1;
-    }
-
-    return pGT->getDims();
+    int dims[2] = {m, n};
+    return mxCreateCellArray(2, dims);
 }
 
-int *mxGetDimensions(const mxArray *ptr)
+void mxDestroyArray(mxArray *ptr)
 {
-    types::InternalType *pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
-    {
-        return NULL;
-    }
-
-    switch (pIT->getType())
+    if (mxGetClassID(ptr) != mxUNKNOWN_CLASS)
     {
-        case types::InternalType::ScilabList:
-        case types::InternalType::ScilabMList:
-        case types::InternalType::ScilabTList:
-        {
-            int *piDims = (int *) MALLOC(sizeof(int));
-
-            piDims[0] = pIT->getAs<types::Container>()->getSize();
-            return piDims;
-        }
-        default:
-        {
-            types::GenericType *pGT = pIT->getAs<types::GenericType>();
-            if (pGT == NULL)
-            {
-                return NULL;
-            }
-            return pGT->getDimsArray();
-        }
+        delete (InternalType*)ptr;
+        *ptr = NULL;
     }
-    return NULL;
 }
 
-int mxGetM(const mxArray *ptr)
+mxArray *mxDuplicateArray(const mxArray *ptr)
 {
-    types::InternalType *pIT = (types::InternalType *) ptr;
+    InternalType *pIT = (InternalType *)ptr;
     if (pIT == NULL)
     {
         return 0;
     }
 
-    types::GenericType *pGT = pIT->getAs<types::GenericType>();
-    if (pGT == NULL)
-    {
-        return 0;
-    }
-    return pGT->getRows();
+    return (mxArray *)pIT->clone();
 }
 
-void mxSetM(mxArray *ptr, int M)
+void *mxCalloc(size_t n, size_t size)
 {
-    types::InternalType *pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
-    {
-        return;
-    }
-
-    types::GenericType *pGT = pIT->getAs<types::GenericType>();
-    if (pGT == NULL)
-    {
-        return;
-    }
-
-    pGT->resize(M, pGT->getCols());
+    //TODO
+    return CALLOC(n, size);
 }
 
-int *mxGetJc(const mxArray *ptr)
+void *mxMalloc(size_t nsize)
 {
-    // TODO: sparse
-    return NULL;
+    //TODO
+    return MALLOC(nsize);
 }
 
-int *mxGetIr(const mxArray *ptr)
+void *mxRealloc(void *ptr, size_t nsize)
 {
-    // TODO: sparse
-    return NULL;
+    //TODO
+    return REALLOC(ptr, nsize);
 }
 
-void mxSetJc(mxArray *array_ptr, int *jc_data)
+void mxFree(void *ptr)
 {
-    // TODO: sparse
+    //TODO
 }
 
-void mxSetIr(mxArray *array_ptr, int *ir_data)
+//Validate Data
+int mxIsDouble(const mxArray *ptr)
 {
-    // TODO: sparse
+    return mxGetClassID(ptr) == mxDOUBLE_CLASS;
 }
 
-void mxSetNzmax(mxArray *array_ptr, int nzmax)
+int mxIsSingle(const mxArray *ptr)
 {
-    // TODO: sparse
+    return mxGetClassID(ptr) == mxSINGLE_CLASS;
 }
 
-int mxGetN(const mxArray *ptr)
+int mxIsComplex(const mxArray *ptr)
 {
-    types::InternalType * pIT = (types::InternalType *) ptr;
+    InternalType *pIT = (InternalType *)ptr;
     if (pIT == NULL)
     {
         return 0;
     }
 
-    types::GenericType * pGT = pIT->getAs<types::GenericType>();
-    if (pGT == 0)
+    GenericType *pGT = pIT->getAs<GenericType>();
+    if (pGT == NULL)
     {
         return 0;
     }
-    return pGT->getCols();
+
+    return pGT->isComplex() ? 1 : 0;
 }
 
-void mxSetN(mxArray *ptr, int N)
-{
-    types::InternalType * pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
-    {
-        return;
-    }
-
-    types::GenericType * pGT = pIT->getAs<types::GenericType>();
-    if (pGT == NULL)
-    {
-        return;
-    }
-
-    pGT->resize(pGT->getRows(), N);
-}
-
-bool mxIsString(const mxArray *ptr)
-{
-    /* mxIsString is obsolete. */
-    return mxIsChar(ptr);
-}
-
-bool mxIsChar(const mxArray *ptr)
-{
-    return mxGetClassID(ptr) == mxCHAR_CLASS;
-}
-
-bool mxIsNumeric(const mxArray *ptr)
+int 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)
+int mxIsInt64(const mxArray *ptr)
 {
-    return mxGetClassID(ptr) == mxDOUBLE_CLASS;
+    return mxGetClassID(ptr) == mxINT64_CLASS;
 }
 
-bool mxIsSingle(const mxArray *ptr)
+int mxIsUint64(const mxArray *ptr)
 {
-    return mxGetClassID(ptr) == mxSINGLE_CLASS;
+    return mxGetClassID(ptr) == mxUINT64_CLASS;
 }
 
-bool mxIsEmpty(const mxArray *ptr)
+int mxIsInt32(const mxArray *ptr)
 {
-    types::InternalType * pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
-    {
-        //true or false, whatever ;)
-        return true;
-    }
-
-    switch (pIT->getType())
-    {
-        case types::InternalType::ScilabDouble:
-        {
-            types::Double *pD = pIT->getAs<types::Double>();
-            return pD->getSize() == 0;
-        }
-        case types::InternalType::ScilabCell:
-        {
-            types::Cell *pC = pIT->getAs<types::Cell>();
-            return pC->getSize() == 0;
-        }
-        case types::InternalType::ScilabContainer:
-        case types::InternalType::ScilabList:
-        case types::InternalType::ScilabMList:
-        case types::InternalType::ScilabTList:
-        {
-            types::Container *pC = pIT->getAs<types::Container>();
-            return pC->getSize() == 0;
-        }
-        default:
-        {
-            //other type can not be empty
-            return false;
-        }
-    }
+    return mxGetClassID(ptr) == mxINT32_CLASS;
 }
 
-bool mxIsFull(const mxArray *ptr)
+int mxIsUint32(const mxArray *ptr)
 {
-    /* mxIsFull is obsolete. */
-    return !mxIsSparse(ptr);
+    return mxGetClassID(ptr) == mxUINT32_CLASS;
 }
 
-bool mxIsSparse(const mxArray *ptr)
+int mxIsInt16(const mxArray *ptr)
 {
-    // TODO: sparse
-    return false;
+    return mxGetClassID(ptr) == mxINT16_CLASS;
 }
 
-bool mxIsLogical(const mxArray *ptr)
+int mxIsUint16(const mxArray *ptr)
 {
-    return mxGetClassID(ptr) == mxLOGICAL_CLASS;
+    return mxGetClassID(ptr) == mxUINT16_CLASS;
 }
 
-void mxSetLogical(mxArray *ptr)
+int mxIsInt8(const mxArray *ptr)
 {
-    /* obsolete */
-    if (!mxIsNumeric(ptr))
-    {
-        return;
-    }
-    int *data = (int *) mxGetData(ptr);
-    mxArray *newPtr = (mxArray *) new types::Bool(mxGetNumberOfDimensions(ptr), mxGetDimensions(ptr));
-    mxSetData(newPtr, data);
-    *ptr = *newPtr;
+    return mxGetClassID(ptr) == mxINT8_CLASS;
 }
 
-void mxClearLogical(mxArray *ptr)
+int mxIsUint8(const mxArray *ptr)
 {
-    /* obsolete */
-    if (!mxIsLogical(ptr))
-    {
-        return;
-    }
-    int *data = (int *) mxGetData(ptr);
-    mxArray *newPtr = (mxArray *) new types::Int32(mxGetNumberOfDimensions(ptr), mxGetDimensions(ptr));
-    mxSetData(newPtr, data);
-    *ptr = *newPtr;
+    return mxGetClassID(ptr) == mxUINT8_CLASS;
 }
 
-bool mxIsComplex(const mxArray *ptr)
+int mxIsScalar(const mxArray *array_ptr)
 {
-    types::InternalType *pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
-    {
-        return false;
-    }
-
-    types::GenericType *pGT = pIT->getAs<types::GenericType>();
-    if (pGT == NULL)
-    {
-        return false;
-    }
-
-    return pGT->isComplex();
+    //TODO
+    return 0;
 }
 
-double mxGetScalar(const mxArray *ptr)
+int mxIsChar(const mxArray *ptr)
 {
-    // TODO: review spec
-    types::InternalType *pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
-    {
-        return 0;
-    }
-
-    switch (pIT->getType())
-    {
-        case types::InternalType::ScilabDouble:
-        {
-            types::Double *pD = pIT->getAs<types::Double>();
-            return pD->get(0);
-        }
-        case types::InternalType::ScilabBool:
-        {
-            types::Bool *pB = pIT->getAs<types::Bool>();
-            return (double) pB->get(0);
-        }
-        case types::InternalType::ScilabInt8:
-        {
-            types::Int8 *pI = pIT->getAs<types::Int8>();
-            return (double) pI->get(0);
-        }
-        case types::InternalType::ScilabUInt8:
-        {
-            types::UInt8 *pI = pIT->getAs<types::UInt8>();
-            return (double) pI->get(0);
-        }
-        case types::InternalType::ScilabInt16:
-        {
-            types::Int16 *pI = pIT->getAs<types::Int16>();
-            return (double) pI->get(0);
-        }
-        case types::InternalType::ScilabUInt16:
-        {
-            types::UInt16 *pI = pIT->getAs<types::UInt16>();
-            return (double) pI->get(0);
-        }
-        case types::InternalType::ScilabInt32:
-        {
-            types::Int32 *pI = pIT->getAs<types::Int32>();
-            return (double) pI->get(0);
-        }
-        case types::InternalType::ScilabUInt32:
-        {
-            types::UInt32 *pI = pIT->getAs<types::UInt32>();
-            return (double) pI->get(0);
-        }
-        case types::InternalType::ScilabInt64:
-        {
-            types::Int64 *pI = pIT->getAs<types::Int64>();
-            return (double) pI->get(0);
-        }
-        case types::InternalType::ScilabUInt64:
-        {
-            types::UInt64 *pI = pIT->getAs<types::UInt64>();
-            return (double) pI->get(0);
-        }
-        default:
-            return 0;
-    }
+    return mxGetClassID(ptr) == mxCHAR_CLASS;
 }
 
-void *mxGetData(const mxArray *ptr)
+int mxIsLogical(const mxArray *ptr)
 {
-    types::InternalType *pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
-    {
-        return NULL;
-    }
+    return mxGetClassID(ptr) == mxLOGICAL_CLASS;
+}
 
-    switch (pIT->getType())
-    {
-        case types::InternalType::ScilabDouble:
-        {
-            types::Double *pD = pIT->getAs<types::Double>();
-            return pD->get();
-        }
-        case types::InternalType::ScilabBool:
-        {
-            types::Bool *pB = pIT->getAs<types::Bool>();
-            return pB->get();
-        }
-        case types::InternalType::ScilabInt8:
-        {
-            types::Int8 *pI = pIT->getAs<types::Int8>();
-            return pI->get();
-        }
-        case types::InternalType::ScilabUInt8:
-        {
-            types::UInt8 *pI = pIT->getAs<types::UInt8>();
-            return pI->get();
-        }
-        case types::InternalType::ScilabInt16:
-        {
-            types::Int16 *pI = pIT->getAs<types::Int16>();
-            return pI->get();
-        }
-        case types::InternalType::ScilabUInt16:
-        {
-            types::UInt16 *pI = pIT->getAs<types::UInt16>();
-            return pI->get();
-        }
-        case types::InternalType::ScilabInt32:
-        {
-            types::Int32 *pI = pIT->getAs<types::Int32>();
-            return pI->get();
-        }
-        case types::InternalType::ScilabUInt32:
-        {
-            types::UInt32 *pI = pIT->getAs<types::UInt32>();
-            return pI->get();
-        }
-        case types::InternalType::ScilabInt64:
-        {
-            types::Int64 *pI = pIT->getAs<types::Int64>();
-            return pI->get();
-        }
-        case types::InternalType::ScilabUInt64:
-        {
-            types::UInt64 *pI = pIT->getAs<types::UInt64>();
-            return pI->get();
-        }
-        default:
-            return NULL;
-    }
+int mxIsLogicalScalar(const mxArray *ptr)
+{
+    return mxIsLogical(ptr) && mxGetNumberOfElements(ptr) == 1;
 }
 
-void *mxGetImagData(const mxArray *ptr)
+int mxIsLogicalScalarTrue(const mxArray *ptr)
 {
-    types::InternalType *pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
+    if (mxIsLogicalScalar(ptr) == false)
     {
-        return NULL;
+        return 0;
     }
 
-    switch (pIT->getType())
+    if (*mxGetLogicals(ptr) == 0)
     {
-        case types::InternalType::ScilabDouble:
-        {
-            types::Double *pD = pIT->getAs<types::Double>();
-            return pD->getImg();
-        }
-        case types::InternalType::ScilabBool:
-        {
-            types::Bool *pB = pIT->getAs<types::Bool>();
-            return pB->getImg();
-        }
-        case types::InternalType::ScilabInt8:
-        {
-            types::Int8 *pI = pIT->getAs<types::Int8>();
-            return pI->getImg();
-        }
-        case types::InternalType::ScilabUInt8:
-        {
-            types::UInt8 *pI = pIT->getAs<types::UInt8>();
-            return pI->getImg();
-        }
-        case types::InternalType::ScilabInt16:
-        {
-            types::Int16 *pI = pIT->getAs<types::Int16>();
-            return pI->getImg();
-        }
-        case types::InternalType::ScilabUInt16:
-        {
-            types::UInt16 *pI = pIT->getAs<types::UInt16>();
-            return pI->getImg();
-        }
-        case types::InternalType::ScilabInt32:
-        {
-            types::Int32 *pI = pIT->getAs<types::Int32>();
-            return pI->getImg();
-        }
-        case types::InternalType::ScilabUInt32:
-        {
-            types::UInt32 *pI = pIT->getAs<types::UInt32>();
-            return pI->getImg();
-        }
-        case types::InternalType::ScilabInt64:
-        {
-            types::Int64 *pI = pIT->getAs<types::Int64>();
-            return pI->getImg();
-        }
-        case types::InternalType::ScilabUInt64:
-        {
-            types::UInt64 *pI = pIT->getAs<types::UInt64>();
-            return pI->getImg();
-        }
-        default:
-            return NULL;
+        return 0;
     }
-}
 
-void mexErrMsgTxt(const char *error_msg)
-{
-    throw new ScilabException(error_msg);
+    return 1;
 }
 
-mxArray *mxCreateDoubleMatrix(int m, int n, mxComplexity complexFlag)
+int mxIsStruct(const mxArray *ptr)
 {
-    types::Double *ptr = new types::Double(m, n, complexFlag == mxCOMPLEX);
-    return (mxArray *) ptr;
+    return mxGetClassID(ptr) == mxSTRUCT_CLASS;
 }
 
-mxArray *mxCreateDoubleScalar(double value)
+int mxIsCell(const mxArray *ptr)
 {
-    mxArray *ptr = mxCreateDoubleMatrix(1, 1, mxREAL);
-
-    ((types::Double *) ptr)->set(0, value);
-    return ptr;
+    return mxGetClassID(ptr) == mxCELL_CLASS;
 }
 
-bool mxIsClass(const mxArray *ptr, const char *name)
+int mxIsClass(const mxArray *ptr, const char *name)
 {
     if (strcmp(name, "cell") == 0)
     {
@@ -784,10 +469,6 @@ bool mxIsClass(const mxArray *ptr, const char *name)
     {
         return mxIsDouble(ptr);
     }
-    if (strcmp(name, "function_handle") == 0)
-    {
-        return mxIsFunction(ptr);
-    }
     if (strcmp(name, "int8") == 0)
     {
         return mxIsInt8(ptr);
@@ -833,295 +514,139 @@ bool mxIsClass(const mxArray *ptr, const char *name)
         return mxIsUint64(ptr);
     }
     // TODO: how to handle <class_name> and <class_id>?
-    return false;
+    return 0;
 }
 
-mxArray *mxCreateStructArray(int ndim, const int *dims, int nfields, const char **field_names)
+int mxIsInf(double x)
 {
-    types::Struct *ptr = new types::Struct(ndim, (int *) dims);
-    for (int i = 0; i < nfields; i++)
+    if (x == x + 1)
     {
-        wchar_t *name = to_wide_string(field_names[i]);
-        ptr->addField(name);
-        FREE(name);
+        return 1;
     }
-    return (mxArray *) ptr;
-}
-
-mxArray *mxCreateStructMatrix(int m, int n, int nfields, const char **field_names)
-{
-    int dims[2] = {m, n};
-    return mxCreateStructArray(2, dims, nfields, field_names);
-}
-
-void mxSetFieldByNumber(mxArray *array_ptr, int lindex, int field_number, mxArray *value)
-{
-    if (mxIsStruct(array_ptr) && lindex < mxGetNumberOfElements(array_ptr))
+    else
     {
-        types::SingleStruct *ptr = ((types::Struct *) array_ptr)->get(lindex);
-        types::String *names = ptr->getFieldNames();
-        ptr->set(names->get(field_number), (types::InternalType *) value);
+        return 0;
     }
 }
 
-void mxSetField(mxArray *array_ptr, int lindex, const char *field_name, mxArray *value)
+int mxIsFinite(double x)
 {
-    int field_num = mxGetFieldNumber(array_ptr, field_name);
-    if (field_num >= 0)
+    if (x < x + 1)
     {
-        mxSetFieldByNumber(array_ptr, lindex, field_num, value);
+        return 1;
+    }
+    else
+    {
+        return 0;
     }
 }
 
-const char *mxGetFieldNameByNumber(const mxArray *array_ptr, int field_number)
+int mxIsNaN(double x)
 {
-    if (!mxIsStruct(array_ptr))
+    if (x != x)
     {
-        return NULL;
+        return 1;
     }
-    if (field_number < 0 || field_number >= mxGetNumberOfFields(array_ptr))
+    else
     {
-        return NULL;
+        return 0;
     }
-    types::String *names = ((types::Struct *) array_ptr)->getFieldNames();
-    wchar_t *name = names->get(field_number);
-    return (const char *) wide_string_to_UTF8(name);
 }
 
-int mxAddField(mxArray *ptr, const char *fieldname)
+int mxIsEmpty(const mxArray *ptr)
 {
-    if (!mxIsStruct(ptr))
+    InternalType * pIT = (InternalType *)ptr;
+    if (pIT == NULL)
     {
-        return -1;
+        //true or false, whatever ;)
+        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)
-{
-    if (!mxIsChar(array_ptr))
+    switch (pIT->getType())
     {
-        return NULL;
-    }
-    wchar_t *chars = ((types::String *) array_ptr)->get(0);
-    return (mxChar *) wide_string_to_UTF8(chars);
-}
-
-mxArray *mxCreateNumericArray(int ndim, const int *dims, mxClassID CLASS, mxComplexity complexFlag)
-{
-    types::GenericType *ptr;
-
-    switch (CLASS)
-    {
-        case mxDOUBLE_CLASS:
-            ptr = new types::Double(ndim, (int *) dims, complexFlag == mxCOMPLEX);
-            break;
-        case mxINT8_CLASS:
-            ptr = new types::Int8(ndim, (int *) dims);
-            break;
-        case mxUINT8_CLASS:
-            ptr = new types::UInt8(ndim, (int *) dims);
-            break;
-        case mxINT16_CLASS:
-            ptr = new types::Int16(ndim, (int *) dims);
-            break;
-        case mxUINT16_CLASS:
-            ptr = new types::UInt16(ndim, (int *) dims);
-            break;
-        case mxINT32_CLASS:
-            ptr = new types::Int32(ndim, (int *) dims);
-            break;
-        case mxUINT32_CLASS:
-            ptr = new types::UInt32(ndim, (int *) dims);
-            break;
-        case mxINT64_CLASS:
-            ptr = new types::Int64(ndim, (int *) dims);
-            break;
-        case mxUINT64_CLASS:
-            ptr = new types::UInt64(ndim, (int *) dims);
-            break;
+        case InternalType::ScilabDouble:
+        {
+            Double *pD = pIT->getAs<Double>();
+            return pD->getSize() == 0;
+        }
+        case InternalType::ScilabCell:
+        {
+            Cell *pC = pIT->getAs<Cell>();
+            return pC->getSize() == 0;
+        }
+        case InternalType::ScilabContainer:
+        case InternalType::ScilabList:
+        case InternalType::ScilabMList:
+        case InternalType::ScilabTList:
+        {
+            Container *pC = pIT->getAs<Container>();
+            return pC->getSize() == 0;
+        }
         default:
-            ptr = NULL;
-    }
-    return (mxArray *) ptr;
-}
-
-mxArray *mxCreateNumericMatrix(int m, int n, mxClassID CLASS, mxComplexity complexFlag)
-{
-    int dims[2] = {m, n};
-    return mxCreateNumericArray(2, dims, CLASS, complexFlag);
-}
-
-mxArray *mxCreateCharArray(int ndim, const int *dims)
-{
-    if (ndim == 0 || ndim == 1)
-    {
-        ndim = 2;
+        {
+            //other type can not be empty
+            return 0;
+        }
     }
-    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);
-    return (mxArray *) ptr;
-}
-
-mxArray *mxCreateCellMatrix(int m, int n)
-{
-    int dims[2] = {m, n};
-    return mxCreateCellArray(2, dims);
 }
 
-mxArray *mxGetCell(const mxArray *ptr, int lindex)
+int mxIsSparse(const mxArray *ptr)
 {
-    types::Cell * pa = (types::Cell *) ptr;
-    return (mxArray *) pa->get(lindex);
+    //TODO
+    return 0;
 }
 
-int mxGetFieldNumber(const mxArray *ptr, const char *string)
+int mxIsFromGlobalWS(const mxArray *pm)
 {
-    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 (wcscmp(names->get(i), field_name) == 0)
-        {
-            FREE(field_name);
-            return i;
-        }
-    }
-    FREE(field_name);
-    return -1;
+    //TODO
+    return 0;
 }
 
-mxArray *mxGetField(const mxArray *ptr, int lindex, const char *string)
+//Convert Data Types
+char *mxArrayToString(const mxArray *ptr)
 {
-    int field_num = mxGetFieldNumber(ptr, string);
-    if (field_num < 0)
+    if (!mxIsChar(ptr))
     {
-        return NULL;
+        return (char *)0;
     }
-    return mxGetFieldByNumber(ptr, lindex, field_num);
-}
 
-mxArray *mxGetFieldByNumber(const mxArray *ptr, int lindex, int field_number)
-{
-    if (!mxIsStruct(ptr))
-    {
-        return NULL;
-    }
-    if (lindex >= mxGetNumberOfElements(ptr) || lindex < 0)
-    {
-        return NULL;
-    }
-    if (field_number >= mxGetNumberOfFields(ptr) || field_number < 0)
+    String *pa = (String *)ptr;
+    int items = mxGetM(ptr);
+    int index = 0;
+    int length = 1; // one extra char to \0
+    wchar_t **wstrings = pa->get();
+    for (int k = 0; k < items; k++)
     {
-        return NULL;
+        length += (int)wcslen(wstrings[k]);
     }
-    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)
-{
-    if (!mxIsStruct(ptr))
+    char *str = (char *)malloc(sizeof(char *) * length);
+    for (int k = 0; k < items; k++)
     {
-        return 0;
+        char *dest = wide_string_to_UTF8(wstrings[k]);
+        int dest_length = strlen(dest);
+        memcpy(str + index, dest, dest_length);
+        index += dest_length;
     }
-    types::Struct * pa = (types::Struct *) ptr;
-    return pa->getFieldNames()->getSize();
-}
-
-/*----------------------------------------------------
-* mxCalloc is supposed to initialize data to 0
-* but what does it means since size can be anythink
-* we initialize to zero for double and int data types
-*----------------------------------------------------*/
-
-void *mxRealloc(void *ptr, size_t nsize)
-{
-    // TODO: manage this memory
-    return REALLOC(ptr, nsize);
-}
-
-void *mxCalloc(size_t n, size_t size)
-{
-    // TODO: manage this memory
-    return CALLOC(n, size);
-}
 
-void *mxMalloc(size_t nsize)
-{
-    // TODO: manage this memory
-    return MALLOC(nsize);
-}
-
-void mexMakeMemoryPersistent(void *ptr)
-{
-    // FIXME
-}
-
-
-void *mxCalloc_m(unsigned int n, unsigned int size)
-{
-    // FIXME
-    return NULL;
+    str[index] = '\0';
+    return str;
 }
 
-void *mxMalloc_m(unsigned int n)
+char *mxArrayToUTF8String(const mxArray *array_ptr)
 {
-    // FIXME
+    //TODO
     return NULL;
 }
 
-/* free : explicit free of a mxCalloc_m allocated space
-*        except if space is protected
-*/
-
-void mxFree_m(void *ptr)
-{
-    // FIXME
-}
-
-/* free : explicit free of all mxCalloc_m allocated space
-*        except if space is protected
-*/
-
-static void mxFree_m_all()
-{
-    // FIXME
-}
-
-bool mxIsCell(const mxArray *ptr)
-{
-    return mxGetClassID(ptr) == mxCELL_CLASS;
-}
-
-bool mxIsStruct(const mxArray *ptr)
-{
-    return mxGetClassID(ptr) == mxSTRUCT_CLASS;
-}
-
 int mxGetString(const mxArray *ptr, char *str, int strl)
 {
     if (!mxIsChar(ptr))
     {
         return 1;
     }
-    types::String *pa = (types::String *) ptr;
+
+    String *pa = (String *)ptr;
     int items = mxGetM(ptr);
     int index = 0;
     int free_space = strl - 1;
@@ -1139,349 +664,942 @@ int mxGetString(const mxArray *ptr, char *str, int strl)
             break;
         }
     }
-    str[index] = '\0';
-    return free_space >= 0 ? 0 : 1;
-}
 
-char *mxArrayToString(const mxArray *ptr)
-{
-    if (!mxIsChar(ptr))
-    {
-        return (char *) 0;
-    }
-    types::String *pa = (types::String *) ptr;
-    int items = mxGetM(ptr);
-    int index = 0;
-    int length = 1; // one extra char to \0
-    wchar_t **wstrings = pa->get();
-    for (int k = 0; k < items; k++)
-    {
-        length += (int)wcslen(wstrings[k]);
-    }
-    char *str = (char *) malloc(sizeof(char *) * length);
-    for (int k = 0; k < items; k++)
-    {
-        char *dest = wide_string_to_UTF8(wstrings[k]);
-        int dest_length = strlen(dest);
-        memcpy(str + index, dest, dest_length);
-        index += dest_length;
-    }
     str[index] = '\0';
-    return str;
+    return free_space >= 0 ? 0 : 1;
 }
 
-void mxFreeMatrix(mxArray *ptr)
+int mxSetClassName(mxArray *array_ptr, const char *classname)
 {
-    mxDestroyArray(ptr);
+    //TODO
+    return 0;
 }
 
-bool mexIsGlobal(const mxArray *ptr)
+int mxGetNumberOfDimensions(const mxArray *ptr)
 {
-    symbol::Context *context = symbol::Context::getInstance();
-    int size = symbol::Symbol::getSize();
-    wchar_t **keys = symbol::Symbol::getAll();
-
-    for (int i = 0; i < size; i++)
+    InternalType *pIT = (InternalType *)ptr;
+    if (pIT == NULL)
     {
-        symbol::Symbol *s = new symbol::Symbol(keys[i]);
-        const mxArray *value = (const mxArray *) context->get(*s);
-        if (value == ptr)
-        {
-            return context->isGlobalVisible(*s);
-        }
+        return 0;
     }
-    return false;
-}
 
-mxArray *mxDuplicateArray(const mxArray *ptr)
-{
-    types::InternalType *pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
+    GenericType *pGT = pIT->getAs<GenericType>();
+    if (pGT == NULL)
     {
-        return 0;
+        //InternalType but not GenericType, so mono dimension type.
+        return 1;
     }
 
-    return (mxArray *) pIT->clone();
+    return pGT->getDims();
 }
 
-void mxDestroyArray(mxArray *ptr)
+int mxGetElementSize(const mxArray *ptr)
 {
-    if (mxIsDouble(ptr))
+    if (mxIsChar(ptr))
     {
-        delete (types::Double *) ptr;
+        return sizeof(wchar_t*);
     }
-    else if (mxIsChar(ptr))
+    else if (mxIsLogical(ptr))
     {
-        delete (types::String *) ptr;
+        return sizeof(int);
     }
-    else if (mxIsLogical(ptr))
+    else if (mxIsDouble(ptr))
     {
-        delete (types::Bool *) ptr;
+        return sizeof(double);
     }
     else if (mxIsSparse(ptr))
     {
-        // TODO: sparse
+        return sizeof(double);
     }
     else if (mxIsInt8(ptr))
     {
-        delete (types::Int8 *) ptr;
+        return sizeof(char);
     }
     else if (mxIsInt16(ptr))
     {
-        delete (types::Int16 *) ptr;
+        return sizeof(short);
     }
     else if (mxIsInt32(ptr))
     {
-        delete(types::Int32 *) ptr;
+        return sizeof(int);
     }
     else if (mxIsInt64(ptr))
     {
-        delete((types::Int64 *) ptr);
+        return sizeof(long long);
     }
     else if (mxIsUint8(ptr))
     {
-        delete((types::UInt8 *) ptr);
+        return sizeof(unsigned char);
     }
     else if (mxIsUint16(ptr))
     {
-        delete((types::UInt16 *) ptr);
+        return sizeof(unsigned short);
     }
     else if (mxIsUint32(ptr))
     {
-        delete((types::UInt32 *) ptr);
+        return sizeof(unsigned int);
     }
     else if (mxIsUint64(ptr))
     {
-        delete((types::UInt64 *) ptr);
+        return sizeof(unsigned long long);
     }
     else if (mxIsCell(ptr))
     {
-        delete((types::Cell *) ptr);
+        return sizeof(InternalType*);
     }
     else if (mxIsStruct(ptr))
     {
-        delete((types::Struct *) ptr);
+        return sizeof(SingleStruct*);
     }
+    return 0;
 }
 
-void mxFree(void *ptr)
+mwSize *mxGetDimensions(const mxArray *ptr)
 {
-    // TODO: manage this memory
-    FREE(ptr);
-}
+    InternalType *pIT = (InternalType *)ptr;
+    if (pIT == NULL)
+    {
+        return NULL;
+    }
 
-int mexAtExit(void (*func)(void))
-{
-    exitFcn = func;
-    return 0;
-}
+    switch (pIT->getType())
+    {
+        case InternalType::ScilabList:
+        case InternalType::ScilabMList:
+        case InternalType::ScilabTList:
+        {
+            int *piDims = (int *)MALLOC(sizeof(int));
 
-mxArray *mxCreateSparse(int m, int n, int nzmax, mxComplexity cmplx)
-{
-    // TODO: sparse
+            piDims[0] = pIT->getAs<Container>()->getSize();
+            return piDims;
+        }
+        default:
+        {
+            GenericType *pGT = pIT->getAs<GenericType>();
+            if (pGT == NULL)
+            {
+                return NULL;
+            }
+            return pGT->getDimsArray();
+        }
+    }
     return NULL;
 }
 
-mxArray *mxCreateString(const char *string)
-{
-    types::String *ptr = new types::String(string);
-    return (mxArray *) ptr;
-}
-
-
-mxArray *mxCreateLogicalArray(int ndim, const int *dims)
+int mxSetDimensions(mxArray *array_ptr, const int *dims, int ndim)
 {
-    types::Bool *ptr = new types::Bool(ndim, (int *) dims);
-    return (mxArray *) ptr;
-}
-
-mxArray *mxCreateLogicalMatrix(int m, int n)
+    if (mxIsCell(array_ptr))
+    {
+        ((Cell *)array_ptr)->resize((int *)dims, ndim);
+    }
+    else if (mxIsChar(array_ptr))
+    {
+        ((String *)array_ptr)->resize((int *)dims, ndim);
+    }
+    else if (mxIsDouble(array_ptr))
+    {
+        ((Double *)array_ptr)->resize((int *)dims, ndim);
+    }
+    else if (mxIsSparse(array_ptr))
+    {
+        //TODO
+    }
+    else if (mxIsInt8(array_ptr))
+    {
+        ((Int8 *)array_ptr)->resize((int *)dims, ndim);
+    }
+    else if (mxIsInt16(array_ptr))
+    {
+        ((Int16 *)array_ptr)->resize((int *)dims, ndim);
+    }
+    else if (mxIsInt32(array_ptr))
+    {
+        ((Int32 *)array_ptr)->resize((int *)dims, ndim);
+    }
+    else if (mxIsInt64(array_ptr))
+    {
+        ((Int64 *)array_ptr)->resize((int *)dims, ndim);
+    }
+    else if (mxIsLogical(array_ptr))
+    {
+        ((Bool *)array_ptr)->resize((int *)dims, ndim);
+    }
+    else if (mxIsStruct(array_ptr))
+    {
+        ((Struct *)array_ptr)->resize((int *)dims, ndim);
+    }
+    else if (mxIsUint8(array_ptr))
+    {
+        ((UInt8 *)array_ptr)->resize((int *)dims, ndim);
+    }
+    else if (mxIsUint16(array_ptr))
+    {
+        ((UInt16 *)array_ptr)->resize((int *)dims, ndim);
+    }
+    else if (mxIsUint32(array_ptr))
+    {
+        ((UInt32 *)array_ptr)->resize((int *)dims, ndim);
+    }
+    else if (mxIsUint64(array_ptr))
+    {
+        ((UInt64 *)array_ptr)->resize((int *)dims, ndim);
+    }
+
+    return 0;
+}
+
+int mxGetNumberOfElements(const mxArray *ptr)
+{
+    InternalType *pIT = (InternalType *)ptr;
+    if (pIT == NULL)
+    {
+        return 0;
+    }
+
+    GenericType *pGT = dynamic_cast<GenericType *>(pIT);
+    if (pGT == NULL)
+    {
+        return 0;
+    }
+
+    return pGT->getSize();
+}
+
+int mxCalcSingleSubscript(const mxArray *ptr, int nsubs, const int *subs)
+{
+    int index = 0;
+    int iMult = 1;
+    mwSize *dims = mxGetDimensions(ptr);
+    for (int i = 0; i < nsubs; i++)
+    {
+        index += subs[i] * iMult;
+        iMult *= dims[i];
+    }
+    return index;
+}
+
+int mxGetM(const mxArray *ptr)
+{
+    InternalType *pIT = (InternalType *)ptr;
+    if (pIT == NULL)
+    {
+        return 0;
+    }
+
+    GenericType *pGT = pIT->getAs<GenericType>();
+    if (pGT == NULL)
+    {
+        return 0;
+    }
+    return pGT->getRows();
+}
+
+void mxSetM(mxArray *ptr, int M)
+{
+    InternalType *pIT = (InternalType *)ptr;
+    if (pIT == NULL)
+    {
+        return;
+    }
+
+    GenericType *pGT = pIT->getAs<GenericType>();
+    if (pGT == NULL)
+    {
+        return;
+    }
+
+    pGT->resize(M, pGT->getCols());
+}
+
+int mxGetN(const mxArray *ptr)
+{
+    InternalType * pIT = (InternalType *)ptr;
+    if (pIT == NULL)
+    {
+        return 0;
+    }
+
+    GenericType * pGT = pIT->getAs<GenericType>();
+    if (pGT == 0)
+    {
+        return 0;
+    }
+    return pGT->getCols();
+}
+
+void mxSetN(mxArray *ptr, int N)
+{
+    InternalType * pIT = (InternalType *)ptr;
+    if (pIT == NULL)
+    {
+        return;
+    }
+
+    GenericType * pGT = pIT->getAs<GenericType>();
+    if (pGT == NULL)
+    {
+        return;
+    }
+
+    pGT->resize(pGT->getRows(), N);
+}
+
+double mxGetScalar(const mxArray *ptr)
+{
+    // TODO: review spec
+    InternalType *pIT = (InternalType *)ptr;
+    if (pIT == NULL)
+    {
+        return 0;
+    }
+
+    switch (pIT->getType())
+    {
+        case InternalType::ScilabDouble:
+        {
+            Double *pD = pIT->getAs<Double>();
+            return pD->get(0);
+        }
+        case InternalType::ScilabBool:
+        {
+            Bool *pB = pIT->getAs<Bool>();
+            return (double)pB->get(0);
+        }
+        case InternalType::ScilabInt8:
+        {
+            Int8 *pI = pIT->getAs<Int8>();
+            return (double)pI->get(0);
+        }
+        case InternalType::ScilabUInt8:
+        {
+            UInt8 *pI = pIT->getAs<UInt8>();
+            return (double)pI->get(0);
+        }
+        case InternalType::ScilabInt16:
+        {
+            Int16 *pI = pIT->getAs<Int16>();
+            return (double)pI->get(0);
+        }
+        case InternalType::ScilabUInt16:
+        {
+            UInt16 *pI = pIT->getAs<UInt16>();
+            return (double)pI->get(0);
+        }
+        case InternalType::ScilabInt32:
+        {
+            Int32 *pI = pIT->getAs<Int32>();
+            return (double)pI->get(0);
+        }
+        case InternalType::ScilabUInt32:
+        {
+            UInt32 *pI = pIT->getAs<UInt32>();
+            return (double)pI->get(0);
+        }
+        case InternalType::ScilabInt64:
+        {
+            Int64 *pI = pIT->getAs<Int64>();
+            return (double)pI->get(0);
+        }
+        case InternalType::ScilabUInt64:
+        {
+            UInt64 *pI = pIT->getAs<UInt64>();
+            return (double)pI->get(0);
+        }
+        default:
+            return 0;
+    }
+}
+
+double *mxGetPr(const mxArray *ptr)
+{
+    InternalType *pIT = (InternalType *)ptr;
+    if (pIT == NULL)
+    {
+        return NULL;
+    }
+
+    Double *pD = dynamic_cast<Double *>(pIT);
+    if (pD == NULL)
+    {
+        return NULL;
+    }
+
+    return pD->get();
+}
+
+void mxSetPr(mxArray *ptr, double *pr)
+{
+    ((Double *)ptr)->set(pr);
+}
+
+double *mxGetPi(const mxArray *ptr)
+{
+    return ((Double *)ptr)->getImg();
+}
+
+void mxSetPi(mxArray *ptr, double *pi)
+{
+    ((Double *)ptr)->setImg(pi);
+}
+
+void *mxGetData(const mxArray *ptr)
+{
+    InternalType *pIT = (InternalType *)ptr;
+    if (pIT == NULL)
+    {
+        return NULL;
+    }
+
+    switch (pIT->getType())
+    {
+        case InternalType::ScilabDouble:
+        {
+            Double *pD = pIT->getAs<Double>();
+            return pD->get();
+        }
+        case InternalType::ScilabBool:
+        {
+            Bool *pB = pIT->getAs<Bool>();
+            return pB->get();
+        }
+        case InternalType::ScilabInt8:
+        {
+            Int8 *pI = pIT->getAs<Int8>();
+            return pI->get();
+        }
+        case InternalType::ScilabUInt8:
+        {
+            UInt8 *pI = pIT->getAs<UInt8>();
+            return pI->get();
+        }
+        case InternalType::ScilabInt16:
+        {
+            Int16 *pI = pIT->getAs<Int16>();
+            return pI->get();
+        }
+        case InternalType::ScilabUInt16:
+        {
+            UInt16 *pI = pIT->getAs<UInt16>();
+            return pI->get();
+        }
+        case InternalType::ScilabInt32:
+        {
+            Int32 *pI = pIT->getAs<Int32>();
+            return pI->get();
+        }
+        case InternalType::ScilabUInt32:
+        {
+            UInt32 *pI = pIT->getAs<UInt32>();
+            return pI->get();
+        }
+        case InternalType::ScilabInt64:
+        {
+            Int64 *pI = pIT->getAs<Int64>();
+            return pI->get();
+        }
+        case InternalType::ScilabUInt64:
+        {
+            UInt64 *pI = pIT->getAs<UInt64>();
+            return pI->get();
+        }
+        default:
+            return NULL;
+    }
+}
+
+void mxSetData(mxArray *array_ptr, void *data_ptr)
+{
+    if (mxIsChar(array_ptr))
+    {
+        ((String *)array_ptr)->set((wchar_t **)data_ptr);
+    }
+    else if (mxIsDouble(array_ptr))
+    {
+        ((Double *)array_ptr)->set((double *)data_ptr);
+    }
+    else if (mxIsInt8(array_ptr))
+    {
+        ((Int8 *)array_ptr)->set((char *)data_ptr);
+    }
+    else if (mxIsInt16(array_ptr))
+    {
+        ((Int16 *)array_ptr)->set((short *)data_ptr);
+    }
+    else if (mxIsInt32(array_ptr))
+    {
+        ((Int32 *)array_ptr)->set((int *)data_ptr);
+    }
+    else if (mxIsInt64(array_ptr))
+    {
+        ((Int64 *)array_ptr)->set((long long *)data_ptr);
+    }
+    else if (mxIsLogical(array_ptr))
+    {
+        ((Bool *)array_ptr)->set((int *)data_ptr);
+    }
+    // else if (mxIsSingle(array_ptr)) {
+    //   ((Float *) array_ptr)->set((float *) data_ptr);
+    // }
+    else if (mxIsUint8(array_ptr))
+    {
+        ((UInt8 *)array_ptr)->set((unsigned char *)data_ptr);
+    }
+    else if (mxIsUint16(array_ptr))
+    {
+        ((UInt16 *)array_ptr)->set((unsigned short *)data_ptr);
+    }
+    else if (mxIsUint32(array_ptr))
+    {
+        ((UInt32 *)array_ptr)->set((unsigned int *)data_ptr);
+    }
+    else if (mxIsUint64(array_ptr))
+    {
+        ((UInt64 *)array_ptr)->set((unsigned long long *) data_ptr);
+    }
+}
+
+void *mxGetImagData(const mxArray *ptr)
+{
+    InternalType *pIT = (InternalType *)ptr;
+    if (pIT == NULL)
+    {
+        return NULL;
+    }
+
+    switch (pIT->getType())
+    {
+        case InternalType::ScilabDouble:
+        {
+            Double *pD = pIT->getAs<Double>();
+            return pD->getImg();
+        }
+        case InternalType::ScilabBool:
+        {
+            Bool *pB = pIT->getAs<Bool>();
+            return pB->getImg();
+        }
+        case InternalType::ScilabInt8:
+        {
+            Int8 *pI = pIT->getAs<Int8>();
+            return pI->getImg();
+        }
+        case InternalType::ScilabUInt8:
+        {
+            UInt8 *pI = pIT->getAs<UInt8>();
+            return pI->getImg();
+        }
+        case InternalType::ScilabInt16:
+        {
+            Int16 *pI = pIT->getAs<Int16>();
+            return pI->getImg();
+        }
+        case InternalType::ScilabUInt16:
+        {
+            UInt16 *pI = pIT->getAs<UInt16>();
+            return pI->getImg();
+        }
+        case InternalType::ScilabInt32:
+        {
+            Int32 *pI = pIT->getAs<Int32>();
+            return pI->getImg();
+        }
+        case InternalType::ScilabUInt32:
+        {
+            UInt32 *pI = pIT->getAs<UInt32>();
+            return pI->getImg();
+        }
+        case InternalType::ScilabInt64:
+        {
+            Int64 *pI = pIT->getAs<Int64>();
+            return pI->getImg();
+        }
+        case InternalType::ScilabUInt64:
+        {
+            UInt64 *pI = pIT->getAs<UInt64>();
+            return pI->getImg();
+        }
+        default:
+            return NULL;
+    }
+}
+
+void mxSetImagData(mxArray *array_ptr, void *data_ptr)
+{
+    if (mxIsChar(array_ptr))
+    {
+        ((String *)array_ptr)->setImg((wchar_t **)data_ptr);
+    }
+    else if (mxIsDouble(array_ptr))
+    {
+        ((Double *)array_ptr)->setImg((double *)data_ptr);
+    }
+    else if (mxIsInt8(array_ptr))
+    {
+        ((Int8 *)array_ptr)->setImg((char *)data_ptr);
+    }
+    else if (mxIsInt16(array_ptr))
+    {
+        ((Int16 *)array_ptr)->setImg((short *)data_ptr);
+    }
+    else if (mxIsInt32(array_ptr))
+    {
+        ((Int32 *)array_ptr)->setImg((int *)data_ptr);
+    }
+    else if (mxIsInt64(array_ptr))
+    {
+        ((Int64 *)array_ptr)->setImg((long long *)data_ptr);
+    }
+    else if (mxIsLogical(array_ptr))
+    {
+        ((Bool *)array_ptr)->setImg((int *)data_ptr);
+    }
+    // else if (mxIsSingle(array_ptr)) {
+    //   ((Float *) array_ptr)->setImg((float *) data_ptr);
+    // }
+    else if (mxIsUint8(array_ptr))
+    {
+        ((UInt8 *)array_ptr)->setImg((unsigned char *)data_ptr);
+    }
+    else if (mxIsUint16(array_ptr))
+    {
+        ((UInt16 *)array_ptr)->setImg((unsigned short *)data_ptr);
+    }
+    else if (mxIsUint32(array_ptr))
+    {
+        ((UInt32 *)array_ptr)->setImg((unsigned int *)data_ptr);
+    }
+    else if (mxIsUint64(array_ptr))
+    {
+        ((UInt64 *)array_ptr)->setImg((unsigned long long *) data_ptr);
+    }
+}
+
+mxChar *mxGetChars(mxArray *array_ptr)
 {
-    types::Bool *ptr = new types::Bool(m, n);
-    return (mxArray *) ptr;
+    if (!mxIsChar(array_ptr))
+    {
+        return NULL;
+    }
+    wchar_t *chars = ((String *)array_ptr)->get(0);
+    return (mxChar *)wide_string_to_UTF8(chars);
 }
 
-mxArray *mxCreateLogicalScalar(mxLogical value)
+mxLogical *mxGetLogicals(const mxArray *ptr)
 {
-    mxArray *ptr = mxCreateLogicalMatrix(1, 1);
+    InternalType *pIT = (InternalType *)ptr;
+    if (pIT == NULL)
+    {
+        return NULL;
+    }
 
-    ((types::Bool *) ptr)->set(0, value);
-    return ptr;
+    Bool *pB = pIT->getAs<Bool>();
+    if (pB == NULL)
+    {
+        return NULL;
+    }
+
+    return (mxLogical *)pB->get();
+}
+
+mxClassID mxGetClassID(const mxArray *ptr)
+{
+    InternalType *pIT = dynamic_cast<InternalType*>((InternalType*)ptr);
+    if (pIT == NULL)
+    {
+        return mxUNKNOWN_CLASS;
+    }
+
+    switch (pIT->getType())
+    {
+        case InternalType::ScilabInt8:
+            return mxINT8_CLASS;
+        case InternalType::ScilabUInt8:
+            return mxUINT8_CLASS;
+        case InternalType::ScilabInt16:
+            return mxINT16_CLASS;
+        case InternalType::ScilabUInt16:
+            return mxUINT16_CLASS;
+        case InternalType::ScilabInt32:
+            return mxINT32_CLASS;
+        case InternalType::ScilabUInt32:
+            return mxUINT32_CLASS;
+        case InternalType::ScilabInt64:
+            return mxINT64_CLASS;
+        case InternalType::ScilabUInt64:
+            return mxUINT64_CLASS;
+        case InternalType::ScilabString:
+            return mxCHAR_CLASS;
+        case InternalType::ScilabDouble:
+            return mxDOUBLE_CLASS;
+        case InternalType::ScilabBool:
+            return mxLOGICAL_CLASS;
+        case InternalType::ScilabFloat:
+            return mxSINGLE_CLASS;
+        case InternalType::ScilabStruct:
+            return mxSTRUCT_CLASS;
+        case InternalType::ScilabCell:
+            return mxCELL_CLASS;
+        case InternalType::ScilabFunction:
+            return mxFUNCTION_CLASS;
+        default:
+            return mxUNKNOWN_CLASS;
+    }
+}
+
+const char *mxGetClassName(const mxArray *ptr)
+{
+    if (mxIsDouble(ptr))
+    {
+        return "double";
+    }
+    if (mxIsChar(ptr))
+    {
+        return "char";
+    }
+    if (mxIsLogical(ptr))
+    {
+        return "bool";
+    }
+    if (mxIsSparse(ptr))
+    {
+        return "sparse";
+    }
+    if (mxIsInt8(ptr))
+    {
+        return "int8";
+    }
+    if (mxIsInt16(ptr))
+    {
+        return "int16";
+    }
+    if (mxIsInt32(ptr))
+    {
+        return "int32";
+    }
+    if (mxIsInt64(ptr))
+    {
+        return "int64";
+    }
+    if (mxIsUint8(ptr))
+    {
+        return "uint8";
+    }
+    if (mxIsUint16(ptr))
+    {
+        return "uint16";
+    }
+    if (mxIsUint32(ptr))
+    {
+        return "uint32";
+    }
+    if (mxIsUint64(ptr))
+    {
+        return "uint64";
+    }
+    if (mxIsCell(ptr))
+    {
+        return "cell";
+    }
+    if (mxIsStruct(ptr))
+    {
+        return "struct";
+    }
+    return "unknown";
+}
+
+mxArray *mxGetProperty(const mxArray *pa, mwIndex index, const char *propname)
+{
+    //TODO
+    return NULL;
+}
+
+void mxSetProperty(mxArray *pa, mwIndex index, const char *propname, const mxArray *value)
+{
+    //TODO
+}
+
+mxArray *mxGetField(const mxArray *ptr, int lindex, const char *string)
+{
+    int field_num = mxGetFieldNumber(ptr, string);
+    if (field_num < 0)
+    {
+        return NULL;
+    }
+    return mxGetFieldByNumber(ptr, lindex, field_num);
+}
+
+void mxSetField(mxArray *array_ptr, int lindex, const char *field_name, mxArray *value)
+{
+    int field_num = mxGetFieldNumber(array_ptr, field_name);
+    if (field_num >= 0)
+    {
+        mxSetFieldByNumber(array_ptr, lindex, field_num, value);
+    }
+}
+
+int mxGetNumberOfFields(const mxArray *ptr)
+{
+    if (!mxIsStruct(ptr))
+    {
+        return 0;
+    }
+    Struct * pa = (Struct *)ptr;
+    return pa->getFieldNames()->getSize();
+}
+
+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;
+    }
+    String *names = ((Struct *)array_ptr)->getFieldNames();
+    wchar_t *name = names->get(field_number);
+    return (const char *)wide_string_to_UTF8(name);
+}
+
+int mxGetFieldNumber(const mxArray *ptr, const char *string)
+{
+    if (!mxIsStruct(ptr))
+    {
+        return -1;
+    }
+    Struct *pa = (Struct *)ptr;
+    String *names = pa->getFieldNames();
+    wchar_t *field_name = to_wide_string(string);
+
+    for (int i = 0; i < names->getSize(); i++)
+    {
+        if (wcscmp(names->get(i), field_name) == 0)
+        {
+            FREE(field_name);
+            return i;
+        }
+    }
+    FREE(field_name);
+    return -1;
+}
+
+mxArray *mxGetFieldByNumber(const mxArray *ptr, int lindex, int field_number)
+{
+    if (!mxIsStruct(ptr))
+    {
+        return NULL;
+    }
+    if (lindex >= mxGetNumberOfElements(ptr) || lindex < 0)
+    {
+        return NULL;
+    }
+    if (field_number >= mxGetNumberOfFields(ptr) || field_number < 0)
+    {
+        return NULL;
+    }
+    Struct *pa = (Struct *)ptr;
+    String *names = pa->getFieldNames();
+    SingleStruct *s = pa->get(lindex);
+    return (mxArray *)s->get(names->get(field_number));
 }
 
-bool mxIsLogicalScalarTrue(const mxArray *ptr)
+void mxSetFieldByNumber(mxArray *array_ptr, int lindex, int field_number, mxArray *value)
 {
-    if (mxIsLogicalScalar(ptr) == false)
+    if (mxIsStruct(array_ptr) && lindex < mxGetNumberOfElements(array_ptr))
     {
-        return false;
+        SingleStruct *ptr = ((Struct *)array_ptr)->get(lindex);
+        String *names = ptr->getFieldNames();
+        ptr->set(names->get(field_number), (InternalType *)value);
     }
+}
 
-    if (*mxGetLogicals(ptr) == 0)
+int mxAddField(mxArray *ptr, const char *fieldname)
+{
+    if (!mxIsStruct(ptr))
     {
-        return false;
+        return -1;
     }
-
-    return true;
+    Struct *pa = (Struct *)ptr;
+    wchar_t *wfieldname = to_wide_string(fieldname);
+    pa->addField(wfieldname);
+    return mxGetFieldNumber(ptr, fieldname);
 }
 
-bool mxIsLogicalScalar(const mxArray *ptr)
+void mxRemoveField(mxArray *pm, int fieldnumber)
 {
-    return mxIsLogical(ptr) && mxGetNumberOfElements(ptr) == 1;
+    //TODO
 }
 
-int mexPrintf(const char *format, ...)
+mxArray *mxGetCell(const mxArray *ptr, int lindex)
 {
-    // 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);
-    scilabWrite(string);
-    return 0;
+    Cell * pa = (Cell *)ptr;
+    return (mxArray *)pa->get(lindex);
 }
 
-void mexWarnMsgTxt(const char *error_msg)
+void mxSetCell(mxArray *array_ptr, int lindex, mxArray *value)
 {
-    scilabError(_("Warning: "));
-    scilabError(error_msg);
-    scilabError("\n\n");
+    ((Cell *)array_ptr)->set(lindex, (InternalType *)value);
 }
 
-int mexCallSCILAB(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name)
+int mxGetNzmax(const mxArray *ptr)
 {
-    wchar_t* pwst = to_wide_string(name);
-    symbol::Context *context = symbol::Context::getInstance();
-    symbol::Symbol *symbol = new symbol::Symbol(pwst);
-    FREE(pwst);
-
-    types::InternalType *value = context->get(*symbol);
-    types::Function *func = value->getAs<types::Function>();
-    if (func == NULL)
-    {
-        return 1;
-    }
-
-    types::typed_list in;
-    types::typed_list out;
-    types::optional_list opt;
-    for (int i = 0; i < nrhs; i++)
-    {
-        in.push_back((types::InternalType*)prhs[i]);
-    }
+    // TODO
+    return 0;
+}
 
-    func->call(in, opt, nlhs, out, NULL);
+void mxSetNzmax(mxArray *array_ptr, int nzmax)
+{
+    // TODO
+}
 
-    for (int i = 0; i < nlhs; i++)
-    {
-        plhs[i] = (mxArray *) (out[i]);
-    }
+int *mxGetIr(const mxArray *ptr)
+{
+    // TODO
+    return NULL;
+}
 
-    return 0;
+void mxSetIr(mxArray *array_ptr, int *ir_data)
+{
+    // TODO
 }
 
-int mexCallMATLAB(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name)
+int *mxGetJc(const mxArray *ptr)
 {
-    return mexCallSCILAB(nlhs, plhs, nrhs, prhs, name);
+    // TODO
+    return NULL;
 }
 
-int mxCalcSingleSubscript(const mxArray *ptr, int nsubs, const int *subs)
+void mxSetJc(mxArray *array_ptr, int *jc_data)
 {
-    int index = 0;
-    int iMult = 1;
-    int *dims = mxGetDimensions(ptr);
-    for (int i = 0; i < nsubs; i++)
-    {
-        index += subs[i] * iMult;
-        iMult *= dims[i];
-    }
-    return index;
+    // TODO
 }
 
-int C2F(mexcallscilab) (int *nlhs, mxArray **plhs, int *nrhs, mxArray **prhs, char *name, int namelen)
+void setmexFunctionName(const char* name)
 {
-    return mexCallSCILAB(*nlhs, plhs, *nrhs, prhs, name);
+    ConfigVariable::setMexFunctionName(name);
 }
 
-/** generic mex interface **/
 const char *mexFunctionName(void)
 {
-    return the_current_mex_name;
+    return ConfigVariable::getMexFunctionName().c_str();
 }
 
-int mxGetElementSize(const mxArray *ptr)
+int mexAtExit(void(*func)(void))
 {
-    if (mxIsChar(ptr))
-    {
-        return sizeof(wchar_t *);
-    }
-    else if (mxIsLogical(ptr))
-    {
-        return sizeof(int);
-    }
-    else if (mxIsDouble(ptr))
-    {
-        return sizeof(double);
-    }
-    else if (mxIsSparse(ptr))
-    {
-        // TODO: sparse
-    }
-    else if (mxIsInt8(ptr))
-    {
-        return sizeof(char);
-    }
-    else if (mxIsInt16(ptr))
-    {
-        return sizeof(short);
-    }
-    else if (mxIsInt32(ptr))
-    {
-        return sizeof(int);
-    }
-    else if (mxIsInt64(ptr))
-    {
-        return sizeof(long long);
-    }
-    else if (mxIsUint8(ptr))
-    {
-        return sizeof(unsigned char);
-    }
-    else if (mxIsUint16(ptr))
-    {
-        return sizeof(unsigned short);
-    }
-    else if (mxIsUint32(ptr))
-    {
-        return sizeof(unsigned int);
-    }
-    else if (mxIsUint64(ptr))
-    {
-        return sizeof(unsigned long long);
-    }
-    else if (mxIsCell(ptr))
-    {
-        return sizeof(types::InternalType *);
-    }
-    else if (mxIsStruct(ptr))
-    {
-        return sizeof(types::SingleStruct *);
-    }
+    exitFcn = func;
     return 0;
 }
 
-mxArray *mxCreateCharMatrixFromStrings(int m, const char **str)
+int mexCallMATLAB(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name)
 {
-    int n = 1;
-    wchar_t** strings = NULL;
-    strings = (wchar_t**)MALLOC(sizeof(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);
-    freeArrayOfWideString(strings, m);
-    return (mxArray *) ptr;
+    return mexCallSCILAB(nlhs, plhs, nrhs, prhs, name);;
+}
+
+mxArray *mexCallMATLABWithTrap(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[], const char *functionName)
+{
+    //TODO
+    return NULL;
 }
 
 int mexEvalString(const char *name)
@@ -1492,13 +1610,13 @@ int mexEvalString(const char *name)
     bool bMute = true;
     Parser parser;
     parser.parse(to_wide_string(name));
-    if (parser.getExitStatus() !=  Parser::Succeded)
+    if (parser.getExitStatus() != Parser::Succeded)
     {
         //mexPrintf(wide_string_to_UTF8(parser.getErrorMessage()));
         return 1;
     }
 
-    Exp *pExp = parser.getTree();
+    ast::Exp *pExp = parser.getTree();
 
     if (pExp == NULL)
     {
@@ -1512,26 +1630,26 @@ int mexEvalString(const char *name)
     {
         ConfigVariable::setPromptMode(-1);
     }
-    ast::exps_t LExp = pExp->getAs<SeqExp>()->getExps();
+    ast::exps_t LExp = pExp->getAs<ast::SeqExp>()->getExps();
 
-    for (ast::exps_t::iterator j = LExp.begin(), itEnd = LExp.end() ; j != itEnd ; ++j)
+    for (ast::exps_t::iterator j = LExp.begin(), itEnd = LExp.end(); j != itEnd; ++j)
     {
         try
         {
             //excecute script
-            ExecVisitor execMe;
+            ast::ExecVisitor execMe;
             (*j)->accept(execMe);
 
             //to manage call without ()
             if (execMe.getResult() != NULL && execMe.getResult()->getAs<Callable>())
             {
                 Callable *pCall = execMe.getResult()->getAs<Callable>();
-                types::typed_list out;
-                types::typed_list in;
-                types::optional_list opt;
+                typed_list out;
+                typed_list in;
+                optional_list opt;
                 try
                 {
-                    ExecVisitor execCall;
+                    ast::ExecVisitor execCall;
                     Function::ReturnValue Ret = pCall->call(in, opt, 1, out, &execCall);
                     if (Ret == Callable::OK)
                     {
@@ -1546,7 +1664,7 @@ int mexEvalString(const char *name)
                         }
                         else
                         {
-                            for (int i = 0 ; i < static_cast<int>(out.size()) ; i++)
+                            for (int i = 0; i < static_cast<int>(out.size()); i++)
                             {
                                 out[i]->DecreaseRef();
                                 execMe.setResult(i, out[i]);
@@ -1572,10 +1690,10 @@ int mexEvalString(const char *name)
                         }
                     }
                 }
-                catch (ScilabMessage sm)
+                catch (ast::ScilabMessage sm)
                 {
                     wostringstream os;
-                    PrintVisitor printMe(os);
+                    ast::PrintVisitor printMe(os);
                     (*j)->accept(printMe);
                     os << std::endl << std::endl;
                     if (ConfigVariable::getLastErrorFunction() == L"")
@@ -1616,17 +1734,17 @@ int mexEvalString(const char *name)
                 }
             }
         }
-        catch (ScilabMessage sm)
+        catch (ast::ScilabMessage sm)
         {
-            if (bErrCatch  == false && bMute == false)
+            if (bErrCatch == false && bMute == false)
             {
                 scilabErrorW(sm.GetErrorMessage().c_str());
 
-                CallExp* pCall = dynamic_cast<CallExp*>(*j);
+                ast::CallExp* pCall = dynamic_cast<ast::CallExp*>(*j);
                 if (pCall != NULL)
                 {
                     //to print call expression only of it is a macro
-                    ExecVisitor execFunc;
+                    ast::ExecVisitor execFunc;
                     pCall->getName().accept(execFunc);
 
                     if (execFunc.getResult() != NULL &&
@@ -1635,7 +1753,7 @@ int mexEvalString(const char *name)
                         wostringstream os;
 
                         //add function failed
-                        PrintVisitor printMe(os);
+                        ast::PrintVisitor printMe(os);
                         pCall->accept(printMe);
                         os << std::endl;
 
@@ -1675,523 +1793,226 @@ int mexEvalString(const char *name)
             //store message
             iErr = ConfigVariable::getLastErrorNumber();
             if (bErrCatch == false)
-            {
-                //in case of error, change mode to 2 ( prompt )
-                ConfigVariable::setPromptMode(2);
-                //write error
-                scilabErrorW(ConfigVariable::getLastErrorMessage().c_str());
-                scilabErrorW(L"\n");
-
-                //write positino
-                wchar_t szError[bsiz];
-                os_swprintf(szError, bsiz, _W("at line % 5d of exec file called by :\n").c_str(), (*j)->getLocation().first_line);
-                //restore previous prompt mode
-                ConfigVariable::setPromptMode(oldVal);
-                throw ast::ScilabMessage(szError, 1, (*j)->getLocation());
-            }
-            break;
-        }
-    }
-
-    //restore previous prompt mode
-    ConfigVariable::setPromptMode(oldVal);
-
-    delete parser.getTree();
-    return 0;
-}
-
-mxArray *mexGetArray(char *name, char *workspace)
-{
-    return mexGetVariable(workspace, name);
-}
-
-const mxArray *mexGetVariablePtr(const char *workspace, const char *var_name)
-{
-    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 *key = to_wide_string(name);
-    types::InternalType *value = NULL;
-    if (strcmp(workspace, "base") == 0)
-    {
-        value = context->get(*(new symbol::Symbol(key)));
-    }
-    else if (strcmp(workspace, "caller") == 0)
-    {
-        value = context->getCurrentLevel(*(new symbol::Symbol(key)));
-    }
-    else if (strcmp(workspace, "global") == 0)
-    {
-        value = context->getGlobalValue(*(new symbol::Symbol(key)));
-    }
-    FREE(key);
-    return (mxArray *) value;
-}
-
-int mexPutVariable(const char *workspace, const char *varname, const mxArray *pm)
-{
-    symbol::Context *context = symbol::Context::getInstance();
-    wchar_t *dest = to_wide_string(varname);
-    if (strcmp(workspace, "base") == 0)
-    {
-        context->putInPreviousScope(context->getOrCreate(symbol::Symbol(dest)), (types::InternalType *) pm);
-    }
-    else if (strcmp(workspace, "caller") == 0)
-    {
-        context->put(symbol::Symbol(dest), (types::InternalType *) pm);
-    }
-    else if (strcmp(workspace, "global") == 0)
-    {
-        context->setGlobalVisible(symbol::Symbol(dest), true);
-        context->put(symbol::Symbol(dest), (types::InternalType *) pm);
-    }
-    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)
-{
-    /* obsolete */
-    mexErrMsgTxt(_("Routine mxSetName not implemented !\n"));
-    exit(1);
-}
-
-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);
-    }
-    else if (mxIsInt16(array_ptr))
-    {
-        ((types::Int16 *) array_ptr)->set((short *) data_ptr);
-    }
-    else if (mxIsInt32(array_ptr))
-    {
-        ((types::Int32 *) array_ptr)->set((int *) data_ptr);
-    }
-    else if (mxIsInt64(array_ptr))
-    {
-        ((types::Int64 *) array_ptr)->set((long long *) data_ptr);
-    }
-    else if (mxIsLogical(array_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);
-    }
-    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);
-    }
-}
+            {
+                //in case of error, change mode to 2 ( prompt )
+                ConfigVariable::setPromptMode(2);
+                //write error
+                scilabErrorW(ConfigVariable::getLastErrorMessage().c_str());
+                scilabErrorW(L"\n");
 
-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)->setImg((unsigned short *) data_ptr);
-    }
-    else if (mxIsUint32(array_ptr))
-    {
-        ((types::UInt32 *) array_ptr)->setImg((unsigned int *) data_ptr);
-    }
-    else if (mxIsUint64(array_ptr))
-    {
-        ((types::UInt64 *) array_ptr)->setImg((unsigned long long *) data_ptr);
+                //write positino
+                wchar_t szError[bsiz];
+                os_swprintf(szError, bsiz, _W("at line % 5d of exec file called by :\n").c_str(), (*j)->getLocation().first_line);
+                //restore previous prompt mode
+                ConfigVariable::setPromptMode(oldVal);
+                throw ast::ScilabMessage(szError, 1, (*j)->getLocation());
+            }
+            break;
+        }
     }
+
+    //restore previous prompt mode
+    ConfigVariable::setPromptMode(oldVal);
+
+    delete parser.getTree();
+    return 0;
 }
 
-void mxSetPr(mxArray *ptr, double *pr)
+mxArray *mexEvalStringWithTrap(const char *command)
 {
-    ((types::Double *) ptr)->set(pr);
+    //TODO
+    return NULL;
 }
 
-void mxSetPi(mxArray *ptr, double *pi)
+const mxArray *mexGet(double handle, const char *property)
 {
-    ((types::Double *) ptr)->setImg(pi);
+    //TODO
+    return NULL;
 }
 
-const char *mxGetName(const mxArray *array_ptr)
+int mexSet(double handle, const char *property, mxArray *value)
 {
-    /* obsolete */
-    mexPrintf(_("Routine mxGetName not implemented.\n"));
-    exit(1);
+    //TODO
     return 0;
 }
 
-int mxSetDimensions(mxArray *array_ptr, const int *dims, int ndim)
+mxArray *mexGetVariable(const char *workspace, const char *name)
 {
-    if (mxIsCell(array_ptr))
-    {
-        ((types::Cell *) array_ptr)->resize((int *) dims, ndim);
-    }
-    else if (mxIsChar(array_ptr))
-    {
-        ((types::String *) array_ptr)->resize((int *) dims, ndim);
-    }
-    else if (mxIsDouble(array_ptr))
-    {
-        ((types::Double *) 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);
-    }
-    else if (mxIsInt16(array_ptr))
-    {
-        ((types::Int16 *) array_ptr)->resize((int *) dims, ndim);
-    }
-    else if (mxIsInt32(array_ptr))
-    {
-        ((types::Int32 *) array_ptr)->resize((int *) dims, ndim);
-    }
-    else if (mxIsInt64(array_ptr))
-    {
-        ((types::Int64 *) array_ptr)->resize((int *) dims, ndim);
-    }
-    else if (mxIsLogical(array_ptr))
-    {
-        ((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);
-    }
-    else if (mxIsUint8(array_ptr))
-    {
-        ((types::UInt8 *) array_ptr)->resize((int *) dims, ndim);
-    }
-    else if (mxIsUint16(array_ptr))
-    {
-        ((types::UInt16 *) array_ptr)->resize((int *) dims, ndim);
-    }
-    else if (mxIsUint32(array_ptr))
-    {
-        ((types::UInt32 *) array_ptr)->resize((int *) dims, ndim);
-    }
-    else if (mxIsUint64(array_ptr))
+    mxArray* ret = NULL;
+    const mxArray* ptr = mexGetVariablePtr(workspace, name);
+
+    if (ptr)
     {
-        ((types::UInt64 *) array_ptr)->resize((int *) dims, ndim);
+        ret = (mxArray*)((InternalType*)ptr)->clone();
     }
-
-    return 0;
+    return ret;
 }
 
-const char *mxGetClassName(const mxArray *ptr)
+const mxArray *mexGetVariablePtr(const char *workspace, const char *name)
 {
-    if (mxIsDouble(ptr))
-    {
-        return "double";
-    }
-    if (mxIsChar(ptr))
-    {
-        return "char";
-    }
-    if (mxIsSparse(ptr))
-    {
-        return "sparse";
-    }
-    if (mxIsInt8(ptr))
-    {
-        return "int8";
-    }
-    if (mxIsInt16(ptr))
-    {
-        return "int16";
-    }
-    if (mxIsInt32(ptr))
-    {
-        return "int32";
-    }
-    if (mxIsInt64(ptr))
-    {
-        return "int64";
-    }
-    if (mxIsUint8(ptr))
+    symbol::Context *context = symbol::Context::getInstance();
+    wchar_t *key = to_wide_string(name);
+    InternalType *value = NULL;
+    symbol::Symbol sym = symbol::Symbol(key);
+    if (strcmp(workspace, "base") == 0)
     {
-        return "uint8";
+        value = context->get(sym);
     }
-    if (mxIsUint16(ptr))
+    else if (strcmp(workspace, "caller") == 0)
     {
-        return "uint16";
+        if (context->isGlobalVisible(sym) == false)
+        {
+            value = context->get(sym);
+        }
     }
-    if (mxIsUint32(ptr))
+    else if (strcmp(workspace, "global") == 0)
     {
-        return "uint32";
+        if (context->isGlobalVisible(sym))
+        {
+            value = context->getGlobalValue(sym);
+        }
     }
-    if (mxIsUint64(ptr))
+    FREE(key);
+    return (mxArray *)value;
+}
+
+int mexPutVariable(const char *workspace, const char *varname, const mxArray *pm)
+{
+    symbol::Context *context = symbol::Context::getInstance();
+    wchar_t *dest = to_wide_string(varname);
+    if (strcmp(workspace, "base") == 0)
     {
-        return "uint64";
+        context->putInPreviousScope(context->getOrCreate(symbol::Symbol(dest)), (InternalType *)pm);
     }
-    if (mxIsCell(ptr))
+    else if (strcmp(workspace, "caller") == 0)
     {
-        return "cell";
+        context->put(symbol::Symbol(dest), (InternalType *)pm);
     }
-    if (mxIsStruct(ptr))
+    else if (strcmp(workspace, "global") == 0)
     {
-        return "struct";
+        context->setGlobalVisible(symbol::Symbol(dest), true);
+        context->put(symbol::Symbol(dest), (InternalType *)pm);
     }
-    if (mxIsFunction(ptr))
+    else
     {
-        return "function_handle";
+        return 1;
     }
-    return "unknown";
-}
-
-void mxSetCell(mxArray *array_ptr, int lindex, mxArray *value)
-{
-    ((types::Cell *) array_ptr)->set(lindex, (types::InternalType *) value);
-}
-
-int mxGetNzmax(const mxArray *ptr)
-{
-    // TODO: sparse
     return 0;
 }
 
-mxLogical *mxGetLogicals(const mxArray *ptr)
+int mexIsGlobal(const mxArray *ptr)
 {
-    types::InternalType *pIT = (types::InternalType *) ptr;
-    if (pIT == NULL)
-    {
-        return NULL;
-    }
+    symbol::Context *context = symbol::Context::getInstance();
+    std::list<std::wstring> lst;
+    int size = context->getGlobalNameForWho(lst, false);
 
-    types::Bool *pB = pIT->getAs<types::Bool>();
-    if (pB == NULL)
+    for (auto it : lst)
     {
-        return NULL;
+        symbol::Symbol s = symbol::Symbol(it);
+        const mxArray *value = (const mxArray *)context->getGlobalValue(s);
+        if (value == ptr)
+        {
+            return 1;
+        }
     }
-
-    return (mxLogical *) pB->get();
-}
-
-void mexInfo(char *str)
-{
-    mexPrintf("mexInfo: %s", str);
-    // FIXME : Use scilabWrite
-}
-
-int mexCheck(char *str, int nbvars)
-{
-    // FIXME : Where does Nbvars come from ??
-    // if ( nbvars != -1 && Nbvars != nbvars)
-    //     fprintf(stderr,"%s %d %d\n",str,Nbvars,nbvars);
-    // return Nbvars ;
     return 0;
 }
 
-/****************************************************
-* C functions for Fortran  mexfunctions
-****************************************************/
-
-double *C2F(mxgetpr) (mxArray *ptr)
-{
-    return mxGetPr(ptr);
-}
-
-double *C2F(mxgetpi) (mxArray *ptr)
-{
-    return mxGetPi(ptr);
-}
-
-int C2F(mxgetm) (mxArray *ptr)
-{
-    return mxGetM(ptr);
-}
-
-int C2F(mxgetn) (mxArray *ptr)
-{
-    return mxGetN(ptr);
-}
-
-int C2F(mxisstring) (mxArray *ptr)
-{
-    return mxIsString(ptr);
-}
-
-int C2F(mxisnumeric) (mxArray *ptr)
+int mexPrintf(const char *format, ...)
 {
-    return mxIsNumeric(ptr);
+    // 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);
+    scilabWrite(string);
+    return 0;
 }
 
-int C2F(mxisfull) (mxArray *ptr)
+void mexSetTrapFlag(int trapflag)
 {
-    return mxIsFull(ptr);
+    //TODO
 }
 
-int C2F(mxissparse) (mxArray *ptr)
+void mexErrMsgIdAndTxt(const char *errorid, const char *errormsg, ...)
 {
-    return mxIsSparse(ptr);
+    //TODO
 }
 
-int C2F(mxiscomplex) (mxArray *ptr)
+void mexWarnMsgIdAndTxt(const char *warningid, const char *warningmsg, ...)
 {
-    return mxIsComplex(ptr);
+    //TODO
 }
 
-double C2F(mxgetscalar) (mxArray *ptr)
+void mexErrMsgTxt(const char *error_msg)
 {
-    return mxGetScalar(ptr);
+    throw ast::ScilabError(error_msg);
 }
 
-void C2F(mexprintf) (char *error_msg, int len)
+void mexWarnMsgTxt(const char *error_msg)
 {
-    error_msg[len] = '\0';
-    mexPrintf(error_msg);
+    scilabError(_("Warning: "));
+    scilabError(error_msg);
+    scilabError("\n\n");
 }
 
-void C2F(mexerrmsgtxt) (char *error_msg, int len)
+int mexIsLocked(void)
 {
-    error_msg[len] = '\0';
-    mexErrMsgTxt(error_msg);
+    //TODO
+    return 0;
 }
 
-mxArray *C2F(mxcreatefull) (int *m, int *n, int *it)
+void mexLock(void)
 {
-    /* mxCreateFull is obsolete. Call mxCreateDoubleMatrix instead. */
-    return (mxArray *) mxCreateDoubleMatrix(*m, *n, (mxComplexity) * it);
+    //TODO
 }
 
-mxArray *C2F(mxcreatedoublematrix) (int *m, int *n, int *it)
+void mexUnlock(void)
 {
-    return (mxArray *) mxCreateDoubleMatrix(*m, *n, (mxComplexity) * it);
+    //TODO
 }
 
-unsigned long int C2F(mxcalloc) (unsigned int *n, unsigned int *size)
+void mexMakeArrayPersistent(void *ptr)
 {
-    mxCalloc(*n, *size);
-    return 0;
+    //TODO
 }
 
-int C2F(mxgetstring) (mxArray *ptr, char *str, int *strl)
+void mexMakeMemoryPersistent(void *ptr)
 {
-    return mxGetString(ptr, str, *strl);
+    //TODO
 }
 
-void C2F(mxfreematrix) (mxArray *ptr)
+double mxGetInf(void)
 {
-    mxFreeMatrix(ptr);
-}
+    InternalType *pITInf = symbol::Context::getInstance()->get(symbol::Symbol(L"%inf"));
+    if (pITInf && pITInf->isDouble())
+    {
+        return pITInf->getAs<Double>()->get(0);
+    }
 
-mxArray *C2F(mxcreatestring) (char *string, long int l)
-{
-    string[l] = '\0';
-    return mxCreateString(string);
+    return -1;
 }
 
-int C2F(mxcopyreal8toptr) (double *y, mxArray *ptr, int *n)
+double mxGetNaN(void)
 {
-    double *pr = mxGetPr(ptr);
-    memcpy(y, pr, (*n) * sizeof(double));
-    return 0;
-}
+    InternalType *pITInf = symbol::Context::getInstance()->get(symbol::Symbol(L"%nan"));
+    if (pITInf)
+    {
+        return pITInf->getAs<Double>()->get(0);
+    }
 
-int C2F(mxcopycomplex16toptr) (double *y, mxArray *ptr, mxArray *pti, int *n)
-{
-    // FIXME : Wrap this one to the C one
-    return 0;
+    return -1;
 }
 
-int C2F(mxcopyptrtoreal8) (mxArray *ptr, double *y, int *n)
+double mxGetEps(void)
 {
-    double *pr = mxGetPr(ptr);
-    memcpy(pr, y, (*n) * sizeof(double));
-    return 0;
-}
+    InternalType *pITEps = symbol::Context::getInstance()->get(symbol::Symbol(L"%eps"));
+    if (pITEps && pITEps->isDouble())
+    {
+        return pITEps->getAs<Double>()->get(0);
+    }
 
-int C2F(mxcopyptrtocomplex16) (mxArray *ptr, mxArray *pti, double *y, int *n)
-{
-    // FIXME : Wrap this one to the C one
-    return 0;
+    return -1;
 }
 
-/* *mxRealloc(void *ptr, size_t size);
-   mxArray *mxCreateStringFromNChars(const char *str, int n);
-   int mxSetClassName(mxArray *pa, const char *classname);
-   void mxRemoveField(mxArray *pa, int field);
-   void mxSetCopyInCell(mxArray *pa, int i, mxArray *value);  */
diff --git a/scilab/modules/mexlib/src/cpp/mexlib.h b/scilab/modules/mexlib/src/cpp/mexlib.h
deleted file mode 100644 (file)
index e3d369b..0000000
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2007-2008 - INRIA - Sylvestre LEDRU <sylvestre.ledru@inria.fr>
- *
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
-
-/*
- * Local declaration file for mexlib
- *
- */
-
-/**
- * TODO : comment
- * @param ptr_lstk
- * @return
- */
-vraiptrst stkptr(long int ptr_lstk);
-
-
-/**
- * TODO : comment
- * @param ptr
- * @return
- */
-int *Header(const mxArray *ptr);
-
-/**
- * TODO : comment
- * @param header
- * @return
- */
-mxArray *header2ptr(int *header);
-
-/**
- * TODO : comment
- * @param header
- * @param i
- * @return
- */
-int *listentry(int *header, int i);
-
-/**
- * TODO : comment
- * @param header
- * @return
- */
-int theMLIST(int *header);
-
-/**
- * TODO : comment
- * @param ptr
- * @return
- */
-int *RawHeader(const mxArray *ptr);
-
-/**
- * TODO : comment
- * @param ptr
- * @return
- */
-int Is1x1(const mxArray *ptr);
-
-/**
- * TODO : comment
- * @param m
- * @return
- */
-mxArray *mxCreateData(int m);
-
-/**
- * TODO : comment
- * @param expr
- * @param error_message
- */
-void mxAssert(int expr, char *error_message);
-
-/**
- * TODO : comment
- * @param ptr
- * @param nsize
- */
-void *mxRealloc(void *ptr, size_t nsize);
-
-/**
- * TODO : comment
- * @param ptr
- */
-void mexMakeMemoryPersistent(void *ptr);
-
-/**
- * TODO : comment
- * @param ptr
- * @return
- */
-int IsstOrce(mxArray *ptr);
-
-/**
- * TODO : comment
- * @param ptr
- * @param number
- * @param size
- */
-void  numberandsize(const mxArray  *ptr, int *number, int *size);
-
-/**
- * TODO : comment
- * @param ptr
- * @return
- */
-bool mexIsGlobal(const mxArray *ptr);
-
-/**
- * Unreference objects in a struct or cell
- * @param ptr
- * @return
- */
-mxArray *UnrefStruct(mxArray *ptr);
-
-/**
- * TODO : comment
- * @param m
- * @param n
- * @return
- */
-mxArray *mxCreateLogicalMatrix(int m, int n);
-
-/**
- * TODO : comment
- * @param value
- * @return
- */
-mxArray *mxCreateLogicalScalar(mxLOGICAL value);
-
-/**
- * TODO : comment
- * @param pa
- * @return
- */
-bool mxIsLogicalScalarTrue(mxArray *pa);
-
-/**
- * TODO : comment
- * @param pa
- * @return
- */
-bool mxIsLogicalScalar(mxArray *pa);
-
-/**
- * TODO : comment
- * @return
- */
-const char *mexFunctionName(void);
-
-/**
- * TODO : comment
- * @param array_ptr
- * @param workspace
- * @return
- */
-int mexPutArray(mxArray *array_ptr, char *workspace);
-
-/**
- * TODO : comment
- * @param workspace
- * @param var_name
- * @param array_ptr
- * @return
- */
-int mexPutVariable(const char *workspace, char *var_name, mxArray *array_ptr);
-
-/**
- * TODO : comment
- * @param ptr
- * @return
- */
-const char *mxGetClassName(const mxArray *ptr);
-
-/**
- * TODO : comment
- * @param m
- * @param n
- * @param it
- * @return
- */
-mxArray *C2F(mxcreatedoublematrix)(int *m, int *n, int *it);
-
-/**
- * TODO : comment
- * @param y
- * @param ptr
- * @param pti
- * @param n
- * @return
- */
-int C2F(mxcopycomplex16toptr)(double *y, mxArray *ptr, mxArray *pti, int *n);
-
-/**
- * TODO : comment
- * @param ptr
- * @param pti
- * @param y
- * @param n
- * @return
- */
-int C2F(mxcopyptrtocomplex16)(mxArray *ptr, mxArray *pti, double *y, int *n);
index f2b2390..18d9fd0 100644 (file)
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
@@ -235,7 +235,6 @@ cd ..
   <ItemGroup>
     <ClInclude Include="..\..\includes\mex.h" />
     <ClInclude Include="..\..\includes\sci_gateway.h" />
-    <ClInclude Include="..\cpp\mexlib.h" />
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="libmat.rc" />
index 8e08ce3..eebba8e 100644 (file)
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
     <Filter Include="Source Files">
@@ -24,9 +24,6 @@
     <ClInclude Include="..\..\includes\sci_gateway.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\cpp\mexlib.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="libmat.rc">
index c84b2d4..1bbe651 100644 (file)
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
@@ -238,7 +238,6 @@ cd ..
   <ItemGroup>
     <ClInclude Include="..\..\includes\mex.h" />
     <ClInclude Include="..\..\includes\sci_gateway.h" />
-    <ClInclude Include="..\cpp\mexlib.h" />
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="libmex.rc" />
index 28c03c3..a60eee8 100644 (file)
@@ -35,9 +35,6 @@
     <ClInclude Include="..\..\includes\sci_gateway.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\cpp\mexlib.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="libmex.rc">
index 0e11ef5..eb2baad 100644 (file)
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
@@ -236,7 +236,6 @@ cd ..
   <ItemGroup>
     <ClInclude Include="..\..\includes\mex.h" />
     <ClInclude Include="..\..\includes\sci_gateway.h" />
-    <ClInclude Include="..\cpp\mexlib.h" />
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="libmx.rc" />
index 0234534..0e78309 100644 (file)
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
     <Filter Include="Source Files">
@@ -24,9 +24,6 @@
     <ClInclude Include="..\..\includes\sci_gateway.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\cpp\mexlib.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="libmx.rc">
index e84f9c1..8d84522 100644 (file)
@@ -4,31 +4,32 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
+//
+// <-- JVM NOT MANDATORY -->
+//
+// =============================================================================
 // <-- Non-regression test for bug 5292 -->
 //
 // <-- Bugzilla URL -->
 // http://bugzilla.scilab.org/show_bug.cgi?id=5292
 //
 // <-- Short Description -->
-// There is a conflict between bool and scilab header mex.h 
-ilib_verbose(0);
-my_current_directory = pwd();
+// There is a conflict between bool and scilab header mex.h
 cd(TMPDIR);
-mputl('ilib_mex_build(''libmex'',[''mex_5292'',''mexfunction_5292'',''cmex''],[''mexfunction_5292.cpp''],[],'''','''','''','''')','builder.sce');
-mputl(["#include <mex.h>"
+ilib_verbose(0);
+mputl([ "#include <mex.h>"
 "#include <list>"
 "#include <memory.h>"
+""
 "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])"
 "{"
-"  if(nrhs < 2)"
-"    mexErrMsgTxt(""Two input arguments required."");"
-"  if (nlhs > 1)"
-"   mexErrMsgTxt(""Too many output arguments."");"
-"}"],'mexfunction_5292.cpp');
-exec('builder.sce');
-exec('loader.sce');
-ierr = execstr('mex_5292()','errcatch');
-if ierr <> 999 then bugmes();quit;end
-ierr = execstr('mex_5292(2,2)','errcatch');
-if ierr <> 0 then bugmes();quit;end
-cd(my_current_directory);
+"    if(nrhs < 2)"
+"        mexErrMsgTxt(""Two input arguments required."");"
+"    if (nlhs > 1)"
+"        mexErrMsgTxt(""Too many output arguments."");"
+"}"],"mexfunction_5292.cpp");
+ilib_mex_build("libmextest", ["mex_5292", "mexfunction_5292", "cmex"], "mexfunction_5292.cpp", []);
+exec("loader.sce");
+assert_checkerror("mex_5292()", [], 999);
+ierr = execstr("mex_5292(2,2)","errcatch");
+assert_checktrue(ierr == 0);
index 75be34a..a394fed 100644 (file)
@@ -4,40 +4,34 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
-
+//
+// <-- JVM NOT MANDATORY -->
+//
+// =============================================================================
 // <-- Non-regression test for bug 5292 -->
 //
 // <-- Bugzilla URL -->
 // http://bugzilla.scilab.org/show_bug.cgi?id=5292
 //
 // <-- Short Description -->
-// There is a conflict between bool and scilab header mex.h 
+// There is a conflict between bool and scilab header mex.h
 
-ilib_verbose(0);
-
-my_current_directory = pwd();
 cd(TMPDIR);
-mputl('ilib_mex_build(''libmex'',[''mex_5292'',''mexfunction_5292'',''cmex''],[''mexfunction_5292.cpp''],[],'''','''','''','''')','builder.sce');
-
-mputl(["#include <mex.h>"
+ilib_verbose(0);
+mputl([ "#include <mex.h>"
 "#include <list>"
 "#include <memory.h>"
-
+""
 "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])"
 "{"
-"  if(nrhs < 2)"
-"    mexErrMsgTxt(""Two input arguments required."");"
-"  if (nlhs > 1)"
-"   mexErrMsgTxt(""Too many output arguments."");"
-"}"],'mexfunction_5292.cpp');
-
-exec('builder.sce');
-exec('loader.sce');
-
-ierr = execstr('mex_5292()','errcatch');
-if ierr <> 999 then pause,end
-
-ierr = execstr('mex_5292(2,2)','errcatch');
-if ierr <> 0 then pause,end
-
-cd(my_current_directory);
+"    if(nrhs < 2)"
+"        mexErrMsgTxt(""Two input arguments required."");"
+"    if (nlhs > 1)"
+"        mexErrMsgTxt(""Too many output arguments."");"
+"}"],"mexfunction_5292.cpp");
+ilib_mex_build("libmextest", ["mex_5292", "mexfunction_5292", "cmex"], "mexfunction_5292.cpp", []);
+exec("loader.sce");
+
+assert_checkerror("mex_5292()", [], 999);
+ierr = execstr("mex_5292(2,2)","errcatch");
+assert_checktrue(ierr == 0);
index cb67af9..f09a5cd 100644 (file)
@@ -4,6 +4,10 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
+//
+// <-- JVM NOT MANDATORY -->
+//
+// =============================================================================
 // <-- Non-regression test for bug 614 -->
 //
 // <-- Bugzilla URL -->
 //    double format.
 //
 //    Also occur in other OS's.
-ilib_verbose(0);
-my_current_directory = pwd();
 cd(TMPDIR);
-mputl("ilib_mex_build(""libmextest"",[""mexf16"",""mexfunction16"",""cmex""],[""mexfunction16.c""],[],[],"""","""","""")","builder.sce");
-mputl([
-"#include ""mex.h"""
+ilib_verbose(0);
+mputl([ "#include <mex.h>"
 "void mexFunction(nlhs, plhs, nrhs, prhs)"
 "     int nlhs, nrhs;"
 "     mxArray *plhs[]; mxArray *prhs[];"
 "{"
 "  int *dims = mxGetDimensions(prhs[0]);"
 "  sciprint(""%d %d %d\n"",dims[0],dims[1],dims[2]);"
-"}"
-],"mexfunction16.c");
-exec("builder.sce");
+"}"],"mexfunction16.c");
+ilib_mex_build("libmextest", ["mexf16", "mexfunction16", "cmex"], "mexfunction16.c", []);
 exec("loader.sce");
-mexf16(rand(2,3,2))
-2 3 2
-cd(my_current_directory);
+mexf16(rand(8,12,5))
+8 12 5
index 92d7da3..0751072 100644 (file)
@@ -4,7 +4,10 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
-
+//
+// <-- JVM NOT MANDATORY -->
+//
+// =============================================================================
 // <-- Non-regression test for bug 614 -->
 //
 // <-- Bugzilla URL -->
 //
 //    Also occur in other OS's.
 
-ilib_verbose(0);
-
-my_current_directory = pwd();
 cd(TMPDIR);
-mputl("ilib_mex_build(""libmextest"",[""mexf16"",""mexfunction16"",""cmex""],[""mexfunction16.c""],[],[],"""","""","""")","builder.sce");
+ilib_verbose(0);
 
-mputl([
-"#include ""mex.h"""
+mputl([ "#include <mex.h>"
 "void mexFunction(nlhs, plhs, nrhs, prhs)"
 "     int nlhs, nrhs;"
 "     mxArray *plhs[]; mxArray *prhs[];"
 "{"
 "  int *dims = mxGetDimensions(prhs[0]);"
 "  sciprint(""%d %d %d\n"",dims[0],dims[1],dims[2]);"
-"}"
-],"mexfunction16.c");
-
-exec("builder.sce");
+"}"],"mexfunction16.c");
+ilib_mex_build("libmextest", ["mexf16", "mexfunction16", "cmex"], "mexfunction16.c", []);
 exec("loader.sce");
 
-mexf16(rand(2,3,2))
-
-cd(my_current_directory);
+mexf16(rand(8,12,5))
index 2d2b2a6..e54449a 100644 (file)
@@ -4,9 +4,9 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
-
+//
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
+//
 // <-- NOT FIXED -->
 // ============================================================================
 // Unitary tests for mexAtExit mex function
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void callAtExit()';
-       '{';
-       '    mexPrintf(""The mexAtExit function works!"");';
-       '}';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mexAtExit(&callAtExit);';
-       '}'],'mexatExit.c');
-ilib_mex_build('libmextest',['atExit','mexatExit','cmex'], 'mexatExit.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void callAtExit()";
+"{";
+"    mexPrintf(""The mexAtExit function works!"");";
+"}";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mexAtExit(&callAtExit);";
+"}"],"mexatExit.c");
+ilib_mex_build("libmextest",["atExit","mexatExit","cmex"], "mexatExit.c",[]);
+exec("loader.sce");
 
 atExit()
index 4ccd92f..8fd531e 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl([ "#include ""mex.h""";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "    mexCallMATLAB(nlhs, plhs, nrhs, prhs, ""sum"");";
-        "}"],"mexcallMATLAB.c");
-ilib_mex_build("libmextest", ["callMATLAB", "mexcallMATLAB", "cmex"], "mexcallMATLAB.c", [], "", "", "", "");
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mexCallMATLAB(nlhs, plhs, nrhs, prhs, ""sum"");";
+"}"],"mexcallMATLAB.c");
+ilib_mex_build("libmextest", ["callMATLAB", "mexcallMATLAB", "cmex"], "mexcallMATLAB.c", []);
 exec("loader.sce");
 res = callMATLAB([1 2 3 4]);
 assert_checkequal(res, 10);
index ef943c9..5c83e70 100644 (file)
@@ -17,7 +17,7 @@ mputl([ "#include ""mex.h""";
 "{";
 "    mexCallMATLAB(nlhs, plhs, nrhs, prhs, ""sum"");";
 "}"],"mexcallMATLAB.c");
-ilib_mex_build("libmextest", ["callMATLAB", "mexcallMATLAB", "cmex"], "mexcallMATLAB.c", [], "", "", "", "");
+ilib_mex_build("libmextest", ["callMATLAB", "mexcallMATLAB", "cmex"], "mexcallMATLAB.c", []);
 exec("loader.sce");
 
 res = callMATLAB([1 2 3 4]);
index a2df41a..f3a2768 100644 (file)
@@ -4,9 +4,9 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
-
+//
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
+//
 // <-- INTERACTIVE TEST -->
 // ============================================================================
 // Unitary tests for mexErrMsgTxt mex function
@@ -16,12 +16,12 @@ cd(TMPDIR);
 
 ilib_verbose(0);
 
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mexErrMsgTxt(""An useless error message!"");';
-       '}'],'mexerrMsgTxt.c');
-ilib_mex_build('libmextest',['errMsgTxt','mexerrMsgTxt','cmex'], 'mexerrMsgTxt.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mexErrMsgTxt(""An useless error message!"");";
+"}"],"mexerrMsgTxt.c");
+ilib_mex_build("libmextest",["errMsgTxt","mexerrMsgTxt","cmex"], "mexerrMsgTxt.c",[]);
+exec("loader.sce");
 
 errMsgTxt()
index c46359a..daf93ff 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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",[],"","","","");
+"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",[]);
 exec("loader.sce");
 r = evalString("printf ""mexEvalString works!\n"";");
 mexEvalString works!
index 2f15fa9..0be0149 100644 (file)
@@ -18,7 +18,7 @@ mputl(["#include ""mex.h""";
 "    char *string = mxArrayToString(prhs[0]);";
 "    plhs[0] = mxCreateDoubleScalar(mexEvalString(string));";
 "}"],"mexevalString.c");
-ilib_mex_build("libmextest",["evalString","mexevalString","cmex"], "mexevalString.c",[],"","","","");
+ilib_mex_build("libmextest",["evalString","mexevalString","cmex"], "mexevalString.c",[]);
 exec("loader.sce");
 
 r = evalString("printf ""mexEvalString works!\n"";");
index f8a5052..6954581 100644 (file)
@@ -1,39 +1,23 @@
-
 // ============================================================================
-
 // 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 mexFunctionName mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mexPrintf(""%s"", mexFunctionName());';
-       '}'],'mexfunctionName.c');
-
-ilib_mex_build('libmex',['func','mexfunctionName','cmex'], 'mexfunctionName.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mexPrintf(""%s\n"", mexFunctionName());";
+"}"],"mexfunctionName.c");
+ilib_mex_build("libmextest",["func","mexfunctionName","cmex"], "mexfunctionName.c",[]);
+exec("loader.sce");
 func();
-func
\ No newline at end of file
+func
index 42a8623..6059ee3 100644 (file)
@@ -4,23 +4,22 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
-
+//
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
-// <-- NOT FIXED -->
+//
 // ============================================================================
 // Unitary tests for mexFunctionName mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mexPrintf(""%s"", mexFunctionName());';
-       '}'],'mexfunctionName.c');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mexPrintf(""%s\n"", mexFunctionName());";
+"}"],"mexfunctionName.c");
 
-ilib_mex_build('libmex',['func','mexfunctionName','cmex'], 'mexfunctionName.c',[],'Makelib','','','');
-exec('loader.sce');
+ilib_mex_build("libmextest",["func","mexfunctionName","cmex"], "mexfunctionName.c",[]);
+exec("loader.sce");
 
 func();
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexGetArray.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexGetArray.dia.ref
deleted file mode 100644 (file)
index 4f1ba47..0000000
+++ /dev/null
@@ -1,58 +0,0 @@
-
-// ============================================================================
-
-// 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);
-
-ilib_verbose(0);
-
-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.tst b/scilab/modules/mexlib/tests/unit_tests/mexGetArray.tst
deleted file mode 100644 (file)
index 7fd1b82..0000000
+++ /dev/null
@@ -1,35 +0,0 @@
-// ============================================================================
-// 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);
-ilib_verbose(0);
-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
index bedcb06..77e9622 100644 (file)
@@ -1,58 +1,42 @@
-
 // ============================================================================
-
 // 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);
-
 ilib_verbose(0);
-
-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');
-
+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", []);
+exec("loader.sce");
+//create a global var
 global globalvar;
-
 globalvar = "my global var";
-
+//create a global var and hide it
+global globalvar2;
+globalvar2 = "my global var2";
+clear globalvar2;
+//create a local 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
-
+assert_checkequal(getVariable("global", "globalvar"), "my global var");
+assert_checkequal(getVariable("caller", "globalvar"), "NULL");
+assert_checkequal(getVariable("base", "globalvar"), "my global var");
+assert_checkequal(getVariable("global", "callervar"), "NULL");
+assert_checkequal(getVariable("caller", "callervar"), "my caller var");
+assert_checkequal(getVariable("base", "callervar"), "my caller var");
+assert_checkequal(getVariable("global", "globalvar2"), "NULL");
+assert_checkequal(getVariable("caller", "globalvar2"), "NULL");
+assert_checkequal(getVariable("base", "globalvar2"), "NULL");
index 7f02ee1..d0436bf 100644 (file)
@@ -4,32 +4,46 @@
 //
 //  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);
 ilib_verbose(0);
-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');
+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", []);
+exec("loader.sce");
 
+//create a global var
 global globalvar;
 globalvar = "my global var";
+
+//create a global var and hide it
+global globalvar2;
+globalvar2 = "my global var2";
+clear globalvar2;
+
+//create a local 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
+
+assert_checkequal(getVariable("global", "globalvar"), "my global var");
+assert_checkequal(getVariable("caller", "globalvar"), "NULL");
+assert_checkequal(getVariable("base", "globalvar"), "my global var");
+
+assert_checkequal(getVariable("global", "callervar"), "NULL");
+assert_checkequal(getVariable("caller", "callervar"), "my caller var");
+assert_checkequal(getVariable("base", "callervar"), "my caller var");
+
+assert_checkequal(getVariable("global", "globalvar2"), "NULL");
+assert_checkequal(getVariable("caller", "globalvar2"), "NULL");
+assert_checkequal(getVariable("base", "globalvar2"), "NULL");
index f1a1c41..73a05d5 100644 (file)
@@ -1,58 +1,42 @@
-
 // ============================================================================
-
 // 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);
-
 ilib_verbose(0);
-
-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');
-
+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", []);
+exec("loader.sce");
+//create a global var
 global globalvar;
-
 globalvar = "my global var";
-
+//create a global var and hide it
+global globalvar2;
+globalvar2 = "my global var2";
+clear globalvar2;
+//create a local 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
-
+assert_checkequal(getVariablePtr("global", "globalvar"), "my global var");
+assert_checkequal(getVariablePtr("caller", "globalvar"), "NULL");
+assert_checkequal(getVariablePtr("base", "globalvar"), "my global var");
+assert_checkequal(getVariablePtr("global", "callervar"), "NULL");
+assert_checkequal(getVariablePtr("caller", "callervar"), "my caller var");
+assert_checkequal(getVariablePtr("base", "callervar"), "my caller var");
+assert_checkequal(getVariablePtr("global", "globalvar2"), "NULL");
+assert_checkequal(getVariablePtr("caller", "globalvar2"), "NULL");
+assert_checkequal(getVariablePtr("base", "globalvar2"), "NULL");
index 5fa2087..9ef8308 100644 (file)
@@ -4,32 +4,46 @@
 //
 //  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);
 ilib_verbose(0);
-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');
+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", []);
+exec("loader.sce");
 
+//create a global var
 global globalvar;
 globalvar = "my global var";
+
+//create a global var and hide it
+global globalvar2;
+globalvar2 = "my global var2";
+clear globalvar2;
+
+//create a local 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
+
+assert_checkequal(getVariablePtr("global", "globalvar"), "my global var");
+assert_checkequal(getVariablePtr("caller", "globalvar"), "NULL");
+assert_checkequal(getVariablePtr("base", "globalvar"), "my global var");
+
+assert_checkequal(getVariablePtr("global", "callervar"), "NULL");
+assert_checkequal(getVariablePtr("caller", "callervar"), "my caller var");
+assert_checkequal(getVariablePtr("base", "callervar"), "my caller var");
+
+assert_checkequal(getVariablePtr("global", "globalvar2"), "NULL");
+assert_checkequal(getVariablePtr("caller", "globalvar2"), "NULL");
+assert_checkequal(getVariablePtr("base", "globalvar2"), "NULL");
index 465ac04..73636d9 100644 (file)
@@ -1,47 +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 mexIsGlobal mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-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');
-
+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", []);
+exec("loader.sce");
 global globalvar;
-
 globalvar = 1;
-
 localvar = "s";
-
-if isGlobal(globalvar) <> %t then pause end
-
-if isGlobal(localvar) <> %f then pause end
-
+assert_checktrue(isGlobal(globalvar));
+assert_checkfalse(isGlobal(localvar));
index 2da037d..a5497f4 100644 (file)
@@ -4,25 +4,25 @@
 //
 //  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);
 ilib_verbose(0);
-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');
+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", []);
+exec("loader.sce");
 
 global globalvar;
 globalvar = 1;
 localvar = "s";
-if isGlobal(globalvar) <> %t then pause end
-if isGlobal(localvar) <> %f then pause end
+assert_checktrue(isGlobal(globalvar));
+assert_checkfalse(isGlobal(localvar));
index 8764c52..591084d 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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", [], "", "", "", "");
+"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", []);
 exec("loader.sce");
 mprintf();
 The quick brown fox jumps over the lazy dog.
index 118103c..80e3d54 100644 (file)
@@ -19,7 +19,7 @@ mputl([ "#include ""mex.h""";
 "    mexPrintf(""Some UTF-8 chars are áãâéíóúü.\n"");";
 "    mexPrintf(""Printing %s %s."", ""with"", ""parameters"");";
 "}"],"mexprintf.c");
-ilib_mex_build("libmextest", ["mprintf", "mexprintf", "cmex"], "mexprintf.c", [], "", "", "", "");
+ilib_mex_build("libmextest", ["mprintf", "mexprintf", "cmex"], "mexprintf.c", []);
 exec("loader.sce");
 
 mprintf();
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexPutFull.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mexPutFull.dia.ref
deleted file mode 100644 (file)
index b089ac2..0000000
+++ /dev/null
@@ -1,32 +0,0 @@
-// ============================================================================
-// 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 -->
-// ============================================================================
-// Unitary tests for mexPutFull mex function
-// ============================================================================
-cd(TMPDIR);
-ilib_verbose(0);
-mputl([ "#include ""mex.h""";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "    double pr[2] = {2, 5};";
-        "    double pi[2] = {3, 0};";
-        "    mexPutFull(""var1"", 2, 1, pr, NULL);";
-        "    plhs[0] = mexGetVariable(""caller"", ""var1"");";
-        "    mexPutFull(""var2"", 1, 2, pr, pi);";
-        "    plhs[1] = mexGetVariable(""caller"", ""var2"");";
-        "}"],"mexputFull.c");
-ilib_mex_build("libmextest", ["putFull", "mexputFull", "cmex"], "mexputFull.c", [], "", "", "", "");
-exec("loader.sce");
-[out1, out2] = putFull();
-assert_checktrue(exists("var1")==1);
-assert_checktrue(exists("var2")==1);
-assert_checkequal(out1(1), 2);
-assert_checkequal(out1(2), 5);
-assert_checkequal(out2(1), complex(2, 3));
-assert_checkequal(real(out2(2)), 5);
-assert_checkequal(imag(out2(2)), 0);
diff --git a/scilab/modules/mexlib/tests/unit_tests/mexPutFull.tst b/scilab/modules/mexlib/tests/unit_tests/mexPutFull.tst
deleted file mode 100644 (file)
index 5ef33af..0000000
+++ /dev/null
@@ -1,35 +0,0 @@
-// ============================================================================
-// 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 -->
-// ============================================================================
-// Unitary tests for mexPutFull mex function
-// ============================================================================
-
-cd(TMPDIR);
-ilib_verbose(0);
-mputl([ "#include ""mex.h""";
-"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-"{";
-"    double pr[2] = {2, 5};";
-"    double pi[2] = {3, 0};";
-"    mexPutFull(""var1"", 2, 1, pr, NULL);";
-"    plhs[0] = mexGetVariable(""caller"", ""var1"");";
-"    mexPutFull(""var2"", 1, 2, pr, pi);";
-"    plhs[1] = mexGetVariable(""caller"", ""var2"");";
-"}"],"mexputFull.c");
-ilib_mex_build("libmextest", ["putFull", "mexputFull", "cmex"], "mexputFull.c", [], "", "", "", "");
-exec("loader.sce");
-
-[out1, out2] = putFull();
-assert_checktrue(exists("var1")==1);
-assert_checktrue(exists("var2")==1);
-assert_checkequal(out1(1), 2);
-assert_checkequal(out1(2), 5);
-assert_checkequal(out2(1), complex(2, 3));
-assert_checkequal(real(out2(2)), 5);
-assert_checkequal(imag(out2(2)), 0);
index 639f25f..ea3a717 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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", [], "", "", "", "");
+"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", []);
 exec("loader.sce");
 global globalvar;
 putVariable("global", "globalvar", 32);
index 30c5b77..19a507c 100644 (file)
@@ -19,7 +19,7 @@ mputl([ "#include ""mex.h""";
 "    char *name = mxArrayToString(prhs[1]);";
 "    mxArray *pOut = mexPutVariable(workspace, name, prhs[2]);";
 "}"],"mexputVariable.c");
-ilib_mex_build("libmextest", ["putVariable", "mexputVariable", "cmex"], "mexputVariable.c", [], "", "", "", "");
+ilib_mex_build("libmextest", ["putVariable", "mexputVariable", "cmex"], "mexputVariable.c", []);
 exec("loader.sce");
 
 global globalvar;
index a0fbfd1..a1fe4a2 100644 (file)
@@ -4,19 +4,21 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
-// <-- JVM NOT MANDATORY -->
+//
 // <-- ENGLISH IMPOSED -->
+// <-- JVM NOT MANDATORY -->
+//
 // ============================================================================
 // Unitary tests for mexWarnMsgTxt mex function
 // ============================================================================
 cd(TMPDIR);
 ilib_verbose(0);
 mputl(["#include ""mex.h""";
-       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-       "{";
-       "    mexWarnMsgTxt(""If you read this message, mexWarnMsgTxt works!"");";
-       "}"],"mexwarnMsgTxt.c");
-ilib_mex_build("libmextest",["warnMsgTxt","mexwarnMsgTxt","cmex"], "mexwarnMsgTxt.c",[],"","","","");
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mexWarnMsgTxt(""If you read this message, mexWarnMsgTxt works!"");";
+"}"],"mexwarnMsgTxt.c");
+ilib_mex_build("libmextest",["warnMsgTxt","mexwarnMsgTxt","cmex"], "mexwarnMsgTxt.c",[]);
 exec("loader.sce");
 warnMsgTxt()
 Warning: If you read this message, mexWarnMsgTxt works!
index b51f78f..1be8079 100644 (file)
@@ -4,9 +4,10 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
-
-// <-- JVM NOT MANDATORY -->
+//
 // <-- ENGLISH IMPOSED -->
+// <-- JVM NOT MANDATORY -->
+//
 // ============================================================================
 // Unitary tests for mexWarnMsgTxt mex function
 // ============================================================================
@@ -20,7 +21,7 @@ mputl(["#include ""mex.h""";
 "{";
 "    mexWarnMsgTxt(""If you read this message, mexWarnMsgTxt works!"");";
 "}"],"mexwarnMsgTxt.c");
-ilib_mex_build("libmextest",["warnMsgTxt","mexwarnMsgTxt","cmex"], "mexwarnMsgTxt.c",[],"","","","");
+ilib_mex_build("libmextest",["warnMsgTxt","mexwarnMsgTxt","cmex"], "mexwarnMsgTxt.c",[]);
 exec("loader.sce");
 
 warnMsgTxt()
index 75291e5..dfea902 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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", [], "", "", "", "");
+"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", []);
 exec("loader.sce");
 s = struct();
 addField(s);
index b4e84af..4068375 100644 (file)
@@ -19,7 +19,7 @@ mputl([ "#include ""mex.h""";
 "    int fieldnumber = mxAddField(ptr, ""another"");";
 "    mxSetFieldByNumber(ptr, 0, fieldnumber, mxCreateDoubleScalar(3));";
 "}"],"mexaddField.c");
-ilib_mex_build("libmextest", ["addField", "mexaddField", "cmex"], "mexaddField.c", [], "", "", "", "");
+ilib_mex_build("libmextest", ["addField", "mexaddField", "cmex"], "mexaddField.c", []);
 exec("loader.sce");
 
 s = struct();
index 183d587..81d5e32 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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", [], "", "", "", "");
+"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", []);
 exec("loader.sce");
 arrayToString("hello world");
 hello world
index 634b3fb..a941135 100644 (file)
@@ -18,7 +18,7 @@ mputl([ "#include ""mex.h""";
 "    char *str = mxArrayToString(prhs[0]);";
 "    mexPrintf(""%s"", str);";
 "}"],"mexArrayToString.c");
-ilib_mex_build("libmextest", ["arrayToString", "mexArrayToString", "cmex"], "mexArrayToString.c", [], "", "", "", "");
+ilib_mex_build("libmextest", ["arrayToString", "mexArrayToString", "cmex"], "mexArrayToString.c", []);
 exec("loader.sce");
 
 arrayToString("hello world");
index 7eecf6d..476a8e0 100644 (file)
@@ -4,9 +4,9 @@
 //
 //  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);
 ilib_verbose(0);
-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');
+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",[],"","","-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');
+assert(1, "This is true");
+assert(0, "This is false and throws an exception.");
+assert(1, "This assert is never executed");
index f3230df..c4c3183 100644 (file)
@@ -4,9 +4,9 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
-
+//
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
+//
 // <-- INTERACTIVE TEST -->
 // ============================================================================
 // Unitary tests for mxAssertS mex function
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxAssertS(mxGetScalar(prhs[0]), mxGetChars(prhs[1]));';
-       '}'],'mexAssertS.c');
-ilib_mex_build('libmextest',['assertS','mexAssertS','cmex'], 'mexAssertS.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mxAssertS(mxGetScalar(prhs[0]), mxGetChars(prhs[1]));";
+"}"],"mexAssertS.c");
+ilib_mex_build("libmextest",["assertS","mexAssertS","cmex"], "mexAssertS.c",[]);
+exec("loader.sce");
 
-assertS(1, 'This is true');
-assertS(0, 'This is false and throws an exception.');
-assertS(1, 'This assert is never executed');
+assertS(1, "This is true");
+assertS(0, "This is false and throws an exception.");
+assertS(1, "This assert is never executed");
index 56d2446..06f7f2b 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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", [], "", "", "", "");
+"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", []);
 exec("loader.sce");
 a = zeros(3, 3);
 r = calcSingleSubscript(a, 2, int32([0 0]));
index 1c127a9..51f1064 100644 (file)
@@ -19,7 +19,7 @@ mputl([ "#include ""mex.h""";
 "    int ndim = mxGetScalar(prhs[1]);";
 "    plhs[0] = mxCreateDoubleScalar(mxCalcSingleSubscript(prhs[0], ndim, dims));";
 "}"],"mexcalcSingleSubscript.c");
-ilib_mex_build("libmextest", ["calcSingleSubscript", "mexcalcSingleSubscript", "cmex"], "mexcalcSingleSubscript.c", [], "", "", "", "");
+ilib_mex_build("libmextest", ["calcSingleSubscript", "mexcalcSingleSubscript", "cmex"], "mexcalcSingleSubscript.c", []);
 exec("loader.sce");
 
 a = zeros(3, 3);
index 1d0a98a..504dbc6 100644 (file)
@@ -25,9 +25,6 @@ mputl(["#include ""mex.h""";
 "    if (mxIsDouble(prhs[0])) {";
 "        mexPrintf(""double"");";
 "    }"
-"    if (mxIsFunction(prhs[0])) {";
-"        mexPrintf(""function_handle"");";
-"    }"
 "    if (mxIsInt8(prhs[0])) {";
 "        mexPrintf(""int8"");";
 "    }"
@@ -62,7 +59,7 @@ mputl(["#include ""mex.h""";
 "        mexPrintf(""uint64"");";
 "    }"
 "}"],"mexcheckTypes.c");
-ilib_mex_build("libmextest",["printClass","mexcheckTypes","cmex"], "mexcheckTypes.c",[],"","","","");
+ilib_mex_build("libmextest",["printClass","mexcheckTypes","cmex"], "mexcheckTypes.c",[]);
 exec("loader.sce");
 printClass(cell());
 cell
@@ -70,8 +67,6 @@ printClass("s");
 char
 printClass(1);
 double
-printClass(sum);
-function_handle
 printClass(int8(1));
 int8
 printClass(int16(1));
index db8a7d2..6d4111e 100644 (file)
@@ -27,9 +27,6 @@ mputl(["#include ""mex.h""";
 "    if (mxIsDouble(prhs[0])) {";
 "        mexPrintf(""double"");";
 "    }"
-"    if (mxIsFunction(prhs[0])) {";
-"        mexPrintf(""function_handle"");";
-"    }"
 "    if (mxIsInt8(prhs[0])) {";
 "        mexPrintf(""int8"");";
 "    }"
@@ -65,13 +62,12 @@ mputl(["#include ""mex.h""";
 "    }"
 "}"],"mexcheckTypes.c");
 
-ilib_mex_build("libmextest",["printClass","mexcheckTypes","cmex"], "mexcheckTypes.c",[],"","","","");
+ilib_mex_build("libmextest",["printClass","mexcheckTypes","cmex"], "mexcheckTypes.c",[]);
 exec("loader.sce");
 
 printClass(cell());
 printClass("s");
 printClass(1);
-printClass(sum);
 printClass(int8(1));
 printClass(int16(1));
 printClass(int32(1));
index f204feb..4947c6d 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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",[],"","","","");
+"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",[]);
 exec("loader.sce");
 [out1, out2] = createCell();
 assert_checkequal(size(out1), [2, 2]);
index ddc7932..13e768f 100644 (file)
@@ -21,7 +21,7 @@ mputl(["#include ""mex.h""";
 "    plhs[0] = pOut1;";
 "    plhs[1] = pOut2;";
 "}"],"mexCreateCell.c");
-ilib_mex_build("libmextest",["createCell","mexCreateCell","cmex"], "mexCreateCell.c",[],"","","","");
+ilib_mex_build("libmextest",["createCell","mexCreateCell","cmex"], "mexCreateCell.c",[]);
 exec("loader.sce");
 
 [out1, out2] = createCell();
index 6c1b47d..b5787d8 100644 (file)
@@ -1,50 +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 mxCreateCharArray mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       '#include <wchar.h>';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    int dims[2] = {1, 1};';
-       '    mxArray *pOut1 = mxCreateCharArray(2, dims);';
-       '    plhs[0] = pOut1;';
-       '    wchar_t *data[1];';
-       '    data[0] = L""hello world"";';
-       '    mxArray *pOut2 = mxCreateCharArray(2, dims);';
-       '    mxSetData(pOut2, data);';
-       '    plhs[1] = pOut2;';
-       '}'],'mexcreateCharArray.c');
-
-ilib_mex_build('libmextest',['createCharArray','mexcreateCharArray','cmex'], 'mexcreateCharArray.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+"#include <wchar.h>";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    int dims[2] = {1, 1};";
+"    mxArray *pOut1 = mxCreateCharArray(2, dims);";
+"    plhs[0] = pOut1;";
+"    wchar_t *data[1];";
+"    data[0] = L""hello world"";";
+"    mxArray *pOut2 = mxCreateCharArray(2, dims);";
+"    mxSetData(pOut2, data);";
+"    plhs[1] = pOut2;";
+"}"],"mexcreateCharArray.c");
+ilib_mex_build("libmextest",["createCharArray","mexcreateCharArray","cmex"], "mexcreateCharArray.c",[]);
+exec("loader.sce");
 [out1, out2] = createCharArray();
-
-if size(out1, "*") <> 1 then pause end
-
-if out2(1) <> "hello world" then pause end
+assert_checkequal(size(out1, "*"), 1);
+assert_checkequal(out2, "hello world");
index 46f2482..2cf0861 100644 (file)
@@ -4,31 +4,31 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
-
+//
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
+//
 // ============================================================================
 // Unitary tests for mxCreateCharArray mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       '#include <wchar.h>';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    int dims[2] = {1, 1};';
-       '    mxArray *pOut1 = mxCreateCharArray(2, dims);';
-       '    plhs[0] = pOut1;';
-       '    wchar_t *data[1];';
-       '    data[0] = L""hello world"";';
-       '    mxArray *pOut2 = mxCreateCharArray(2, dims);';
-       '    mxSetData(pOut2, data);';
-       '    plhs[1] = pOut2;';
-       '}'],'mexcreateCharArray.c');
-ilib_mex_build('libmextest',['createCharArray','mexcreateCharArray','cmex'], 'mexcreateCharArray.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"#include <wchar.h>";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    int dims[2] = {1, 1};";
+"    mxArray *pOut1 = mxCreateCharArray(2, dims);";
+"    plhs[0] = pOut1;";
+"    wchar_t *data[1];";
+"    data[0] = L""hello world"";";
+"    mxArray *pOut2 = mxCreateCharArray(2, dims);";
+"    mxSetData(pOut2, data);";
+"    plhs[1] = pOut2;";
+"}"],"mexcreateCharArray.c");
+ilib_mex_build("libmextest",["createCharArray","mexcreateCharArray","cmex"], "mexcreateCharArray.c",[]);
+exec("loader.sce");
 
 [out1, out2] = createCharArray();
-if size(out1, "*") <> 1 then pause end
-if out2(1) <> "hello world" then pause end
+assert_checkequal(size(out1, "*"), 1);
+assert_checkequal(out2, "hello world");
index 8af9dfa..f05404f 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl([ "#include ""mex.h""";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "    char *strings[2];";
-        "    strings[0] = ""value"";";
-        "    strings[1] = ""another value"";";
-        "    mxArray *pOut = mxCreateCharMatrixFromStrings(2, strings);";
-        "    char *res = mxArrayToString(pOut);";
-        "    plhs[0] = pOut;";
-        "}"],"mexcreateCharMatrixFromStrings.c");
-ilib_mex_build("libmextest", ["createCharMatrixFromStrings", "mexcreateCharMatrixFromStrings", "cmex"], "mexcreateCharMatrixFromStrings.c", [], "", "", "", "");
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    char *strings[2];";
+"    strings[0] = ""value"";";
+"    strings[1] = ""another value"";";
+"    mxArray *pOut = mxCreateCharMatrixFromStrings(2, strings);";
+"    plhs[0] = pOut;";
+"}"],"mexcreateCharMatrixFromStrings.c");
+ilib_mex_build("libmextest", ["createCharMatrixFromStrings", "mexcreateCharMatrixFromStrings", "cmex"], "mexcreateCharMatrixFromStrings.c", []);
 exec("loader.sce");
 res = createCharMatrixFromStrings();
 assert_checkequal(res(1), "value");
index 44f63a9..63886b1 100644 (file)
@@ -19,10 +19,9 @@ mputl([ "#include ""mex.h""";
 "    strings[0] = ""value"";";
 "    strings[1] = ""another value"";";
 "    mxArray *pOut = mxCreateCharMatrixFromStrings(2, strings);";
-"    char *res = mxArrayToString(pOut);";
 "    plhs[0] = pOut;";
 "}"],"mexcreateCharMatrixFromStrings.c");
-ilib_mex_build("libmextest", ["createCharMatrixFromStrings", "mexcreateCharMatrixFromStrings", "cmex"], "mexcreateCharMatrixFromStrings.c", [], "", "", "", "");
+ilib_mex_build("libmextest", ["createCharMatrixFromStrings", "mexcreateCharMatrixFromStrings", "cmex"], "mexcreateCharMatrixFromStrings.c", []);
 exec("loader.sce");
 
 res = createCharMatrixFromStrings();
index 313f009..bcdbe6f 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl([ "#include ""mex.h""";
-        "";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "   int i = 0;";
-        "   double dblM = 0;";
-        "   double dblN = 0;";
-        "   double *pdbl = NULL;";
-        "   mxArray* pOut1 = NULL;";
-        "   mxArray* pOut2 = NULL;";
-        "";
-        "   if(nrhs != 2 || nlhs != 2 /*|| !mxIsDouble(prhs[0])*/)";
-        "   {";
-        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
-        "   }";
-        "";
-        "   dblM = mxGetScalar(prhs[0]);";
-        "   dblN = mxGetScalar(prhs[1]);";
-        "   pOut1 = mxCreateDoubleMatrix((int)dblM, (int)dblN, mxREAL);";
-        "   pOut2 = mxCreateDoubleScalar(dblM * dblN);";
-        "   pdbl = mxGetPr(pOut1);";
-        "   for(i = 0 ; i < dblM * dblN ; i++)";
-        "   {";
-        "       pdbl[i] = i+1;";
-        "   }";
-        "";
-        "   plhs[0] = pOut1;";
-        "   plhs[1] = pOut2;";
-        "}"],"mexCreateDoubleScalar.c");
-ilib_mex_build("libmextest",["createDouble","mexCreateDoubleScalar","cmex"],"mexCreateDoubleScalar.c",[],"","","","");
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int i = 0;";
+"   double dblM = 0;";
+"   double dblN = 0;";
+"   double *pdbl = NULL;";
+"   mxArray* pOut1 = NULL;";
+"   mxArray* pOut2 = NULL;";
+"";
+"   if(nrhs != 2 || nlhs != 2 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   dblM = mxGetScalar(prhs[0]);";
+"   dblN = mxGetScalar(prhs[1]);";
+"   pOut1 = mxCreateDoubleMatrix((int)dblM, (int)dblN, mxREAL);";
+"   pOut2 = mxCreateDoubleScalar(dblM * dblN);";
+"   pdbl = mxGetPr(pOut1);";
+"   for(i = 0 ; i < dblM * dblN ; i++)";
+"   {";
+"       pdbl[i] = i+1;";
+"   }";
+"";
+"   plhs[0] = pOut1;";
+"   plhs[1] = pOut2;";
+"}"],"mexCreateDoubleScalar.c");
+ilib_mex_build("libmextest",["createDouble","mexCreateDoubleScalar","cmex"],"mexCreateDoubleScalar.c",[]);
 exec("loader.sce");
 m = 3;
 n = 4;
index 782efa6..53cb49e 100644 (file)
@@ -41,7 +41,7 @@ mputl([ "#include ""mex.h""";
 "   plhs[0] = pOut1;";
 "   plhs[1] = pOut2;";
 "}"],"mexCreateDoubleScalar.c");
-ilib_mex_build("libmextest",["createDouble","mexCreateDoubleScalar","cmex"],"mexCreateDoubleScalar.c",[],"","","","");
+ilib_mex_build("libmextest",["createDouble","mexCreateDoubleScalar","cmex"],"mexCreateDoubleScalar.c",[]);
 exec("loader.sce");
 
 m = 3;
index 65debde..5f7610f 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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", [], "", "", "", "");
+"";
+"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", []);
 exec("loader.sce");
 a = createLogicalArray(4, int32([2 2 2 2]));
 assert_checkequal(size(a, "*"), 16);
index d2b6c83..6008ece 100644 (file)
@@ -20,7 +20,7 @@ mputl([ "#include ""mex.h""";
 "   int *dims = (int *) mxGetData(prhs[1]);";
 "   plhs[0] = mxCreateLogicalArray(ndim, dims);";
 "}"],"mexCreateLogicalArray.c");
-ilib_mex_build("libmextest",["createLogicalArray", "mexCreateLogicalArray", "cmex"], "mexCreateLogicalArray.c", [], "", "", "", "");
+ilib_mex_build("libmextest",["createLogicalArray", "mexCreateLogicalArray", "cmex"], "mexCreateLogicalArray.c", []);
 exec("loader.sce");
 
 a = createLogicalArray(4, int32([2 2 2 2]));
index 3077920..145b80c 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl([ "#include ""mex.h""";
-        "";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "   double* pdblM = NULL;";
-        "   double* pdblN = NULL;";
-        "   mxArray* pOut = NULL;";
-        "";
-        "   if(nrhs != 2 /*|| !mxIsDouble(prhs[0])*/)";
-        "   {";
-        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
-        "   }";
-        "";
-        "   pdblM = mxGetPr(prhs[0]);";
-        "   pdblN = mxGetPr(prhs[1]);";
-        "   pOut = mxCreateLogicalMatrix((int)pdblM[0], (int)pdblN[0]);";
-        "   plhs[0] = pOut;";
-        "}"],"mexCreateLogicalMatrix.c");
-ilib_mex_build("libmextest",["createLogicalMatrix", "mexCreateLogicalMatrix", "cmex"], "mexCreateLogicalMatrix.c", [], "", "", "", "");
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   double* pdblM = NULL;";
+"   double* pdblN = NULL;";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 2 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   pdblM = mxGetPr(prhs[0]);";
+"   pdblN = mxGetPr(prhs[1]);";
+"   pOut = mxCreateLogicalMatrix((int)pdblM[0], (int)pdblN[0]);";
+"   plhs[0] = pOut;";
+"}"],"mexCreateLogicalMatrix.c");
+ilib_mex_build("libmextest",["createLogicalMatrix", "mexCreateLogicalMatrix", "cmex"], "mexCreateLogicalMatrix.c", []);
 exec("loader.sce");
 a = createLogicalMatrix(4,3);
 assert_checkequal(size(a, "*"), 12);
index b919444..5a71da1 100644 (file)
@@ -30,7 +30,7 @@ mputl([ "#include ""mex.h""";
 "   pOut = mxCreateLogicalMatrix((int)pdblM[0], (int)pdblN[0]);";
 "   plhs[0] = pOut;";
 "}"],"mexCreateLogicalMatrix.c");
-ilib_mex_build("libmextest",["createLogicalMatrix", "mexCreateLogicalMatrix", "cmex"], "mexCreateLogicalMatrix.c", [], "", "", "", "");
+ilib_mex_build("libmextest",["createLogicalMatrix", "mexCreateLogicalMatrix", "cmex"], "mexCreateLogicalMatrix.c", []);
 exec("loader.sce");
 
 a = createLogicalMatrix(4,3);
index 895cd13..3ccade6 100644 (file)
@@ -5,36 +5,35 @@
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxCreateLogicalScalar mex function
 // ============================================================================
 cd(TMPDIR);
 ilib_verbose(0);
 mputl([ "#include ""mex.h""";
-        "";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "   int bIn1 = 0;";
-        "   int bIn2 = 0;";
-        "   mxArray* pOut1 = NULL;";
-        "   mxArray* pOut2 = NULL;";
-        "";
-        "   if(nrhs != 2 || nlhs != 2/*|| !mxIsDouble(prhs[0])*/)";
-        "   {";
-        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
-        "   }";
-        "";
-        "   bIn1 = mxIsLogicalScalarTrue(prhs[0]);";
-        "   bIn2 = mxIsLogicalScalarTrue(prhs[1]);";
-        "";
-        "   pOut1 = mxCreateLogicalScalar(!bIn1);";
-        "   pOut2 = mxCreateLogicalScalar(!bIn2);";
-        "";
-        "   plhs[0] = pOut1;";
-        "   plhs[1] = pOut2;";
-        "}"],"mexCreateLogicalScalar.c");
-ilib_mex_build("libmextest", ["createLogicalScalar", "mexCreateLogicalScalar", "cmex"], "mexCreateLogicalScalar.c", [], "", "", "", "");
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int bIn1 = 0;";
+"   int bIn2 = 0;";
+"   mxArray* pOut1 = NULL;";
+"   mxArray* pOut2 = NULL;";
+"";
+"   if(nrhs != 2 || nlhs != 2/*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   bIn1 = mxIsLogicalScalarTrue(prhs[0]);";
+"   bIn2 = mxIsLogicalScalarTrue(prhs[1]);";
+"";
+"   pOut1 = mxCreateLogicalScalar(!bIn1);";
+"   pOut2 = mxCreateLogicalScalar(!bIn2);";
+"";
+"   plhs[0] = pOut1;";
+"   plhs[1] = pOut2;";
+"}"],"mexCreateLogicalScalar.c");
+ilib_mex_build("libmextest", ["createLogicalScalar", "mexCreateLogicalScalar", "cmex"], "mexCreateLogicalScalar.c", []);
 exec("loader.sce");
 [out1, out2] = createLogicalScalar(%t, %f);
 assert_checkfalse(out1);
index 279a9ec..ccb81cb 100644 (file)
@@ -6,7 +6,6 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxCreateLogicalScalar mex function
 // ============================================================================
@@ -36,7 +35,7 @@ mputl([ "#include ""mex.h""";
 "   plhs[0] = pOut1;";
 "   plhs[1] = pOut2;";
 "}"],"mexCreateLogicalScalar.c");
-ilib_mex_build("libmextest", ["createLogicalScalar", "mexCreateLogicalScalar", "cmex"], "mexCreateLogicalScalar.c", [], "", "", "", "");
+ilib_mex_build("libmextest", ["createLogicalScalar", "mexCreateLogicalScalar", "cmex"], "mexCreateLogicalScalar.c", []);
 exec("loader.sce");
 
 [out1, out2] = createLogicalScalar(%t, %f);
index e70b6d3..36ccbdb 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl([ "#include ""mex.h""";
-        "";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "   int piDims[3] = {4,3,2};";
-        "   int iDims = 3;";
-        "   mxClassID CLASS = 0;";
-        "   double* pdblType = NULL;";
-        "   mxArray* pOut = NULL;";
-        "";
-        "   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
-        "   {";
-        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
-        "   }";
-        "";
-        "   pdblType = mxGetPr(prhs[0]);";
-        "   pOut = mxCreateNumericArray(iDims, piDims, (mxClassID)pdblType[0], mxREAL);";
-        "   plhs[0] = pOut;";
-        "}"],"mexCreateNumericArray.c");
-ilib_mex_build("libmextest",["createNumericArray","mexCreateNumericArray","cmex"], "mexCreateNumericArray.c",[],"","","","");
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int piDims[3] = {4,3,2};";
+"   int iDims = 3;";
+"   mxClassID CLASS = 0;";
+"   double* pdblType = NULL;";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   pdblType = mxGetPr(prhs[0]);";
+"   pOut = mxCreateNumericArray(iDims, piDims, (mxClassID)pdblType[0], mxREAL);";
+"   plhs[0] = pOut;";
+"}"],"mexCreateNumericArray.c");
+ilib_mex_build("libmextest",["createNumericArray","mexCreateNumericArray","cmex"], "mexCreateNumericArray.c",[]);
 exec("loader.sce");
-ref_int8 = int8(1);
-ref_int8(4,3,2) = int8(1);
-ref_int8(:) = int8(0);
-ref_uint8 = uint8(1);
-ref_uint8(4,3,2) = uint8(1);
-ref_uint8(:) = uint8(0);
-ref_int16 = int16(1);
-ref_int16(4,3,2) = int16(1);
-ref_int16(:) = int16(0);
-ref_uint16 = uint16(1);
-ref_uint16(4,3,2) = uint16(1);
-ref_uint16(:) = uint16(0);
-ref_int32 = int32(1);
-ref_int32(4,3,2) = int32(1);
-ref_int32(:) = int32(0);
-ref_uint32 = uint32(1);
-ref_uint32(4,3,2) = uint32(1);
-ref_uint32(:) = uint32(0);
-ref_int64 = int64(1);
-ref_int64(4,3,2) = int64(1);
-ref_int64(:) = int64(0);
-ref_uint64 = uint64(1);
-ref_uint64(4,3,2) = uint64(1);
-ref_uint64(:) = uint64(0);
 ret8 = createNumericArray(8);
 retU8 = createNumericArray(9);
 ret16 = createNumericArray(10);
index 443c7f9..80b2647 100644 (file)
@@ -31,41 +31,9 @@ mputl([ "#include ""mex.h""";
 "   pOut = mxCreateNumericArray(iDims, piDims, (mxClassID)pdblType[0], mxREAL);";
 "   plhs[0] = pOut;";
 "}"],"mexCreateNumericArray.c");
-ilib_mex_build("libmextest",["createNumericArray","mexCreateNumericArray","cmex"], "mexCreateNumericArray.c",[],"","","","");
+ilib_mex_build("libmextest",["createNumericArray","mexCreateNumericArray","cmex"], "mexCreateNumericArray.c",[]);
 exec("loader.sce");
 
-ref_int8 = int8(1);
-ref_int8(4,3,2) = int8(1);
-ref_int8(:) = int8(0);
-
-ref_uint8 = uint8(1);
-ref_uint8(4,3,2) = uint8(1);
-ref_uint8(:) = uint8(0);
-
-ref_int16 = int16(1);
-ref_int16(4,3,2) = int16(1);
-ref_int16(:) = int16(0);
-
-ref_uint16 = uint16(1);
-ref_uint16(4,3,2) = uint16(1);
-ref_uint16(:) = uint16(0);
-
-ref_int32 = int32(1);
-ref_int32(4,3,2) = int32(1);
-ref_int32(:) = int32(0);
-
-ref_uint32 = uint32(1);
-ref_uint32(4,3,2) = uint32(1);
-ref_uint32(:) = uint32(0);
-
-ref_int64 = int64(1);
-ref_int64(4,3,2) = int64(1);
-ref_int64(:) = int64(0);
-
-ref_uint64 = uint64(1);
-ref_uint64(4,3,2) = uint64(1);
-ref_uint64(:) = uint64(0);
-
 ret8 = createNumericArray(8);
 retU8 = createNumericArray(9);
 ret16 = createNumericArray(10);
index cb3779a..05e8ed5 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl([ "#include ""mex.h""";
-        "";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "   mxArray* pOut = NULL;";
-        "";
-        "   if(nrhs != 0 /*|| !mxIsDouble(prhs[0])*/)";
-        "   {";
-        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
-        "   }";
-        "";
-        "   pOut = mxCreateString(""Create new String"");";
-        "   plhs[0] = pOut;";
-        "}"],"mexCreateString.c");
-ilib_mex_build("libmextest",["createString","mexCreateString","cmex"], "mexCreateString.c",[],"","","","");
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 0 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   pOut = mxCreateString(""Create new String"");";
+"   plhs[0] = pOut;";
+"}"],"mexCreateString.c");
+ilib_mex_build("libmextest",["createString","mexCreateString","cmex"], "mexCreateString.c",[]);
 exec("loader.sce");
-ref = "Create new String";
-a = createString();
-assert_checkequal(a, ref);
+assert_checkequal(createString(), "Create new String");
index 62d1837..227ff24 100644 (file)
@@ -26,9 +26,7 @@ mputl([ "#include ""mex.h""";
 "   pOut = mxCreateString(""Create new String"");";
 "   plhs[0] = pOut;";
 "}"],"mexCreateString.c");
-ilib_mex_build("libmextest",["createString","mexCreateString","cmex"], "mexCreateString.c",[],"","","","");
+ilib_mex_build("libmextest",["createString","mexCreateString","cmex"], "mexCreateString.c",[]);
 exec("loader.sce");
 
-ref = "Create new String";
-a = createString();
-assert_checkequal(a, ref);
+assert_checkequal(createString(), "Create new String");
index 92cb308..44d5a6a 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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",[],"","","","");
+"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",[]);
 exec("loader.sce");
 [out1, out2] = createStruct();
 assert_checkequal(size(out1, "*"), 9);
index e86e590..c6080d1 100644 (file)
@@ -22,7 +22,7 @@ mputl(["#include ""mex.h""";
 "    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",[],"","","","");
+ilib_mex_build("libmextest",["createStruct","mexcreateStruct","cmex"], "mexcreateStruct.c",[]);
 exec("loader.sce");
 
 [out1, out2] = createStruct();
index fc056a7..0b18a59 100644 (file)
@@ -1,50 +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 mxDestroyArray mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxArray *d = prhs[0];'
-       '    mxDestroyArray(d);';
-       '    if (*d == NULL)';
-       '    {';
-       '        mexPrintf(""It works."");';
-       '    }';
-       '}'],'mexdestroyArray.c');
-
-ilib_mex_build('libmextest',['destroyArray','mexdestroyArray','cmex'], 'mexdestroyArray.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mxArray *d = mxDuplicateArray(prhs[0]);"
+"    mxDestroyArray(d);";
+"    if (*d == NULL)";
+"    {";
+"        mexPrintf(""It works."");";
+"    }";
+"}"],"mexdestroyArray.c");
+ilib_mex_build("libmextest",["destroyArray","mexdestroyArray","cmex"], "mexdestroyArray.c",[]);
+exec("loader.sce");
 destroyArray(cell());
 It works.
-destroyArray('s');
+destroyArray("s");
 It works.
-destroyArray(double(1));
+destroyArray(1);
 It works.
 destroyArray(int8(1));
 It works.
index cdda68a..c2025c2 100644 (file)
@@ -4,32 +4,32 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
-
+//
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
+//
 // ============================================================================
 // Unitary tests for mxDestroyArray mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxArray *d = prhs[0];'
-       '    mxDestroyArray(d);';
-       '    if (*d == NULL)';
-       '    {';
-       '        mexPrintf(""It works."");';
-       '    }';
-       '}'],'mexdestroyArray.c');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mxArray *d = mxDuplicateArray(prhs[0]);"
+"    mxDestroyArray(d);";
+"    if (*d == NULL)";
+"    {";
+"        mexPrintf(""It works."");";
+"    }";
+"}"],"mexdestroyArray.c");
 
-ilib_mex_build('libmextest',['destroyArray','mexdestroyArray','cmex'], 'mexdestroyArray.c',[],'Makelib','','','');
-exec('loader.sce');
+ilib_mex_build("libmextest",["destroyArray","mexdestroyArray","cmex"], "mexdestroyArray.c",[]);
+exec("loader.sce");
 
 destroyArray(cell());
-destroyArray('s');
-destroyArray(double(1));
+destroyArray("s");
+destroyArray(1);
 destroyArray(int8(1));
 destroyArray(int16(1));
 destroyArray(int32(1));
index 8a9cdc7..4d7b9ee 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl([ "#include ""mex.h""";
-        "";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "   mxArray* pOut = NULL;";
-        "";
-        "   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
-        "   {";
-        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
-        "   }";
-        "";
-        "   pOut = mxDuplicateArray(prhs[0]);";
-        "   plhs[0] = pOut;";
-        "}"],"mexDuplicateArray.c");
-ilib_mex_build("libmextest",["duplicateArray","mexDuplicateArray","cmex"], "mexDuplicateArray.c",[],"","","","");
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   pOut = mxDuplicateArray(prhs[0]);";
+"   plhs[0] = pOut;";
+"}"],"mexDuplicateArray.c");
+ilib_mex_build("libmextest",["duplicateArray","mexDuplicateArray","cmex"], "mexDuplicateArray.c",[]);
 exec("loader.sce");
 a = rand(4,3);
 b = duplicateArray(a);
index d8c1b80..cf9415d 100644 (file)
@@ -26,7 +26,7 @@ mputl([ "#include ""mex.h""";
 "   pOut = mxDuplicateArray(prhs[0]);";
 "   plhs[0] = pOut;";
 "}"],"mexDuplicateArray.c");
-ilib_mex_build("libmextest",["duplicateArray","mexDuplicateArray","cmex"], "mexDuplicateArray.c",[],"","","","");
+ilib_mex_build("libmextest",["duplicateArray","mexDuplicateArray","cmex"], "mexDuplicateArray.c",[]);
 exec("loader.sce");
 
 a = rand(4,3);
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxFreeMatrix.dia.ref b/scilab/modules/mexlib/tests/unit_tests/mxFreeMatrix.dia.ref
deleted file mode 100644 (file)
index a90f171..0000000
+++ /dev/null
@@ -1,68 +0,0 @@
-
-// ============================================================================
-
-// 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 mxFreeMatrix mex function
-
-// ============================================================================
-
-cd(TMPDIR);
-
-ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxArray *d = prhs[0];'
-       '    mxFreeMatrix(d);';
-       '    if (*d == NULL)';
-       '    {';
-       '        mexPrintf(""It works."");';
-       '    }';
-       '}'],'mexfreeMatrix.c');
-
-ilib_mex_build('libmextest',['freeMatrix','mexfreeMatrix','cmex'], 'mexfreeMatrix.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
-freeMatrix(cell());
-It works.
-freeMatrix('s');
-It works.
-freeMatrix(double(1));
-It works.
-freeMatrix(int8(1));
-It works.
-freeMatrix(int16(1));
-It works.
-freeMatrix(int32(1));
-It works.
-freeMatrix(int64(1));
-It works.
-freeMatrix(%t);
-It works.
-freeMatrix(struct());
-It works.
-freeMatrix(uint8(1));
-It works.
-freeMatrix(uint16(1));
-It works.
-freeMatrix(uint32(1));
-It works.
-freeMatrix(uint64(1));
-It works.
diff --git a/scilab/modules/mexlib/tests/unit_tests/mxFreeMatrix.tst b/scilab/modules/mexlib/tests/unit_tests/mxFreeMatrix.tst
deleted file mode 100644 (file)
index 3500788..0000000
+++ /dev/null
@@ -1,42 +0,0 @@
-// ============================================================================
-// 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 mxFreeMatrix mex function
-// ============================================================================
-
-cd(TMPDIR);
-ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxArray *d = prhs[0];'
-       '    mxFreeMatrix(d);';
-       '    if (*d == NULL)';
-       '    {';
-       '        mexPrintf(""It works."");';
-       '    }';
-       '}'],'mexfreeMatrix.c');
-
-ilib_mex_build('libmextest',['freeMatrix','mexfreeMatrix','cmex'], 'mexfreeMatrix.c',[],'Makelib','','','');
-exec('loader.sce');
-
-freeMatrix(cell());
-freeMatrix('s');
-freeMatrix(double(1));
-freeMatrix(int8(1));
-freeMatrix(int16(1));
-freeMatrix(int32(1));
-freeMatrix(int64(1));
-freeMatrix(%t);
-freeMatrix(struct());
-freeMatrix(uint8(1));
-freeMatrix(uint16(1));
-freeMatrix(uint32(1));
-freeMatrix(uint64(1));
index 8e911ea..d7c0b23 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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",[],"","","","");
+"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",[]);
 exec("loader.sce");
-r = getChars("hello world");
-assert_checkequal(r, "hello world");
+assert_checkequal(getChars("hello world"), "hello world");
index b9e6144..394ecc0 100644 (file)
@@ -18,8 +18,7 @@ mputl(["#include ""mex.h""";
 "    char *chars = mxGetChars(prhs[0]);";
 "    plhs[0] = mxCreateString(chars);";
 "}"],"mexgetChars.c");
-ilib_mex_build("libmextest",["getChars","mexgetChars","cmex"], "mexgetChars.c",[],"","","","");
+ilib_mex_build("libmextest",["getChars","mexgetChars","cmex"], "mexgetChars.c",[]);
 exec("loader.sce");
 
-r = getChars("hello world");
-assert_checkequal(r, "hello world");
+assert_checkequal(getChars("hello world"), "hello world");
index d7938d8..dfd23f5 100644 (file)
@@ -59,7 +59,7 @@ mputl(["#include ""mex.h""";
 "        mexPrintf(""uint64"");";
 "    }"
 "}"],"mexgetClassID.c");
-ilib_mex_build("libmextest",["printClass","mexgetClassID","cmex"], "mexgetClassID.c",[],"","","","");
+ilib_mex_build("libmextest",["printClass","mexgetClassID","cmex"], "mexgetClassID.c",[]);
 exec("loader.sce");
 printClass(cell());
 cell
index 859c6eb..1dedd2f 100644 (file)
@@ -62,7 +62,7 @@ mputl(["#include ""mex.h""";
 "    }"
 "}"],"mexgetClassID.c");
 
-ilib_mex_build("libmextest",["printClass","mexgetClassID","cmex"], "mexgetClassID.c",[],"","","","");
+ilib_mex_build("libmextest",["printClass","mexgetClassID","cmex"], "mexgetClassID.c",[]);
 exec("loader.sce");
 
 printClass(cell());
index cdf3263..e29b02b 100644 (file)
@@ -15,7 +15,7 @@ mputl(["#include ""mex.h""";
 "{";
 "    mexPrintf(mxGetClassName(prhs[0]));";
 "}"],"mexgetClassName.c");
-ilib_mex_build("libmextest",["printClassName","mexgetClassName","cmex"], "mexgetClassName.c",[],"","","","");
+ilib_mex_build("libmextest",["printClassName","mexgetClassName","cmex"], "mexgetClassName.c",[]);
 exec("loader.sce");
 printClassName(cell());
 cell
@@ -23,8 +23,6 @@ printClassName("s");
 char
 printClassName(1);
 double
-printClassName(sum);
-function_handle
 printClassName(int8(1));
 int8
 printClassName(int16(1));
@@ -34,7 +32,7 @@ int32
 printClassName(int64(1));
 int64
 printClassName(%t);
-unknown
+bool
 printClassName(struct());
 struct
 printClassName(uint8(1));
index 9f226d9..9a90009 100644 (file)
@@ -18,13 +18,12 @@ mputl(["#include ""mex.h""";
 "    mexPrintf(mxGetClassName(prhs[0]));";
 "}"],"mexgetClassName.c");
 
-ilib_mex_build("libmextest",["printClassName","mexgetClassName","cmex"], "mexgetClassName.c",[],"","","","");
+ilib_mex_build("libmextest",["printClassName","mexgetClassName","cmex"], "mexgetClassName.c",[]);
 exec("loader.sce");
 
 printClassName(cell());
 printClassName("s");
 printClassName(1);
-printClassName(sum);
 printClassName(int8(1));
 printClassName(int16(1));
 printClassName(int32(1));
index 05b25a7..5c238c0 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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",[],"","","","");
+"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",[]);
 exec("loader.sce");
 assert_checkequal(getDimensions([1]), int32([1 1]));
 assert_checkequal(getDimensions([1 1 1]), int32([1 3]));
index f1f62b0..7fcdf9c 100644 (file)
@@ -21,7 +21,7 @@ mputl(["#include ""mex.h""";
 "    mxSetPr(ptr, dims);";
 "    plhs[0] = ptr;";
 "}"],"mexgetDimensions.c");
-ilib_mex_build("libmextest",["getDimensions","mexgetDimensions","cmex"], "mexgetDimensions.c",[],"","","","");
+ilib_mex_build("libmextest",["getDimensions","mexgetDimensions","cmex"], "mexgetDimensions.c",[]);
 exec("loader.sce");
 
 assert_checkequal(getDimensions([1]), int32([1 1]));
index eac1125..34dc6da 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl(["#include ""mex.h""";
-       "#include ""wchar.h""";
-       "void check(mxArray *ptr, int size)";
-       "{";
-       "    if (mxGetElementSize(ptr) == size)";
-       "    {"
-       "        mexPrintf(""T"");";
-       "    }"
-       "    else"
-       "    {"
-       "        mexPrintf(""F"");";
-       "    }"
-       "}";
-       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-       "{";
-       "    check(mxCreateCellMatrix(2, 2), sizeof(mxArray *));";
-       "    check(mxCreateStructMatrix(2, 2, 0, NULL), sizeof(mxArray *));";
-       "    check(mxCreateString(""foo""), sizeof(wchar_t *));";
-       "    check(mxCreateDoubleScalar(1), sizeof(double));";
-       "    check(mxCreateNumericMatrix(2, 2, mxINT8_CLASS, mxREAL), sizeof(char));";
-       "    check(mxCreateNumericMatrix(2, 2, mxINT16_CLASS, mxREAL), sizeof(short));";
-       "    check(mxCreateNumericMatrix(2, 2, mxINT32_CLASS, mxREAL), sizeof(int));";
-       "    check(mxCreateNumericMatrix(2, 2, mxINT64_CLASS, mxREAL), sizeof(long long));";
-       "    check(mxCreateNumericMatrix(2, 2, mxUINT8_CLASS, mxREAL), sizeof(unsigned char));";
-       "    check(mxCreateNumericMatrix(2, 2, mxUINT16_CLASS, mxREAL), sizeof(unsigned short));";
-       "    check(mxCreateNumericMatrix(2, 2, mxUINT32_CLASS, mxREAL), sizeof(unsigned int));";
-       "    check(mxCreateNumericMatrix(2, 2, mxUINT64_CLASS, mxREAL), sizeof(unsigned long long));";
-       "    check(mxCreateLogicalScalar(0), sizeof(int));";
-       "}"],"mexgetElementSize.c");
-ilib_mex_build("libmextest",["getElementSize","mexgetElementSize","cmex"], "mexgetElementSize.c",[],"","","","");
+"#include ""wchar.h""";
+"void check(mxArray *ptr, int size)";
+"{";
+"    if (mxGetElementSize(ptr) == size)";
+"    {"
+"        mexPrintf(""T"");";
+"    }"
+"    else"
+"    {"
+"        mexPrintf(""F"");";
+"    }"
+"}";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    check(mxCreateCellMatrix(2, 2), sizeof(mxArray *));";
+"    check(mxCreateStructMatrix(2, 2, 0, NULL), sizeof(mxArray *));";
+"    check(mxCreateString(""foo""), sizeof(wchar_t *));";
+"    check(mxCreateDoubleScalar(1), sizeof(double));";
+"    check(mxCreateNumericMatrix(2, 2, mxINT8_CLASS, mxREAL), sizeof(char));";
+"    check(mxCreateNumericMatrix(2, 2, mxINT16_CLASS, mxREAL), sizeof(short));";
+"    check(mxCreateNumericMatrix(2, 2, mxINT32_CLASS, mxREAL), sizeof(int));";
+"    check(mxCreateNumericMatrix(2, 2, mxINT64_CLASS, mxREAL), sizeof(long long));";
+"    check(mxCreateNumericMatrix(2, 2, mxUINT8_CLASS, mxREAL), sizeof(unsigned char));";
+"    check(mxCreateNumericMatrix(2, 2, mxUINT16_CLASS, mxREAL), sizeof(unsigned short));";
+"    check(mxCreateNumericMatrix(2, 2, mxUINT32_CLASS, mxREAL), sizeof(unsigned int));";
+"    check(mxCreateNumericMatrix(2, 2, mxUINT64_CLASS, mxREAL), sizeof(unsigned long long));";
+"    check(mxCreateLogicalScalar(0), sizeof(int));";
+"}"],"mexgetElementSize.c");
+ilib_mex_build("libmextest",["getElementSize","mexgetElementSize","cmex"], "mexgetElementSize.c",[]);
 exec("loader.sce");
 getElementSize();
 TTTTTTTTTTTTT
index fc77a6e..a2433cc 100644 (file)
@@ -43,7 +43,7 @@ mputl(["#include ""mex.h""";
 "}"],"mexgetElementSize.c");
 
 
-ilib_mex_build("libmextest",["getElementSize","mexgetElementSize","cmex"], "mexgetElementSize.c",[],"","","","");
+ilib_mex_build("libmextest",["getElementSize","mexgetElementSize","cmex"], "mexgetElementSize.c",[]);
 exec("loader.sce");
 
 getElementSize();
index 37900d9..c93c6f8 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl(["#include ""mex.h""";
-       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-       "{";
-       "    double dblEps = mxGetEps();";
-       "    mxArray* pOut = mxCreateDoubleScalar(dblEps);";
-       "    plhs[0] = pOut;";
-       "}"],"mexgetEps.c");
-ilib_mex_build("libmextest",["getEps","mexgetEps","cmex"], "mexgetEps.c",[],"","","","");
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    double dblEps = mxGetEps();";
+"    mxArray* pOut = mxCreateDoubleScalar(dblEps);";
+"    plhs[0] = pOut;";
+"}"],"mexgetEps.c");
+ilib_mex_build("libmextest",["getEps","mexgetEps","cmex"], "mexgetEps.c",[]);
 exec("loader.sce");
-a = getEps();
-assert_checkequal(a, %eps);
+assert_checkequal(getEps(), %eps);
index f348dfb..dc4e07f 100644 (file)
@@ -19,8 +19,7 @@ mputl(["#include ""mex.h""";
 "    mxArray* pOut = mxCreateDoubleScalar(dblEps);";
 "    plhs[0] = pOut;";
 "}"],"mexgetEps.c");
-ilib_mex_build("libmextest",["getEps","mexgetEps","cmex"], "mexgetEps.c",[],"","","","");
+ilib_mex_build("libmextest",["getEps","mexgetEps","cmex"], "mexgetEps.c",[]);
 exec("loader.sce");
 
-a = getEps();
-assert_checkequal(a, %eps);
+assert_checkequal(getEps(), %eps);
index 3620a5e..84a5757 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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",[],"","","","");
+"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",[]);
 exec("loader.sce");
 c = struct("a", 5, "b", 2);
 r = getField(c);
index 543b6b1..08b4d72 100644 (file)
@@ -19,7 +19,7 @@ mputl(["#include ""mex.h""";
 "    if (value == NULL) value = mxCreateDoubleScalar(-1);";
 "    plhs[0] = value;";
 "}"],"mexgetField.c");
-ilib_mex_build("libmextest",["getField","mexgetField","cmex"], "mexgetField.c",[],"","","","");
+ilib_mex_build("libmextest",["getField","mexgetField","cmex"], "mexgetField.c",[]);
 exec("loader.sce");
 
 c = struct("a", 5, "b", 2);
index 7a069ca..503353c 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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",[],"","","","");
+"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",[]);
 exec("loader.sce");
 c = struct("a", 5, "b", 2);
 r = getFieldByNumber(c);
index 4ac6c39..b24ac7f 100644 (file)
@@ -19,7 +19,7 @@ mputl(["#include ""mex.h""";
 "    if (value == NULL) value = mxCreateDoubleScalar(-1);";
 "    plhs[0] = value;";
 "}"],"mexgetFieldByNumber.c");
-ilib_mex_build("libmextest",["getFieldByNumber","mexgetFieldByNumber","cmex"], "mexgetFieldByNumber.c",[],"","","","");
+ilib_mex_build("libmextest",["getFieldByNumber","mexgetFieldByNumber","cmex"], "mexgetFieldByNumber.c",[]);
 exec("loader.sce");
 
 c = struct("a", 5, "b", 2);
index 0734214..0b2a21f 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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",[],"","","","");
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    int fieldnum = mxGetScalar(prhs[1]) - 1;";
+"    char *fieldname = mxGetFieldNameByNumber(prhs[0], fieldnum);";
+"    plhs[0] = mxCreateString(fieldname != NULL ? fieldname : """");";
+"}"],"mexGetFieldNameByNumber.c");
+ilib_mex_build("libmextest",["getFieldNameByNumber","mexGetFieldNameByNumber","cmex"], "mexGetFieldNameByNumber.c",[]);
 exec("loader.sce");
 s = struct("a", 1, "b", 2);
-assert_checkequal(getFieldNameByNumber(s, 0), "a");
-assert_checkequal(getFieldNameByNumber(s, 1), "b");
-assert_checkequal(getFieldNameByNumber(s, 2), "");
+assert_checkequal(getFieldNameByNumber(s, 1), "a");
+assert_checkequal(getFieldNameByNumber(s, 2), "b");
+assert_checkequal(getFieldNameByNumber(s, 3), "");
index b6d355e..1fc4fac 100644 (file)
@@ -15,14 +15,14 @@ ilib_verbose(0);
 mputl(["#include ""mex.h""";
 "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
 "{";
-"    int fieldnum = mxGetScalar(prhs[1]);";
+"    int fieldnum = mxGetScalar(prhs[1]) - 1;";
 "    char *fieldname = mxGetFieldNameByNumber(prhs[0], fieldnum);";
 "    plhs[0] = mxCreateString(fieldname != NULL ? fieldname : """");";
 "}"],"mexGetFieldNameByNumber.c");
-ilib_mex_build("libmextest",["getFieldNameByNumber","mexGetFieldNameByNumber","cmex"], "mexGetFieldNameByNumber.c",[],"","","","");
+ilib_mex_build("libmextest",["getFieldNameByNumber","mexGetFieldNameByNumber","cmex"], "mexGetFieldNameByNumber.c",[]);
 exec("loader.sce");
 
 s = struct("a", 1, "b", 2);
-assert_checkequal(getFieldNameByNumber(s, 0), "a");
-assert_checkequal(getFieldNameByNumber(s, 1), "b");
-assert_checkequal(getFieldNameByNumber(s, 2), "");
+assert_checkequal(getFieldNameByNumber(s, 1), "a");
+assert_checkequal(getFieldNameByNumber(s, 2), "b");
+assert_checkequal(getFieldNameByNumber(s, 3), "");
index 9ff0b97..d1e46af 100644 (file)
@@ -1,60 +1,36 @@
-
 // ============================================================================
-
 // 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);
-
 ilib_verbose(0);
-
-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');
-
+mputl([ "#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    int num = mxGetFieldNumber(prhs[0], ""a"");";
+"    if(num == -1)"
+"    {"
+"        plhs[0] = mxCreateDoubleScalar(num);";
+"    }"
+"    else"
+"    {"
+"        plhs[0] = mxCreateDoubleScalar(num + 1);";
+"    }"
+"}"],"mexgetFieldNumber.c");
+ilib_mex_build("libmextest",["getFieldNumber","mexgetFieldNumber","cmex"], "mexgetFieldNumber.c",[]);
+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
-
+assert_checkequal(getFieldNumber(c), 1);
+c = struct("b", 3, "a", 5);
+assert_checkequal(getFieldNumber(c), 2);
 c = struct("b", 32);
-
-r = getFieldNumber(c);
-
-if r <> -1 then pause end
-
-r = getFieldNumber("not_a_struct");
-
-if r <> -1 then pause end
-
+assert_checkequal(getFieldNumber(c), -1);
+assert_checkequal(getFieldNumber("not_a_struct"), -1);
index ac49b8a..498d9e4 100644 (file)
@@ -4,35 +4,38 @@
 //
 //  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);
 ilib_verbose(0);
-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');
+mputl([ "#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    int num = mxGetFieldNumber(prhs[0], ""a"");";
+"    if(num == -1)"
+"    {"
+"        plhs[0] = mxCreateDoubleScalar(num);";
+"    }"
+"    else"
+"    {"
+"        plhs[0] = mxCreateDoubleScalar(num + 1);";
+"    }"
+"}"],"mexgetFieldNumber.c");
+ilib_mex_build("libmextest",["getFieldNumber","mexgetFieldNumber","cmex"], "mexgetFieldNumber.c",[]);
+exec("loader.sce");
 
 c = struct("a", 3, "b", 1, "1", 2);
-r = getFieldNumber(c);
-if r <> 1 then pause end
+assert_checkequal(getFieldNumber(c), 1);
 
-c = struct("a", 5, "b", 3);
-r = getFieldNumber(c);
-if r <> 0 then pause end
+c = struct("b", 3, "a", 5);
+assert_checkequal(getFieldNumber(c), 2);
 
 c = struct("b", 32);
-r = getFieldNumber(c);
-if r <> -1 then pause end
+assert_checkequal(getFieldNumber(c), -1);
 
-r = getFieldNumber("not_a_struct");
-if r <> -1 then pause end
+assert_checkequal(getFieldNumber("not_a_struct"), -1);
index 375dacd..a7ecad0 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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",[],"","","","");
+"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",[]);
 exec("loader.sce");
-a = getInf();
-assert_checkequal(a, %inf);
+assert_checkequal(getInf(), %inf);
index b0f6245..0f34ec8 100644 (file)
@@ -19,8 +19,7 @@ mputl(["#include ""mex.h""";
 "    mxArray* pOut = mxCreateDoubleScalar(dblInf);";
 "    plhs[0] = pOut;";
 "}"],"mexgetInf.c");
-ilib_mex_build("libmextest",["getInf","mexgetInf","cmex"], "mexgetInf.c",[],"","","","");
+ilib_mex_build("libmextest",["getInf","mexgetInf","cmex"], "mexgetInf.c",[]);
 exec("loader.sce");
 
-a = getInf();
-assert_checkequal(a, %inf);
+assert_checkequal(getInf(), %inf);
index 6f969da..3215b00 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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",[],"","","","");
+"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",[]);
 exec("loader.sce");
 [out1, out2] = getLogicals([%t %f]);
 assert_checktrue(out1);
index 1185c56..7fad4df 100644 (file)
@@ -19,7 +19,7 @@ mputl(["#include ""mex.h""";
 "    plhs[0] = mxCreateLogicalScalar(logicals[0]);";
 "    plhs[1] = mxCreateLogicalScalar(logicals[1]);";
 "}"],"mexgetLogicals.c");
-ilib_mex_build("libmextest",["getLogicals","mexgetLogicals","cmex"], "mexgetLogicals.c",[],"","","","");
+ilib_mex_build("libmextest",["getLogicals","mexgetLogicals","cmex"], "mexgetLogicals.c",[]);
 exec("loader.sce");
 
 [out1, out2] = getLogicals([%t %f]);
index 01bbcfe..964a843 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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",[],"","","","");
+"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",[]);
 exec("loader.sce");
-a = getNaN();
-assert_checktrue(isnan(a));
+assert_checktrue(isnan(getNaN()));
index 1f1281d..184f4ad 100644 (file)
@@ -19,8 +19,7 @@ mputl(["#include ""mex.h""";
 "    mxArray* pOut = mxCreateDoubleScalar(dblNaN);";
 "    plhs[0] = pOut;";
 "}"],"mexgetNaN.c");
-ilib_mex_build("libmextest",["getNaN","mexgetNaN","cmex"], "mexgetNaN.c",[],"","","","");
+ilib_mex_build("libmextest",["getNaN","mexgetNaN","cmex"], "mexgetNaN.c",[]);
 exec("loader.sce");
 
-a = getNaN();
-assert_checktrue(isnan(a));
+assert_checktrue(isnan(getNaN()));
index 9f5017a..408404b 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl([ "#include ""mex.h""";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "   int iDims = 0;";
-        "   mxArray* pOut = NULL;";
-        "";
-        "   if(nrhs != 1)";
-        "   {";
-        "       mexErrMsgTxt(""Wrong number of input argument"");";
-        "   }";
-        "";
-        "   iDims = mxGetNumberOfDimensions(prhs[0]);";
-        "   pOut = mxCreateDoubleScalar((double)iDims);";
-        "   plhs[0] = pOut;";
-        "}"],"mexGetNumberOfDimensions.c");
-ilib_mex_build("libmextest",["getDims","mexGetNumberOfDimensions","cmex"], "mexGetNumberOfDimensions.c",[],"","","","");
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int iDims = 0;";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 1)";
+"   {";
+"       mexErrMsgTxt(""Wrong number of input argument"");";
+"   }";
+"";
+"   iDims = mxGetNumberOfDimensions(prhs[0]);";
+"   pOut = mxCreateDoubleScalar((double)iDims);";
+"   plhs[0] = pOut;";
+"}"],"mexGetNumberOfDimensions.c");
+ilib_mex_build("libmextest",["getDims","mexGetNumberOfDimensions","cmex"], "mexGetNumberOfDimensions.c",[]);
 exec("loader.sce");
 a = ones(5,4,3,2);
-iDims = getDims(a);
-assert_checkequal(iDims, 4);
+assert_checkequal(getDims(a), 4);
index f2351b2..3d18f7d 100644 (file)
@@ -27,11 +27,8 @@ mputl([ "#include ""mex.h""";
 "   pOut = mxCreateDoubleScalar((double)iDims);";
 "   plhs[0] = pOut;";
 "}"],"mexGetNumberOfDimensions.c");
-ilib_mex_build("libmextest",["getDims","mexGetNumberOfDimensions","cmex"], "mexGetNumberOfDimensions.c",[],"","","","");
+ilib_mex_build("libmextest",["getDims","mexGetNumberOfDimensions","cmex"], "mexGetNumberOfDimensions.c",[]);
 exec("loader.sce");
 
 a = ones(5,4,3,2);
-iDims = getDims(a);
-assert_checkequal(iDims, 4);
-
-
+assert_checkequal(getDims(a), 4);
index eff7cac..a922a71 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl([ "#include ""mex.h""";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "   int iSize = 0;";
-        "   mxArray* pOut = NULL;";
-        "";
-        "   if(nrhs != 1)";
-        "   {";
-        "       mexErrMsgTxt(""Wrong number of input argument"");";
-        "   }";
-        "";
-        "   iSize = mxGetNumberOfElements(prhs[0]);";
-        "   pOut = mxCreateDoubleScalar((double)iSize);";
-        "   plhs[0] = pOut;";
-        "}"],"mexGetNumberOfElements.c");
-ilib_mex_build("libmextest",["getNumberOfElements","mexGetNumberOfElements","cmex"], "mexGetNumberOfElements.c",[],"","","","");
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int iSize = 0;";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 1)";
+"   {";
+"       mexErrMsgTxt(""Wrong number of input argument"");";
+"   }";
+"";
+"   iSize = mxGetNumberOfElements(prhs[0]);";
+"   pOut = mxCreateDoubleScalar((double)iSize);";
+"   plhs[0] = pOut;";
+"}"],"mexGetNumberOfElements.c");
+ilib_mex_build("libmextest",["getNumberOfElements","mexGetNumberOfElements","cmex"], "mexGetNumberOfElements.c",[]);
 exec("loader.sce");
 a = ones(1);
-var = getNumberOfElements(a);
-assert_checkequal(var, size(a, "*"));
+assert_checkequal(getNumberOfElements(a), size(a, "*"));
 a = ones(1, 2);
-var = getNumberOfElements(a);
-assert_checkequal(var, size(a, "*"));
+assert_checkequal(getNumberOfElements(a), size(a, "*"));
 a = ones(1, 2, 3);
-var = getNumberOfElements(a);
-assert_checkequal(var, size(a, "*"));
+assert_checkequal(getNumberOfElements(a), size(a, "*"));
 a = ones(1, 2, 3, 4);
-var = getNumberOfElements(a);
-assert_checkequal(var, size(a, "*"));
+assert_checkequal(getNumberOfElements(a), size(a, "*"));
index 1287ee8..f102371 100644 (file)
@@ -27,22 +27,18 @@ mputl([ "#include ""mex.h""";
 "   pOut = mxCreateDoubleScalar((double)iSize);";
 "   plhs[0] = pOut;";
 "}"],"mexGetNumberOfElements.c");
-ilib_mex_build("libmextest",["getNumberOfElements","mexGetNumberOfElements","cmex"], "mexGetNumberOfElements.c",[],"","","","");
+ilib_mex_build("libmextest",["getNumberOfElements","mexGetNumberOfElements","cmex"], "mexGetNumberOfElements.c",[]);
 exec("loader.sce");
 
 a = ones(1);
-var = getNumberOfElements(a);
-assert_checkequal(var, size(a, "*"));
+assert_checkequal(getNumberOfElements(a), size(a, "*"));
 
 a = ones(1, 2);
-var = getNumberOfElements(a);
-assert_checkequal(var, size(a, "*"));
+assert_checkequal(getNumberOfElements(a), size(a, "*"));
 
 a = ones(1, 2, 3);
-var = getNumberOfElements(a);
-assert_checkequal(var, size(a, "*"));
+assert_checkequal(getNumberOfElements(a), size(a, "*"));
 
 a = ones(1, 2, 3, 4);
-var = getNumberOfElements(a);
-assert_checkequal(var, size(a, "*"));
+assert_checkequal(getNumberOfElements(a), size(a, "*"));
 
index 477a597..ad17e2a 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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",[],"","","","");
+"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",[]);
 exec("loader.sce");
 c = struct("a", 5, "b", 3, "e", 1, "another key", "hello");
-r = getNumberOfFields(c);
-assert_checkequal(r, 4);
+assert_checkequal(getNumberOfFields(c), 4);
 c = struct("a", 5, "b", 3);
-r = getNumberOfFields(c);
-assert_checkequal(r, 2);
+assert_checkequal(getNumberOfFields(c), 2);
 c = struct("b", 32);
-r = getNumberOfFields(c);
-assert_checkequal(r, 1);
+assert_checkequal(getNumberOfFields(c), 1);
 r = getNumberOfFields("not_a_struct");
 assert_checkequal(r, 0);
index d9988ee..8ccf858 100644 (file)
@@ -18,20 +18,17 @@ mputl(["#include ""mex.h""";
 "    int num = mxGetNumberOfFields(prhs[0]);";
 "    plhs[0] = mxCreateDoubleScalar(num);";
 "}"],"mexgetNumberOfFields.c");
-ilib_mex_build("libmextest",["getNumberOfFields","mexgetNumberOfFields","cmex"], "mexgetNumberOfFields.c",[],"","","","");
+ilib_mex_build("libmextest",["getNumberOfFields","mexgetNumberOfFields","cmex"], "mexgetNumberOfFields.c",[]);
 exec("loader.sce");
 
 c = struct("a", 5, "b", 3, "e", 1, "another key", "hello");
-r = getNumberOfFields(c);
-assert_checkequal(r, 4);
+assert_checkequal(getNumberOfFields(c), 4);
 
 c = struct("a", 5, "b", 3);
-r = getNumberOfFields(c);
-assert_checkequal(r, 2);
+assert_checkequal(getNumberOfFields(c), 2);
 
 c = struct("b", 32);
-r = getNumberOfFields(c);
-assert_checkequal(r, 1);
+assert_checkequal(getNumberOfFields(c), 1);
 
 r = getNumberOfFields("not_a_struct");
 assert_checkequal(r, 0);
index 0e32a5e..5496229 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl([ "#include ""mex.h""";
-        "";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "   double dblScalar = 0;";
-        "   mxArray* pOut = NULL;";
-        "";
-        "   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
-        "   {";
-        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
-        "   }";
-        "";
-        "   dblScalar = mxGetScalar(prhs[0]);";
-        "   pOut = mxCreateDoubleScalar(dblScalar);";
-        "   plhs[0] = pOut;";
-        "}"],"mexGetScalar.c");
-ilib_mex_build("libmextest",["getScalar","mexGetScalar","cmex"], "mexGetScalar.c",[],"","","","");
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   double dblScalar = 0;";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   dblScalar = mxGetScalar(prhs[0]);";
+"   pOut = mxCreateDoubleScalar(dblScalar);";
+"   plhs[0] = pOut;";
+"}"],"mexGetScalar.c");
+ilib_mex_build("libmextest",["getScalar","mexGetScalar","cmex"], "mexGetScalar.c",[]);
 exec("loader.sce");
 a = 1:10;
 assert_checkequal(getScalar(a), 1);
index 6d17234..9e0ff75 100644 (file)
@@ -28,7 +28,7 @@ mputl([ "#include ""mex.h""";
 "   pOut = mxCreateDoubleScalar(dblScalar);";
 "   plhs[0] = pOut;";
 "}"],"mexGetScalar.c");
-ilib_mex_build("libmextest",["getScalar","mexGetScalar","cmex"], "mexGetScalar.c",[],"","","","");
+ilib_mex_build("libmextest",["getScalar","mexGetScalar","cmex"], "mexGetScalar.c",[]);
 exec("loader.sce");
 
 a = 1:10;
index ec70881..2ca5461 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 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",[],"","","","");
+"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",[]);
 exec("loader.sce");
-r = getSetData(double(1));
-assert_checkequal(r(1), 1);
-r = getSetData(int8(2));
-assert_checkequal(r(1), int8(2));
-r = getSetData(int16(3));
-assert_checkequal(r(1), int16(3));
-r = getSetData(int32(4));
-assert_checkequal(r(1), int32(4));
-r = getSetData(int64(5));
-assert_checkequal(r(1), int64(5));
-r = getSetData(uint8(6));
-assert_checkequal(r(1), uint8(6));
-r = getSetData(uint16(7));
-assert_checkequal(r(1), uint16(7));
-r = getSetData(uint32(8));
-assert_checkequal(r(1), uint32(8));
-r = getSetData(uint64(9));
-assert_checkequal(r(1), uint64(9));
-r = getSetData(%t);
-assert_checktrue(r(1));
+assert_checkequal(getSetData(double(1)), 1);
+assert_checkequal(getSetData(int8(2)), int8(2));
+assert_checkequal(getSetData(int16(3)), int16(3));
+assert_checkequal(getSetData(int32(4)), int32(4));
+assert_checkequal(getSetData(int64(5)), int64(5));
+assert_checkequal(getSetData(uint8(6)), uint8(6));
+assert_checkequal(getSetData(uint16(7)), uint16(7));
+assert_checkequal(getSetData(uint32(8)), uint32(8));
+assert_checkequal(getSetData(uint64(9)), uint64(9));
+assert_checktrue(getSetData(%t));
index c69aa77..73f6aed 100644 (file)
@@ -19,26 +19,16 @@ mputl(["#include ""mex.h""";
 "    mxSetData(prhs[0], data);";
 "    plhs[0] = prhs[0];";
 "}"],"mexGetSetData.c");
-ilib_mex_build("libmextest",["getSetData","mexGetSetData","cmex"], "mexGetSetData.c",[],"","","","");
+ilib_mex_build("libmextest",["getSetData","mexGetSetData","cmex"], "mexGetSetData.c",[]);
 exec("loader.sce");
 
-r = getSetData(double(1));
-assert_checkequal(r(1), 1);
-r = getSetData(int8(2));
-assert_checkequal(r(1), int8(2));
-r = getSetData(int16(3));
-assert_checkequal(r(1), int16(3));
-r = getSetData(int32(4));
-assert_checkequal(r(1), int32(4));
-r = getSetData(int64(5));
-assert_checkequal(r(1), int64(5));
-r = getSetData(uint8(6));
-assert_checkequal(r(1), uint8(6));
-r = getSetData(uint16(7));
-assert_checkequal(r(1), uint16(7));
-r = getSetData(uint32(8));
-assert_checkequal(r(1), uint32(8));
-r = getSetData(uint64(9));
-assert_checkequal(r(1), uint64(9));
-r = getSetData(%t);
-assert_checktrue(r(1));
+assert_checkequal(getSetData(double(1)), 1);
+assert_checkequal(getSetData(int8(2)), int8(2));
+assert_checkequal(getSetData(int16(3)), int16(3));
+assert_checkequal(getSetData(int32(4)), int32(4));
+assert_checkequal(getSetData(int64(5)), int64(5));
+assert_checkequal(getSetData(uint8(6)), uint8(6));
+assert_checkequal(getSetData(uint16(7)), uint16(7));
+assert_checkequal(getSetData(uint32(8)), uint32(8));
+assert_checkequal(getSetData(uint64(9)), uint64(9));
+assert_checktrue(getSetData(%t));
index eac15bd..a215444 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl(["#include ""mex.h""";
-       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-       "{";
-       "    void *data = mxGetImagData(prhs[0]);";
-       "    mxSetImagData(prhs[0], data);";
-       "    plhs[0] = prhs[0];";
-       "}"],"mexGetSetImagData.c");
-ilib_mex_build("libmextest",["getSetImagData","mexGetSetImagData","cmex"], "mexGetSetImagData.c",[],"","","","");
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    void *data = mxGetImagData(prhs[0]);";
+"    mxSetImagData(prhs[0], data);";
+"    plhs[0] = prhs[0];";
+"}"],"mexGetSetImagData.c");
+ilib_mex_build("libmextest",["getSetImagData","mexGetSetImagData","cmex"], "mexGetSetImagData.c",[]);
 exec("loader.sce");
 r = getSetImagData(complex(1, 2));
 assert_checkequal(r(1), complex(1, 2));
index eb56b75..5f99cbe 100644 (file)
@@ -19,7 +19,7 @@ mputl(["#include ""mex.h""";
 "    mxSetImagData(prhs[0], data);";
 "    plhs[0] = prhs[0];";
 "}"],"mexGetSetImagData.c");
-ilib_mex_build("libmextest",["getSetImagData","mexGetSetImagData","cmex"], "mexGetSetImagData.c",[],"","","","");
+ilib_mex_build("libmextest",["getSetImagData","mexGetSetImagData","cmex"], "mexGetSetImagData.c",[]);
 exec("loader.sce");
 
 r = getSetImagData(complex(1, 2));
index bb28e23..6f29d4a 100644 (file)
@@ -12,26 +12,26 @@ cd(TMPDIR);
 ilib_verbose(0);
 ilib_verbose(0);
 mputl([ "#include ""mex.h""";
-        "#include ""localization.h""";
-        "";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "   int i = 0;";
-        "   int iRows = 0;";
-        "   int iCols = 0;";
-        "";
-        "   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
-        "   {";
-        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
-        "   }";
-        "";
-        "   iRows = mxGetM(prhs[0]);";
-        "   iCols = mxGetN(prhs[0]);";
-        "   mxSetM(prhs[0], iRows * 2);";
-        "   mxSetN(prhs[0], iCols * 2);";
-        "   plhs[0] = prhs[0];";
-        "}"],"mexGetSetMN.c");
-ilib_mex_build("libmextest",["expand","mexGetSetMN","cmex"], "mexGetSetMN.c",[],"","","","");
+"#include ""localization.h""";
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int i = 0;";
+"   int iRows = 0;";
+"   int iCols = 0;";
+"";
+"   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   iRows = mxGetM(prhs[0]);";
+"   iCols = mxGetN(prhs[0]);";
+"   mxSetM(prhs[0], iRows * 2);";
+"   mxSetN(prhs[0], iCols * 2);";
+"   plhs[0] = prhs[0];";
+"}"],"mexGetSetMN.c");
+ilib_mex_build("libmextest",["expand","mexGetSetMN","cmex"], "mexGetSetMN.c",[]);
 exec("loader.sce");
 a = [1,2;3,4];
 ref = a;
index c2fbed8..6f7c8df 100644 (file)
@@ -34,7 +34,7 @@ mputl([ "#include ""mex.h""";
 "   mxSetN(prhs[0], iCols * 2);";
 "   plhs[0] = prhs[0];";
 "}"],"mexGetSetMN.c");
-ilib_mex_build("libmextest",["expand","mexGetSetMN","cmex"], "mexGetSetMN.c",[],"","","","");
+ilib_mex_build("libmextest",["expand","mexGetSetMN","cmex"], "mexGetSetMN.c",[]);
 exec("loader.sce");
 
 a = [1,2;3,4];
index 053f27b..fea5d09 100644 (file)
 cd(TMPDIR);
 ilib_verbose(0);
 mputl([ "#include ""mex.h""";
-        "";
-        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
-        "{";
-        "   int i = 0;";
-        "   int iSize = 0;";
-        "   mxArray* pOut = NULL;";
-        "   double* pDblR = NULL;";
-        "   double* pDblI = NULL;";
-        "";
-        "   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
-        "   {";
-        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
-        "   }";
-        "";
-        "   iSize = mxGetNumberOfElements(prhs[0]);";
-        "   pDblR = mxGetPr(prhs[0]);";
-        "   pDblI = mxGetPi(prhs[0]);";
-        "   pOut = mxCreateDoubleMatrix(1, iSize, 1);";
-        "   mxSetPr(pOut, pDblI);";
-        "   mxSetPi(pOut, pDblR);";
-        "   plhs[0] = pOut;";
-        "}"],"mexswapRI.c");
-ilib_mex_build("libmextest",["swapRI","mexswapRI","cmex"], "mexswapRI.c",[],"","","","");
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int i = 0;";
+"   int iSize = 0;";
+"   mxArray* pOut = NULL;";
+"   double* pDblR = NULL;";
+"   double* pDblI = NULL;";
+"";
+"   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   iSize = mxGetNumberOfElements(prhs[0]);";
+"   pDblR = mxGetPr(prhs[0]);";
+"   pDblI = mxGetPi(prhs[0]);";
+"   pOut = mxCreateDoubleMatrix(1, iSize, 1);";
+"   mxSetPr(pOut, pDblI);";
+"   mxSetPi(pOut, pDblR);";
+"   plhs[0] = pOut;";
+"}"],"mexswapRI.c");
+ilib_mex_build("libmextest",["swapRI","mexswapRI","cmex"], "mexswapRI.c",[]);
 exec("loader.sce");
 a = 1:8;
 b = 8:-1:1;