Management of errors in differential equations functions. 83/12783/7
Cedric Delamarre [Wed, 2 Oct 2013 09:45:40 +0000 (11:45 +0200)]
Change-Id: Ib7892ed944bb1d48e39824e0f8dac188d4d21ead

19 files changed:
scilab/modules/differential_equations/includes/differentialequationfunctions.hxx
scilab/modules/differential_equations/includes/scifunctions.h
scilab/modules/differential_equations/sci_gateway/cpp/sci_bvode.cpp
scilab/modules/differential_equations/sci_gateway/cpp/sci_daskr.cpp
scilab/modules/differential_equations/sci_gateway/cpp/sci_dasrt.cpp
scilab/modules/differential_equations/sci_gateway/cpp/sci_dassl.cpp
scilab/modules/differential_equations/sci_gateway/cpp/sci_feval.cpp
scilab/modules/differential_equations/sci_gateway/cpp/sci_impl.cpp
scilab/modules/differential_equations/sci_gateway/cpp/sci_int2d.cpp
scilab/modules/differential_equations/sci_gateway/cpp/sci_int3d.cpp
scilab/modules/differential_equations/sci_gateway/cpp/sci_intg.cpp
scilab/modules/differential_equations/sci_gateway/cpp/sci_intg2.cpp [deleted file]
scilab/modules/differential_equations/sci_gateway/cpp/sci_ode.cpp
scilab/modules/differential_equations/sci_gateway/cpp/sci_odedc.cpp
scilab/modules/differential_equations/sci_gateway/differential_equations_gw.vcxproj
scilab/modules/differential_equations/src/cpp/differentialequationfunctions.cpp
scilab/modules/differential_equations/src/cpp/scifunctions.cpp
scilab/modules/differential_equations/tests/nonreg_tests/bug_12118.dia.ref
scilab/modules/differential_equations/tests/nonreg_tests/bug_12118.tst

index 9f3f483..8a227e6 100644 (file)
@@ -39,12 +39,12 @@ extern "C"
     void C2F(lcomp) (int*, double*, double*, double*);
 
     // odedc
-    typedef int(*odedc_f_t)(int*, int*, int*, double *, double*, double*);
-    void C2F(fcd)   (int*, int*, int*, double *, double*, double*);
-    void C2F(fcd1)  (int*, int*, int*, double *, double*, double*);
-    void C2F(fexcd) (int*, int*, int*, double *, double*, double*);
-    void C2F(phis)  (int*, int*, int*, double *, double*, double*);
-    void C2F(phit)  (int*, int*, int*, double *, double*, double*);
+    typedef int(*odedc_f_t)(int*, int*, int*, double*, double*, double*);
+    void C2F(fcd)   (int*, int*, int*, double*, double*, double*);
+    void C2F(fcd1)  (int*, int*, int*, double*, double*, double*);
+    void C2F(fexcd) (int*, int*, int*, double*, double*, double*);
+    void C2F(phis)  (int*, int*, int*, double*, double*, double*);
+    void C2F(phit)  (int*, int*, int*, double*, double*, double*);
 
     // intg
     double C2F(intgex)(double*);
@@ -130,15 +130,15 @@ public :
     int getOdedcYDSize();
     int getOdedcFlag();
 
-    int execOdeF(int* n, double* t, double* y, double* ydot);
-    int execFunctionJac(int *n, double *t, double *y, int *ml, int *mu, double *J, int *nrpd);
-    int execFunctionG(int* n, double* t, double* y, int* ng, double* gout);
+    void execOdeF(int* n, double* t, double* y, double* ydot);
+    void execFunctionJac(int* n, double* t, double* y, int* ml, int* mu, double* J, int* nrpd);
+    void execFunctionG(int* n, double* t, double* y, int* ng, double* gout);
 
     double execIntgF(double* x);
     double execInt2dF(double* x, double* y);
-    double execInt3dF(double* x, int* numfun, double* funvls);
+    void execInt3dF(double* x, int* numfun, double* funvls);
 
-    int execFevalF(int *nn, double *x1, double *x2, double *xres, int *itype);
+    void execFevalF(int* nn, double* x1, double* x2, double* xres, int* itype);
 
     // bvode
     void setFsubFunction(types::Callable*);
@@ -162,33 +162,33 @@ public :
     void setBvodeM(int);
     void setBvodeN(int);
 
-    int execBvodeGsub(int*, double*, double*);
-    int execBvodeDgsub(int*, double*, double*);
-    int execBvodeFsub(double*, double*, double*);
-    int execBvodeDfsub(double*, double*, double*);
-    int execBvodeGuess(double*, double*, double*);
+    void execBvodeGsub(int*, double*, double*);
+    void execBvodeDgsub(int*, double*, double*);
+    void execBvodeFsub(double*, double*, double*);
+    void execBvodeDfsub(double*, double*, double*);
+    void execBvodeGuess(double*, double*, double*);
 
     // impl
-    int execImplF(int*, double*, double*, double*, double*, int*);
-    int execImplG(int*, double*, double*, double*, double*, double*, int*);
-    int execImplJac(int*, double*, double*, double*, double*, double*, double*, int*);
+    void execImplF(int*, double*, double*, double*, double*, int*);
+    void execImplG(int*, double*, double*, double*, double*, double*, int*);
+    void execImplJac(int*, double*, double*, double*, double*, double*, double*, int*);
 
     //dassl dasrt
-    int execDasslF(double*, double*, double*, double*, int*, double*, int*);
-    int execDasslJac(double*, double*, double*, double*, double*, double*, int*);
+    void execDasslF(double*, double*, double*, double*, int*, double*, int*);
+    void execDasslJac(double*, double*, double*, double*, double*, double*, int*);
     void setMu(int);
     void setMl(int);
 
     // dasrt
-    int execDasrtG(int*, double*, double*, int*, double*, double*, int*);
+    void execDasrtG(int*, double*, double*, int*, double*, double*, int*);
 
     // daskr
-    int execDaskrPsol(int* neq, double* t, double* y, double* ydot, double* savr, double* wk,
-                      double* cj, double* wght, double* wp, int* iwp, double* b, double* eplin,
-                      int* iter, double* rpar, int* ipar);
-    int execDaskrPjac(double* res, int* ires, int* neq, double* t, double* y, double* ydot,
-                      double* rewt, double* savr, double* wk, double* h, double* cj,
-                      double* wp, int* iwp, int* ier, double* rpar, int* ipar);
+    void execDaskrPsol(int* neq, double* t, double* y, double* ydot, double* savr, double* wk,
+                       double* cj, double* wght, double* wp, int* iwp, double* b, double* eplin,
+                       int* iter, double* rpar, int* ipar);
+    void execDaskrPjac(double* res, int* ires, int* neq, double* t, double* y, double* ydot,
+                       double* rewt, double* savr, double* wk, double* h, double* cj,
+                       double* wp, int* iwp, int* ier, double* rpar, int* ipar);
 
 
 private :
@@ -237,9 +237,9 @@ private :
     std::vector<types::InternalType*> m_pJacArgs;
 
     // ode / odedc
-    int callOdeMacroF(int* n, double* t, double* y, double* ydot);
-    int callMacroJac(int *n, double *t, double *y, int *ml, int *mu, double *J, int *nrpd);
-    int callMacroG(int* n, double* t, double* y, int* ng, double* gout);
+    void callOdeMacroF(int* n, double* t, double* y, double* ydot);
+    void callMacroJac(int *n, double *t, double *y, int *ml, int *mu, double *J, int *nrpd);
+    void callMacroG(int* n, double* t, double* y, int* ng, double* gout);
 
     // intg
     double callIntgMacroF(double* x);
@@ -248,10 +248,10 @@ private :
     double callInt2dMacroF(double* x, double* y);
 
     // int3d
-    double callInt3dMacroF(double* x, int* numfun, double* funvls);
+    void callInt3dMacroF(double* x, int* numfun, double* funvls);
 
     // feval
-    int callFevalMacroF(int *nn, double *x1, double *x2, double *xres, int *itype);
+    void callFevalMacroF(int *nn, double *x1, double *x2, double *xres, int *itype);
 
     // bvode
     types::Callable* m_pCallFsubFunction;
@@ -278,31 +278,31 @@ private :
     std::vector<types::InternalType*> m_DgsubArgs;
     std::vector<types::InternalType*> m_GuessArgs;
 
-    int callBvodeMacroGsub  (int* i, double* z, double* g);
-    int callBvodeMacroDgsub (int* i, double* z, double* g);
-    int callBvodeMacroFsub  (double* x, double* z, double* d);
-    int callBvodeMacroDfsub (double* x, double* z, double* d);
-    int callBvodeMacroGuess (double* x, double* z, double* d);
+    void callBvodeMacroGsub  (int* i, double* z, double* g);
+    void callBvodeMacroDgsub (int* i, double* z, double* g);
+    void callBvodeMacroFsub  (double* x, double* z, double* d);
+    void callBvodeMacroDfsub (double* x, double* z, double* d);
+    void callBvodeMacroGuess (double* x, double* z, double* d);
 
     // impl
-    int callImplMacroF(int*, double*, double*, double*, double*, int*);
-    int callImplMacroG(int*, double*, double*, double*, double*, double*, int*);
-    int callImplMacroJac(int*, double*, double*, double*, double*, double*, double*, int*);
+    void callImplMacroF(int*, double*, double*, double*, double*, int*);
+    void callImplMacroG(int*, double*, double*, double*, double*, double*, int*);
+    void callImplMacroJac(int*, double*, double*, double*, double*, double*, double*, int*);
 
     // dassl dasrt
-    int callDasslMacroF(double*, double*, double*, double*, int*, double*, int*);
-    int callDasslMacroJac(double*, double*, double*, double*, double*, double*, int*);
+    void callDasslMacroF(double*, double*, double*, double*, int*, double*, int*);
+    void callDasslMacroJac(double*, double*, double*, double*, double*, double*, int*);
 
     // dasrt
-    int callDasrtMacroG(int*, double*, double*, int*, double*, double*, int*);
+    void callDasrtMacroG(int*, double*, double*, int*, double*, double*, int*);
 
     // daskr
-    int callDaskrMacroPsol(int* neq, double* t, double* y, double* ydot, double* savr, double* wk,
-                           double* cj, double* wght, double* wp, int* iwp, double* b, double* eplin,
-                           int* iter, double* rpar, int* ipar);
-    int callDaskrMacroPjac(double* res, int* ires, int* neq, double* t, double* y, double* ydot,
-                           double* rewt, double* savr, double* wk, double* h, double* cj,
-                           double* wp, int* iwp, int* ier, double* rpar, int* ipar);
+    void callDaskrMacroPsol(int* neq, double* t, double* y, double* ydot, double* savr, double* wk,
+                            double* cj, double* wght, double* wp, int* iwp, double* b, double* eplin,
+                            int* iter, double* rpar, int* ipar);
+    void callDaskrMacroPjac(double* res, int* ires, int* neq, double* t, double* y, double* ydot,
+                            double* rewt, double* savr, double* wk, double* h, double* cj,
+                            double* wp, int* iwp, int* ier, double* rpar, int* ipar);
 };
 
 class DIFFERENTIAL_EQUATIONS_IMPEXP DifferentialEquation
index 9760fba..f725734 100644 (file)
@@ -14,9 +14,9 @@
 #include "dynlib_differential_equations.h"
 
 // ode / odedc
-typedef int(*ode_f_t)(int *n, double *t, double *y, double *ydot);
-typedef int(*func_jac_t)(int *n, double *t, double *y, int *ml, int *mu, double *J, int *nrpd);
-typedef int(*func_g_t)(int *n, double *t, double *y, int *ng, double *gout);
+typedef void(*ode_f_t)(int *n, double *t, double *y, double *ydot);
+typedef void(*func_jac_t)(int *n, double *t, double *y, int *ml, int *mu, double *J, int *nrpd);
+typedef void(*func_g_t)(int *n, double *t, double *y, int *ng, double *gout);
 
 extern double C2F(lsoda)(ode_f_t, int*, double*, double*, double*, int*, double*, double*, int*, int*, int*, double*, int*, int*, int*, func_jac_t, int*);
 extern double C2F(lsode)(ode_f_t, int*, double*, double*, double*, int*, double*, double*, int*, int*, int*, double*, int*, int*, int*, func_jac_t, int*);
@@ -26,9 +26,9 @@ extern double C2F(lsrgk)(ode_f_t, int*, double*, double*, double*, int*, double*
 extern double C2F(rkf45)(ode_f_t, int*, double*, double*, double*, int*, double*, double*, int*, int*, int*, double*, int*, int*, int*, func_jac_t, int*);
 extern double C2F(rksimp)(ode_f_t, int*, double*, double*, double*, int*, double*, double*, int*, int*, int*, double*, int*, int*, int*, func_jac_t, int*);
 
-DIFFERENTIAL_EQUATIONS_IMPEXP int ode_f(int* n, double* t, double* y, double* ydot);
-DIFFERENTIAL_EQUATIONS_IMPEXP int ode_jac(int *n, double *t, double *y, int *ml, int *mu, double *J, int *nrpd);
-DIFFERENTIAL_EQUATIONS_IMPEXP int ode_g(int *n, double *t, double *y, int *ng, double *gout);
+DIFFERENTIAL_EQUATIONS_IMPEXP void ode_f(int* n, double* t, double* y, double* ydot);
+DIFFERENTIAL_EQUATIONS_IMPEXP void ode_jac(int *n, double *t, double *y, int *ml, int *mu, double *J, int *nrpd);
+DIFFERENTIAL_EQUATIONS_IMPEXP void ode_g(int *n, double *t, double *y, int *ng, double *gout);
 
 // intg
 typedef double(*intg_f_t)(double*);
@@ -45,58 +45,58 @@ extern double C2F(twodq)(int2d_f_t, int*, double*, double*, double*, int*, int*,
 DIFFERENTIAL_EQUATIONS_IMPEXP double int2d_f(double*, double*);
 
 // int3d
-typedef double(*int3d_f_t)(double*, int*, double*);
+typedef void(*int3d_f_t)(double*, int*, double*);
 
 extern double C2F(dcutet)(int3d_f_t, int*, double*, int*, int*, int*, double*, double*, int*, int*, int*, double*, double*, int*, int*, double*, int*);
 
-DIFFERENTIAL_EQUATIONS_IMPEXP double int3d_f(double*, int*, double*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void int3d_f(double*, int*, double*);
 
 // feval
-typedef int(*feval_f_t)(int*, double*, double*, double*, int*);
+typedef void(*feval_f_t)(int*, double*, double*, double*, int*);
 
 // bvode
-typedef int(*bvode_idd_t)(int*, double*, double*);
-typedef int(*bvode_ddd_t)(double*, double*, double*);
+typedef void(*bvode_idd_t)(int*, double*, double*);
+typedef void(*bvode_ddd_t)(double*, double*, double*);
 
 extern double C2F(colnew)(int*, int*, double*, double*, double*, int*, int*, double*, double*, int*, double*, int*, bvode_ddd_t, bvode_ddd_t, bvode_idd_t, bvode_idd_t, bvode_ddd_t);
 
 extern double C2F(appsln)(double*, double*, double*, int*);
 
-DIFFERENTIAL_EQUATIONS_IMPEXP int bvode_gsub(int*, double*, double*);
-DIFFERENTIAL_EQUATIONS_IMPEXP int bvode_dgsub(int*, double*, double*);
-DIFFERENTIAL_EQUATIONS_IMPEXP int bvode_fsub(double*, double*, double*);
-DIFFERENTIAL_EQUATIONS_IMPEXP int bvode_dfsub(double*, double*, double*);
-DIFFERENTIAL_EQUATIONS_IMPEXP int bvode_guess(double*, double*, double*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void bvode_gsub(int*, double*, double*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void bvode_dgsub(int*, double*, double*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void bvode_fsub(double*, double*, double*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void bvode_dfsub(double*, double*, double*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void bvode_guess(double*, double*, double*);
 
 // impl
-typedef int(*impl_f_t)(int*, double*, double*, double*, double*, int*);
-typedef int(*impl_g_t)(int*, double*, double*, double*, double*, double*, int*);
-typedef int(*impl_jac_t)(int*, double*, double*, double*, double*, double*, double*, int*);
+typedef void(*impl_f_t)(int*, double*, double*, double*, double*, int*);
+typedef void(*impl_g_t)(int*, double*, double*, double*, double*, double*, int*);
+typedef void(*impl_jac_t)(int*, double*, double*, double*, double*, double*, double*, int*);
 
 DIFFERENTIAL_EQUATIONS_IMPEXP extern double C2F(lsodi)(impl_f_t, impl_g_t, impl_jac_t, int*, double*, double*, double*, double*, int*, double*, double*, int*, int*, int*, double*, int*, int*, int*, int*);
 
-DIFFERENTIAL_EQUATIONS_IMPEXP int impl_f(int*, double*, double*, double*, double*, int*);
-DIFFERENTIAL_EQUATIONS_IMPEXP int impl_g(int*, double*, double*, double*, double*, double*, int*);
-DIFFERENTIAL_EQUATIONS_IMPEXP int impl_jac(int*, double*, double*, double*, double*, double*, double*, int*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void impl_f(int*, double*, double*, double*, double*, int*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void impl_g(int*, double*, double*, double*, double*, double*, int*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void impl_jac(int*, double*, double*, double*, double*, double*, double*, int*);
 
 //dassl dasrt daskr
-typedef int(*dassl_f_t)(double*, double*, double*, double*, int*, double*, int*);
-typedef int(*dassl_jac_t)(double*, double*, double*, double*, double*, double*, int*);
+typedef void(*dassl_f_t)(double*, double*, double*, double*, int*, double*, int*);
+typedef void(*dassl_jac_t)(double*, double*, double*, double*, double*, double*, int*);
 
 extern void C2F(dassl)(dassl_f_t, int*, double*, double*, double*, double*, int*, double*, double*, int*, double*, int*, int*, int*, double*, int*, dassl_jac_t);
 
-DIFFERENTIAL_EQUATIONS_IMPEXP int dassl_f(double*, double*, double*, double*, int*, double*, int*);
-DIFFERENTIAL_EQUATIONS_IMPEXP int dassl_jac(double*, double*, double*, double*, double*, double*, int*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void dassl_f(double*, double*, double*, double*, int*, double*, int*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void dassl_jac(double*, double*, double*, double*, double*, double*, int*);
 
 //dasrt
-typedef int(*dasrt_g_t)(int*, double*, double*, int*, double*, double*, int*);
+typedef void(*dasrt_g_t)(int*, double*, double*, int*, double*, double*, int*);
 extern void C2F(ddasrt)(dassl_f_t, int*, double*, double*, double*, double*, int*, double*, double*, int*, double*, int*, int*, int*, double*, int*, dassl_jac_t, dasrt_g_t, int*, int*);
-DIFFERENTIAL_EQUATIONS_IMPEXP int dasrt_g(int*, double*, double*, int*, double*, double*, int*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void dasrt_g(int*, double*, double*, int*, double*, double*, int*);
 
 //daskr
-typedef int(*daskr_psol_t)(int*, double*, double*, double*, double*, double*, double*, double*, double*, int*, double*, double*, int*, double*, int*);
-typedef int(*daskr_pjac_t)(double*, int*, int*, double*, double*, double*, double*, double*, double*, double*, double*, double*, int*, int*, double*, int*);
+typedef void(*daskr_psol_t)(int*, double*, double*, double*, double*, double*, double*, double*, double*, int*, double*, double*, int*, double*, int*);
+typedef void(*daskr_pjac_t)(double*, int*, int*, double*, double*, double*, double*, double*, double*, double*, double*, double*, int*, int*, double*, int*);
 extern void C2F(ddaskr)(dassl_f_t, int*, double*, double*, double*, double*, int*, double*, double*, int*, double*, int*, int*, int*, double*, int*, void*/*dassl_jac_t or daskr_pjac_t*/, daskr_psol_t, dasrt_g_t, int*, int*);
-DIFFERENTIAL_EQUATIONS_IMPEXP int daskr_psol(int*, double*, double*, double*, double*, double*, double*, double*, double*, int*, double*, double*, int*, double*, int*);
-DIFFERENTIAL_EQUATIONS_IMPEXP int daskr_pjac(double*, int*, int*, double*, double*, double*, double*, double*, double*, double*, double*, double*, int*, int*, double*, int*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void daskr_psol(int*, double*, double*, double*, double*, double*, double*, double*, double*, int*, double*, double*, int*, double*, int*);
+DIFFERENTIAL_EQUATIONS_IMPEXP void daskr_pjac(double*, int*, int*, double*, double*, double*, double*, double*, double*, double*, double*, double*, int*, int*, double*, int*);
 
index 4c00695..c527674 100644 (file)
@@ -1,6 +1,6 @@
 /*
 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-* Copyright (//) 2011 - DIGITEO - Cedric DELAMARRE
+* Copyright (C) 2011 - DIGITEO - Cedric DELAMARRE
 *
 * This file must be used under the terms of the CeCILL.
 * This source file is licensed as described in the file COPYING, which
@@ -25,6 +25,7 @@ extern "C"
 #include "localization.h"
 #include "Scierror.h"
 #include "scifunctions.h"
+#include "sciprint.h"
 }
 
 /*--------------------------------------------------------------------------*/
@@ -68,7 +69,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     // xpoints
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "bvode", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "bvode", iPos + 1);
         return types::Function::Error;
     }
 
@@ -78,7 +79,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     // ncomp
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "bvode", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "bvode", iPos + 1);
         return types::Function::Error;
     }
 
@@ -86,7 +87,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
 
     if (pDblN->isScalar() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "bvode", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "bvode", iPos + 1);
         return types::Function::Error;
     }
 
@@ -94,7 +95,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
 
     if (ncomp > 20)
     {
-        Scierror(999, _("%s: Wrong value for input argument #%d : Value at most 20 expected.\n"), "bvode", iPos + 1);
+        Scierror(999, _("%s: Wrong value for input argument #%d: Value at most 20 expected.\n"), "bvode", iPos + 1);
         return types::Function::Error;
     }
     iPos++;
@@ -102,7 +103,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     // m
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "bvode", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "bvode", iPos + 1);
         return types::Function::Error;
     }
 
@@ -110,11 +111,11 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
 
     if (pDblM->getSize() != ncomp)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A vector of size %d (N) expected.\n"), "bvode", iPos + 1, ncomp);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A vector of size %d (N) expected.\n"), "bvode", iPos + 1, ncomp);
         return types::Function::Error;
     }
 
-    int* M = (int*)malloc(pDblM->getSize() * sizeof(int));
+    int* M = (int*)MALLOC(pDblM->getSize() * sizeof(int));
     for (int i = 0; i < pDblM->getSize(); i++)
     {
         M[i] = (int)pDblM->get(i);
@@ -124,8 +125,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
 
     if (sumM > 40)
     {
-        Scierror(999, _("%s: Wrong value for input argument #%d : Sum of m (%d) must be less than 40.\n"), "bvode", iPos + 1, sumM);
-        free(M);
+        Scierror(999, _("%s: Wrong value for input argument #%d: Sum of m (%d) must be less than 40.\n"), "bvode", iPos + 1, sumM);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -134,8 +135,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     // aleft
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "bvode", iPos + 1);
-        free(M);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "bvode", iPos + 1);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -143,8 +144,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
 
     if (pDblXLow->isScalar() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "bvode", iPos + 1);
-        free(M);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "bvode", iPos + 1);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -154,8 +155,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     // aright
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "bvode", iPos + 1);
-        free(M);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "bvode", iPos + 1);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -163,8 +164,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
 
     if (pDblXUp->isScalar() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "bvode", iPos + 1);
-        free(M);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "bvode", iPos + 1);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -174,8 +175,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     // zeta
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "bvode", iPos + 1);
-        free(M);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "bvode", iPos + 1);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -185,8 +186,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     {
         if (pDblZeta->get(i) > pDblZeta->get(i + 1))
         {
-            Scierror(999, _("%s: Wrong value for input argument #%d : zeta(j) lower or equal to zeta(j+1) expected.\n"), "bvode", iPos + 1);
-            free(M);
+            Scierror(999, _("%s: Wrong value for input argument #%d: zeta(j) lower or equal to zeta(j+1) expected.\n"), "bvode", iPos + 1);
+            FREE(M);
             return types::Function::Error;
         }
     }
@@ -196,8 +197,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     // ipar
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "bvode", iPos + 1);
-        free(M);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "bvode", iPos + 1);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -205,8 +206,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
 
     if (pDblIpar->getSize() != 11)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A vector of size 11 expected.\n"), "bvode", iPos + 1);
-        free(M);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A vector of size 11 expected.\n"), "bvode", iPos + 1);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -221,7 +222,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     if (ipar[0] != 0 && ipar[0] != 1)
     {
         Scierror(999, _("%s: Wrong value for input argument #%d: Wrong value for element %s: %d or %d expected.\n"), "bvode", iPos + 1, 1, 0, 1);
-        free(M);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -234,7 +235,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     if (ipar[1] < 0 || ipar[1] > 7)
     {
         Scierror(999, _("%s: Wrong value for input argument #%d: Wrong value for element %s: %d to %d expected.\n"), "bvode", iPos + 1, 2, 0, 7);
-        free(M);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -248,7 +249,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     if (ipar[3] < 0 || ipar[3] > sumM)
     {
         Scierror(999, _("%s: Wrong value for input argument #%d: Wrong value for element %s: %d to sum of m (=%d) expected.\n"), "bvode", iPos + 1, 4, 0, sumM);
-        free(M);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -270,7 +271,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     if (ipar[4] < nmax * nsizef)
     {
         Scierror(999, _("%s: Wrong value for input argument #%d: Wrong value for element %d.\n"), "bvode", iPos + 1, 5);
-        free(M);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -279,7 +280,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     if (ipar[5] < nmax * nsizei)
     {
         Scierror(999, _("%s: Wrong value for input argument #%d: Wrong value for element %d.\n"), "bvode", iPos + 1, 6);
-        free(M);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -287,7 +288,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     if (ipar[6] < -1 || ipar[6] > 1)
     {
         Scierror(999, _("%s: Wrong value for input argument #%d: Wrong value for element %d: %d to %d expected.\n"), "bvode", iPos + 1, 7, -1, 1);
-        free(M);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -295,7 +296,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     if (ipar[7] < 0 || ipar[7] > 2)
     {
         Scierror(999, _("%s: Wrong value for input argument #%d: Wrong value for element %d: %d to %d expected.\n"), "bvode", iPos + 1, 8, 0, 2);
-        free(M);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -303,7 +304,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     if (ipar[8] < 0 || ipar[8] > 4)
     {
         Scierror(999, _("%s: Wrong value for input argument #%d: Wrong value for element %d: %d to %d expected.\n"), "bvode", iPos + 1, 9, 0, 4);
-        free(M);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -311,7 +312,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     if (ipar[9] < 0 || ipar[9] > 2)
     {
         Scierror(999, _("%s: Wrong value for input argument #%d: Wrong value for element %d: %d to %d expected.\n"), "bvode", iPos + 1, 9, 0, 2);
-        free(M);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -321,8 +322,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     // ltol
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "bvode", iPos + 1);
-        free(M);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "bvode", iPos + 1);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -330,8 +331,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
 
     if (pDblLtol->getSize() != ipar[3])
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : An array of size %d (ipar(4)) expected.\n"), "bvode", iPos + 1, ipar[3]);
-        free(M);
+        Scierror(999, _("%s: Wrong size for input argument #%d: An array of size %d (ipar(4)) expected.\n"), "bvode", iPos + 1, ipar[3]);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -343,8 +344,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     double* pdblLtol = pDblLtol->get();
     if (pdblLtol[0] < 1 || pdblLtol[0] > sumM)
     {
-        Scierror(999, _("%s: Wrong value for input argument #%d : %d to sum of m (=%d) expected.\n"), "bvode", iPos + 1, 1, sumM);
-        free(M);
+        Scierror(999, _("%s: Wrong value for input argument #%d: %d to sum of m (=%d) expected.\n"), "bvode", iPos + 1, 1, sumM);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -353,8 +354,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     {
         if (pdblLtol[i - 1] >= pdblLtol[i] || pdblLtol[i - 1] > sumM)
         {
-            Scierror(999, _("%s: Wrong value for input argument #%d : Bad value for ltol(%d) : ltol(1) < ltol(2) < ... < ltol(NTOL) <= M (sum of m) expected.\n"), "bvode", iPos + 1, i);
-            free(M);
+            Scierror(999, _("%s: Wrong value for input argument #%d: Bad value for ltol(%d): ltol(1) < ltol(2) < ... < ltol(NTOL) <= M (sum of m) expected.\n"), "bvode", iPos + 1, i);
+            FREE(M);
             return types::Function::Error;
         }
     }
@@ -364,8 +365,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     // tol
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "bvode", iPos + 1);
-        free(M);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "bvode", iPos + 1);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -373,8 +374,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
 
     if (pDblTol->getSize() != ipar[3])
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : An array of size %d (ipar(4)) expected.\n"), "bvode", iPos + 1, ipar[3]);
-        free(M);
+        Scierror(999, _("%s: Wrong size for input argument #%d: An array of size %d (ipar(4)) expected.\n"), "bvode", iPos + 1, ipar[3]);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -383,8 +384,8 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     // fixpnt
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "bvode", iPos + 1);
-        free(M);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "bvode", iPos + 1);
+        FREE(M);
         return types::Function::Error;
     }
 
@@ -392,14 +393,14 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
 
     if (pDblFixpnt->getSize() != ipar[10] && ipar[10] != 0)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : An array of size %d (ipar(11)) expected.\n"), "bvode", iPos + 1, ipar[10]);
-        free(M);
+        Scierror(999, _("%s: Wrong size for input argument #%d: An array of size %d (ipar(11)) expected.\n"), "bvode", iPos + 1, ipar[10]);
+        FREE(M);
         return types::Function::Error;
     }
 
     iPos++;
 
-    // functions : fsub,dfsub,gsub,dgsub,guess
+    // functions: fsub,dfsub,gsub,dgsub,guess
     DifferentialEquationFunctions* deFunctionsManager = new DifferentialEquationFunctions(L"bvode");
     DifferentialEquation::addDifferentialEquationFunctions(deFunctionsManager);
     deFunctionsManager->setBvodeM(sumM);
@@ -462,7 +463,7 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
                 Scierror(50, _("%s: Subroutine not found: %s\n"), "bvode", pst);
                 FREE(pst);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(M);
+                FREE(M);
                 return types::Function::Error;
             }
         }
@@ -472,9 +473,9 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
 
             if (pList->getSize() == 0)
             {
-                Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "bvode", i + 1, "(string empty)");
+                Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "bvode", i + 1, "(string empty)");
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(M);
+                FREE(M);
                 return types::Function::Error;
             }
 
@@ -523,101 +524,50 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : The first argument in the list must be a Scilab function.\n"), "bvode", i + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: The first argument in the list must be a Scilab function.\n"), "bvode", i + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(M);
+                FREE(M);
                 return types::Function::Error;
             }
         }
         else
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A function expected.\n"), "bvode", i + 1);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A function expected.\n"), "bvode", i + 1);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(M);
+            FREE(M);
             return types::Function::Error;
         }
     }
 
-    // *** check functions. ***
-
-    int ret     = 0;
-    int i       = 1;
-    double x    = 1;
-    double* z   = (double*)malloc(sumM * sizeof(double));
-    double* d   = (double*)malloc(ncomp * sumM * sizeof(double)); // max size
-
-    memset(z, 0x01, sumM);
-
-    // fsub
-    ret = bvode_fsub(&x, z, d);
-    if (ret == 0)
-    {
-        Scierror(98, _("%s: Argument #%d : Execution of %s function failed.\n"), "bvode", 11, "fsub");
-        free(d);
-        free(z);
-        DifferentialEquation::removeDifferentialEquationFunctions();
-        return types::Function::Error;
-    }
+    // *** Perform operation. ***
+    double* rwork   = (double*)MALLOC(ipar[4] * sizeof(double));
+    int* iwork      = (int*)MALLOC(ipar[5] * sizeof(int));
+    int* ltol       = (int*)MALLOC(pDblLtol->getSize() * sizeof(int));
 
-    // dfsub
-    ret = bvode_dfsub(&x, z, d);
-    if (ret == 0)
+    for (int i = 0; i < pDblLtol->getSize(); i++)
     {
-        Scierror(98, _("%s: Argument #%d : Execution of %s function failed.\n"), "bvode", 12, "dfsub");
-        free(d);
-        free(z);
-        DifferentialEquation::removeDifferentialEquationFunctions();
-        return types::Function::Error;
+        ltol[i] = (int)pDblLtol->get(i);
     }
 
-    // gsub
-    ret = bvode_gsub(&i, z, d);
-    if (ret == 0)
+    try
     {
-        Scierror(98, _("%s: Argument #%d : Execution of %s function failed.\n"), "bvode", 13, "gsub");
-        free(d);
-        free(z);
-        DifferentialEquation::removeDifferentialEquationFunctions();
-        return types::Function::Error;
+        C2F(colnew)(&ncomp, M, &aleft, &aright, pDblZeta->get(), ipar, ltol, pDblTol->get(), pDblFixpnt->get(), iwork, rwork, &iflag, bvode_fsub, bvode_dfsub, bvode_gsub, bvode_dgsub, bvode_guess);
     }
-
-    // dgsub
-    ret = bvode_dgsub(&i, z, d);
-    if (ret == 0)
+    catch (ScilabError &e)
     {
-        Scierror(98, _("%s: Argument #%d : Execution of ls function failed.\n"), "bvode", 14, "dgsub");
-        free(d);
-        free(z);
+        char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+        sciprint(_("%s: exception caught in '%s' subroutine.\n"), "bvode", "colnew");
+        Scierror(999, pstrMsg);
+        FREE(pstrMsg);
+        FREE(iwork);
+        FREE(rwork);
+        FREE(M);
+        FREE(ltol);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        return types::Function::Error;
-    }
 
-    // guess
-    ret = bvode_guess(&x, z, d);
-    if (ret == 0)
-    {
-        Scierror(98, _("%s: Argument #%d : Execution of %s function failed.\n"), "bvode", 15, "guess");
-        free(d);
-        free(z);
-        DifferentialEquation::removeDifferentialEquationFunctions();
         return types::Function::Error;
     }
 
-    free(d);
-    free(z);
-
-    // *** Perform operation. ***
-    double* rwork   = (double*)malloc(ipar[4] * sizeof(double));
-    int* iwork      = (int*)malloc(ipar[5] * sizeof(int));
-    int* ltol       = (int*)malloc(pDblLtol->getSize() * sizeof(int));
-
-    for (int i = 0; i < pDblLtol->getSize(); i++)
-    {
-        ltol[i] = (int)pDblLtol->get(i);
-    }
-
-    C2F(colnew)(&ncomp, M, &aleft, &aright, pDblZeta->get(), ipar, ltol, pDblTol->get(), pDblFixpnt->get(), iwork, rwork, &iflag, bvode_fsub, bvode_dfsub, bvode_gsub, bvode_dgsub, bvode_guess);
-
     if (iflag != 1)
     {
         if (iflag == 0)
@@ -637,17 +587,17 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
             Scierror(999, _("%s: There is an input data error.\n"), "bvode");
         }
 
-        free(iwork);
-        free(rwork);
-        free(M);
-        free(ltol);
+        FREE(iwork);
+        FREE(rwork);
+        FREE(M);
+        FREE(ltol);
         DifferentialEquation::removeDifferentialEquationFunctions();
 
         return types::Function::Error;
     }
 
     types::Double* pDblRes = new types::Double(sumM, pDblXpts->getSize());
-    double* res = (double*)malloc(pDblXpts->getSize() * sumM * sizeof(double));
+    double* res = (double*)MALLOC(pDblXpts->getSize() * sumM * sizeof(double));
     for (int i = 0; i < pDblXpts->getSize(); i++)
     {
         double val = pDblXpts->get(i);
@@ -656,11 +606,11 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
 
     pDblRes->set(res);
 
-    free(iwork);
-    free(rwork);
-    free(M);
-    free(ltol);
-    free(res);
+    FREE(iwork);
+    FREE(rwork);
+    FREE(M);
+    FREE(ltol);
+    FREE(res);
     DifferentialEquation::removeDifferentialEquationFunctions();
 
     // *** Return result in Scilab. ***
index 7de27cd..98db92b 100644 (file)
@@ -97,7 +97,7 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
     bool bListInfo  = false;
 
     // *** check the minimal number of input args. ***
-    if (in.size() < 6 || in.size() > 13)
+    if ((int)in.size() < 6 || (int)in.size() > 13)
     {
         Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "daskr", 6, 13);
         return types::Function::Error;
@@ -114,7 +114,7 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
     // x0 = [y0, yd0]
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "daskr", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "daskr", iPos + 1);
         return types::Function::Error;
     }
 
@@ -122,13 +122,13 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
 
     if (pDblX0->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "daskr", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "daskr", iPos + 1);
         return types::Function::Error;
     }
 
     if (pDblX0->getCols() > 2)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A real matrix with %d to %d colomn(s) expected.\n"), "daskr", iPos + 1, 1, 2);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A real matrix with %d to %d colomn(s) expected.\n"), "daskr", iPos + 1, 1, 2);
         return types::Function::Error;
     }
 
@@ -137,11 +137,11 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
         info[10] = 1;
     }
 
-    YSize = (int*)malloc(sizeOfYSize * sizeof(int));
+    YSize = (int*)MALLOC(sizeOfYSize * sizeof(int));
     *YSize = pDblX0->getRows();
 
-    pdYData = (double*)malloc(*YSize * sizeof(double));
-    pdYdotData = (double*)malloc(*YSize * sizeof(double));
+    pdYData = (double*)MALLOC(*YSize * sizeof(double));
+    pdYdotData = (double*)MALLOC(*YSize * sizeof(double));
 
     C2F(dcopy)(YSize, pDblX0->get(), &iOne, pdYData, &iOne);
     if (pDblX0->getCols() == 2)
@@ -157,7 +157,7 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "daskr", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "daskr", iPos + 1);
         return types::Function::Error;
     }
 
@@ -165,7 +165,7 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
 
     if (pDblT0->isScalar() == false)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "daskr", iPos + 1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), "daskr", iPos + 1);
         return types::Function::Error;
     }
 
@@ -173,7 +173,7 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "daskr", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "daskr", iPos + 1);
         return types::Function::Error;
     }
 
@@ -181,7 +181,7 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
 
     if (pDblT->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "daskr", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "daskr", iPos + 1);
         return types::Function::Error;
     }
 
@@ -200,11 +200,11 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
                 pDblAtol = in[iPos]->getAs<types::Double>();
                 if (pDblAtol->getSize() != pDblX0->getRows() && pDblAtol->isScalar() == false)
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : A scalar or a matrix of size %d expected.\n"), "daskr", iPos + 1, pDblX0->getRows());
+                    Scierror(267, _("%s: Wrong size for input argument #%d: A scalar or a matrix of size %d expected.\n"), "daskr", iPos + 1, pDblX0->getRows());
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
@@ -213,11 +213,11 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
                 pDblRtol = in[iPos]->getAs<types::Double>();
                 if (pDblAtol->getSize() != pDblRtol->getSize())
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : Atol and Rtol must have the same size.\n"), "daskr", iPos + 1, pDblX0->getRows());
+                    Scierror(267, _("%s: Wrong size for input argument #%d: Atol and Rtol must have the same size.\n"), "daskr", iPos + 1, pDblX0->getRows());
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
@@ -226,11 +226,11 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
                 pDblNg = in[iPos]->getAs<types::Double>();
                 if (pDblNg->isScalar() == false)
                 {
-                    Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "daskr", iPos + 1);
+                    Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), "daskr", iPos + 1);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
                 ng = (int)pDblNg->get(0);
@@ -238,23 +238,23 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
             else if (pDblHd == NULL && bFuncF == true)
             {
                 pDblHd = in[iPos]->getAs<types::Double>();
-                if (in.size() != iPos + 1)
+                if ((int)in.size() != iPos + 1)
                 {
                     Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "daskr", iPos + 1);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A function expected.\n"), "daskr", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A function expected.\n"), "daskr", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -288,11 +288,11 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a list expected.\n"), "daskr", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a list expected.\n"), "daskr", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -328,11 +328,11 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a list expected.\n"), "daskr", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a list expected.\n"), "daskr", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
@@ -342,9 +342,9 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
                 Scierror(50, _("%s: Subroutine not found: %s\n"), "daskr", pst);
                 FREE(pst);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -354,21 +354,21 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
 
             if (pList->getSize() == 0)
             {
-                Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "daskr", iPos + 1, "(string empty)");
+                Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "daskr", iPos + 1, "(string empty)");
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
             if (bFuncF && bListInfo)
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "daskr", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "daskr", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
@@ -409,19 +409,19 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
                 if (bOK == false)
                 {
                     char* pst = wide_string_to_UTF8(pStr->get(0));
-                    Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "daskr", iPos + 1, pst);
+                    Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "daskr", iPos + 1, pst);
                     FREE(pst);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
 
                 int* sizeTemp = YSize;
                 int totalSize = sizeOfpdYData;
 
-                YSize = (int*)malloc((sizeOfYSize + pList->getSize() - 1) * sizeof(int));
+                YSize = (int*)MALLOC((sizeOfYSize + pList->getSize() - 1) * sizeof(int));
                 memcpy(YSize, sizeTemp, sizeOfYSize * sizeof(int));
 
                 std::vector<types::Double*> vpDbl;
@@ -429,11 +429,11 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
                 {
                     if (pList->get(iter + 1)->isDouble() == false)
                     {
-                        Scierror(999, _("%s: Wrong type for input argument #%d : Argument %d in the list must be a matrix.\n"), "daskr", iPos + 1, iter + 1);
+                        Scierror(999, _("%s: Wrong type for input argument #%d: Argument %d in the list must be a matrix.\n"), "daskr", iPos + 1, iter + 1);
                         DifferentialEquation::removeDifferentialEquationFunctions();
-                        free(pdYdotData);
-                        free(pdYData);
-                        free(YSize);
+                        FREE(pdYdotData);
+                        FREE(pdYData);
+                        FREE(YSize);
                         return types::Function::Error;
                     }
 
@@ -443,7 +443,7 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
                 }
 
                 double* pdYDataTemp = pdYData;
-                pdYData = (double*)malloc(totalSize * sizeof(double));
+                pdYData = (double*)MALLOC(totalSize * sizeof(double));
                 C2F(dcopy)(&sizeOfpdYData, pdYDataTemp, &iOne, pdYData, &iOne);
 
                 int position = sizeOfpdYData;
@@ -455,8 +455,8 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
                 vpDbl.clear();
                 sizeOfpdYData = totalSize;
                 sizeOfYSize += pList->getSize() - 1;
-                free(pdYDataTemp);
-                free(sizeTemp);
+                FREE(pdYDataTemp);
+                FREE(sizeTemp);
             }
             else if (pList->get(0)->isCallable())
             {
@@ -512,11 +512,11 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
                 // list(double,... then this list is the info argument
                 if (pList->getSize() != 14)
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : A list of size %d expected.\n"), "daskr", iPos + 1, 7);
+                    Scierror(267, _("%s: Wrong size for input argument #%d: A list of size %d expected.\n"), "daskr", iPos + 1, 7);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
 
@@ -526,16 +526,16 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
                     {
                         if (i == 1 || i == 5 || i == 7 || i == 9 || i == 13)
                         {
-                            Scierror(999, _("%s: Wrong type for input argument #%d : Element %d in the info list must be a scalar.\n"), "daskr", iPos + 1, i);
+                            Scierror(999, _("%s: Wrong type for input argument #%d: Element %d in the info list must be a scalar.\n"), "daskr", iPos + 1, i);
                         }
                         else
                         {
-                            Scierror(999, _("%s: Wrong type for input argument #%d : Element %d in the info list must be a matrix.\n"), "daskr", iPos + 1, i);
+                            Scierror(999, _("%s: Wrong type for input argument #%d: Element %d in the info list must be a matrix.\n"), "daskr", iPos + 1, i);
                         }
                         DifferentialEquation::removeDifferentialEquationFunctions();
-                        free(pdYdotData);
-                        free(pdYData);
-                        free(YSize);
+                        FREE(pdYdotData);
+                        FREE(pdYData);
+                        FREE(YSize);
                         return types::Function::Error;
                     }
                 }
@@ -563,11 +563,11 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
                 }
                 else if (pDblTemp->getSize() != 0)
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : Argument %d in te list must be of size %d.\n"), "daskr", iPos + 1, 3, 2);
+                    Scierror(267, _("%s: Wrong size for input argument #%d: Argument %d in te list must be of size %d.\n"), "daskr", iPos + 1, 3, 2);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
 
@@ -690,52 +690,52 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : The first argument in the list must be a string, a function or a matrix in case of argument info.\n"), "daskr", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: The first argument in the list must be a string, a function or a matrix in case of argument info.\n"), "daskr", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
         else
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a function expected.\n"), "daskr", iPos + 1);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a function expected.\n"), "daskr", iPos + 1);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYdotData);
-            free(pdYData);
-            free(YSize);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
             return types::Function::Error;
         }
     }
 
     if (bFuncF == false)
     {
-        Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "daskr", in.size() + 3);
+        Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "daskr", (int)in.size() + 3);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYdotData);
-        free(pdYData);
-        free(YSize);
+        FREE(pdYdotData);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
     if (pDblNg == NULL)
     {
-        Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "daskr", in.size() + 2);
+        Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "daskr", (int)in.size() + 2);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYdotData);
-        free(pdYData);
-        free(YSize);
+        FREE(pdYdotData);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
     if (bFuncG == false)
     {
-        Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "daskr", in.size() + 1);
+        Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "daskr", (int)in.size() + 1);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYdotData);
-        free(pdYData);
-        free(YSize);
+        FREE(pdYdotData);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
@@ -760,7 +760,7 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
     {
         if (pDblAtol->isScalar())
         {
-            atol  = (double*)malloc(sizeof(double));
+            atol  = (double*)MALLOC(sizeof(double));
             *atol = pDblAtol->get(0);
         }
         else
@@ -771,7 +771,7 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
     }
     else
     {
-        atol  = (double*)malloc(sizeof(double));
+        atol  = (double*)MALLOC(sizeof(double));
         *atol = 1.e-7;
     }
 
@@ -779,7 +779,7 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
     {
         if (pDblRtol->isScalar())
         {
-            rtol  = (double*)malloc(sizeof(double));
+            rtol  = (double*)MALLOC(sizeof(double));
             *rtol = pDblRtol->get(0);
         }
         else
@@ -795,12 +795,12 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
             int iSize = pDblAtol->getSize();
             int iZero = 0;
 
-            rtol = (double*)malloc(iSize * sizeof(double));
+            rtol = (double*)MALLOC(iSize * sizeof(double));
             C2F(dcopy)(&iSize, &dblSrc, &iZero, rtol, &iOne);
         }
         else
         {
-            rtol    = (double*)malloc(sizeof(double));
+            rtol    = (double*)MALLOC(sizeof(double));
             *rtol   = 1.e-9;
         }
     }
@@ -861,7 +861,7 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
         // LENIWP is the length ot the iwork segment containing
         // the matrix indexes of the preconditioner P
         // (compressed sparse row format)
-        int LENIWP = 25 * pDblX0->getRows() + 1;
+        LENIWP = 25 * pDblX0->getRows() + 1;
         iworksize += LENIWP;
     }
 
@@ -875,9 +875,9 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
         iworksize += pDblX0->getRows();
     }
 
-    iwork = (int*)malloc(iworksize * sizeof(int));
-    rwork = (double*)malloc(rworksize * sizeof(double));
-    root  = (int*)malloc(ng * sizeof(int));
+    iwork = (int*)MALLOC(iworksize * sizeof(int));
+    rwork = (double*)MALLOC(rworksize * sizeof(double));
+    root  = (int*)MALLOC(ng * sizeof(int));
 
     if (pDblHd != NULL)
     {
@@ -885,18 +885,18 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
         {
             Scierror(77, _("%s: Wrong size for input argument(s) %d: %d expected.\n"), "daskr", in.size(), iworksize + rworksize);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYdotData);
-            free(pdYData);
-            free(YSize);
-            free(iwork);
-            free(rwork);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
+            FREE(iwork);
+            FREE(rwork);
             if (pDblAtol == NULL || pDblAtol->isScalar())
             {
-                free(atol);
+                FREE(atol);
             }
             if (pDblRtol == NULL || pDblRtol->isScalar())
             {
-                free(rtol);
+                FREE(rtol);
             }
             return types::Function::Error;
         }
@@ -991,6 +991,8 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
     std::list<types::Double*> lpDblOut;
     int size = pDblX0->getRows();
     int rowsOut = 1 + pDblX0->getRows() * 2;
+    int iret = 0;
+    int ididtmp = 0;
 
     for (int i = 0; i < pDblT->getSize(); i++)
     {
@@ -1011,56 +1013,71 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
             continue;
         }
 
-        // SUBROUTINE DDASKR(RES, NEQ, T, Y, YPRIME, TOUT, INFO, RTOL, ATOL,
-        //                  IDID, RWORK, LRW, IWORK, LIW, RPAR, IPAR, JAC, PSOL,
-        //                  RT, NRT, JROOT)
-        C2F(ddaskr)(dassl_f, YSize, &t0, pdYData, pdYdotData, &t,
-                    info, rtol, atol, &idid, rwork, &rworksize,
-                    iwork, &iworksize, rpar, ipar,
-                    info[14] == 1 ? (void*)daskr_pjac : (void*)dassl_jac,
-                    daskr_psol, dasrt_g, &ng, root);
-
-        // values of idid says the same things that in ddasrt function,
-        // except these two values.
-        int ididtmp = idid;
-        // The integration to TSTOP was successfully completed (T=TSTOP)
-        if (idid == 4)
+        try
         {
-            idid = 2;
-        }
+            // SUBROUTINE DDASKR(RES, NEQ, T, Y, YPRIME, TOUT, INFO, RTOL, ATOL,
+            //                  IDID, RWORK, LRW, IWORK, LIW, RPAR, IPAR, JAC, PSOL,
+            //                  RT, NRT, JROOT)
+            C2F(ddaskr)(dassl_f, YSize, &t0, pdYData, pdYdotData, &t,
+                        info, rtol, atol, &idid, rwork, &rworksize,
+                        iwork, &iworksize, rpar, ipar,
+                        info[14] == 1 ? (void*)daskr_pjac : (void*)dassl_jac,
+                        daskr_psol, dasrt_g, &ng, root);
+
+            // values of idid says the same things that in ddasrt function,
+            // except these two values.
+            ididtmp = idid;
+            // The integration to TSTOP was successfully completed (T=TSTOP)
+            if (idid == 4)
+            {
+                idid = 2;
+            }
 
-        // One or more root found (eq to idid = 4 for dassl)
-        if (idid == 5)
-        {
-            idid = 4;
-        }
+            // One or more root found (eq to idid = 4 for dassl)
+            if (idid == 5)
+            {
+                idid = 4;
+            }
 
-        if (idid == 6)
+            if (idid == 6)
+            {
+                idid = 3;
+            }
+
+            // use the same error function that dasrt
+            iret = checkDasslError(idid);
+            if (iret == 1) // error
+            {
+                Scierror(999, _("%s: ddaskr return with state %d.\n"), "daskr", ididtmp);
+            }
+        }
+        catch (ScilabError &e)
         {
-            idid = 3;
+            char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+            sciprint(_("%s: exception caught in '%s' subroutine.\n"), "daskr", "ddaskr");
+            Scierror(999, pstrMsg);
+            // set iret to 1 for free allocated memory
+            iret = 1;
         }
 
-        // use the same error function that dasrt
-        int iret = checkDasslError(idid);
-
-        if (iret == 1) // error
+        // free memory when error occurred
+        if (iret == 1)
         {
-            Scierror(999, _("%s: ddaskr return with state %d.\n"), "daskr", ididtmp);
             lpDblOut.clear();
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYdotData);
-            free(pdYData);
-            free(YSize);
-            free(iwork);
-            free(rwork);
-            free(root);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
+            FREE(iwork);
+            FREE(rwork);
+            FREE(root);
             if (pDblAtol == NULL || pDblAtol->isScalar())
             {
-                free(atol);
+                FREE(atol);
             }
             if (pDblRtol == NULL || pDblRtol->isScalar())
             {
-                free(rtol);
+                FREE(rtol);
             }
             return types::Function::Error;
         }
@@ -1072,7 +1089,7 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
 
         if (iret == 2) // warning
         {
-            if(ididtmp == -1 || ididtmp == 5 || ididtmp == 6)
+            if (ididtmp == -1 || ididtmp == 5 || ididtmp == 6)
             {
                 pDblOut->set(0, t0);
             }
@@ -1144,23 +1161,23 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
         out.push_back(pDblHdOut);
     }
 
-    // *** free memory. ***
+    // *** FREE memory. ***
     if (pDblAtol == NULL || pDblAtol->isScalar())
     {
-        free(atol);
+        FREE(atol);
     }
 
     if (pDblRtol == NULL || pDblRtol->isScalar())
     {
-        free(rtol);
+        FREE(rtol);
     }
 
-    free(pdYData);
-    free(pdYdotData);
-    free(YSize);
-    free(rwork);
-    free(iwork);
-    free(root);
+    FREE(pdYData);
+    FREE(pdYdotData);
+    FREE(YSize);
+    FREE(rwork);
+    FREE(iwork);
+    FREE(root);
 
     DifferentialEquation::removeDifferentialEquationFunctions();
 
index 0769fb0..3c07c1c 100644 (file)
@@ -88,7 +88,7 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
     // x0 = [y0, yd0]
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "dasrt", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "dasrt", iPos + 1);
         return types::Function::Error;
     }
 
@@ -96,13 +96,13 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
 
     if (pDblX0->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "dasrt", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "dasrt", iPos + 1);
         return types::Function::Error;
     }
 
     if (pDblX0->getCols() > 2)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A real matrix with %d to %d colomn(s) expected.\n"), "dasrt", iPos + 1, 1, 2);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A real matrix with %d to %d colomn(s) expected.\n"), "dasrt", iPos + 1, 1, 2);
         return types::Function::Error;
     }
 
@@ -115,7 +115,7 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "dasrt", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "dasrt", iPos + 1);
         return types::Function::Error;
     }
 
@@ -123,7 +123,7 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
 
     if (pDblT0->isScalar() == false)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "dasrt", iPos + 1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), "dasrt", iPos + 1);
         return types::Function::Error;
     }
 
@@ -131,7 +131,7 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "dasrt", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "dasrt", iPos + 1);
         return types::Function::Error;
     }
 
@@ -139,7 +139,7 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
 
     if (pDblT->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "dasrt", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "dasrt", iPos + 1);
         return types::Function::Error;
     }
 
@@ -147,11 +147,11 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
     DifferentialEquationFunctions* deFunctionsManager = new DifferentialEquationFunctions(L"dasrt");
     DifferentialEquation::addDifferentialEquationFunctions(deFunctionsManager);
 
-    YSize = (int*)malloc(sizeOfYSize * sizeof(int));
+    YSize = (int*)MALLOC(sizeOfYSize * sizeof(int));
     *YSize = pDblX0->getRows();
 
-    pdYData = (double*)malloc(*YSize * sizeof(double));
-    pdYdotData = (double*)malloc(*YSize * sizeof(double));
+    pdYData = (double*)MALLOC(*YSize * sizeof(double));
+    pdYdotData = (double*)MALLOC(*YSize * sizeof(double));
 
     C2F(dcopy)(YSize, pDblX0->get(), &one, pdYData, &one);
     if (pDblX0->getCols() == 2)
@@ -174,11 +174,11 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
                 pDblAtol = in[iPos]->getAs<types::Double>();
                 if (pDblAtol->getSize() != pDblX0->getRows() && pDblAtol->isScalar() == false)
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : A scalar or a matrix of size %d expected.\n"), "dasrt", iPos + 1, pDblX0->getRows());
+                    Scierror(267, _("%s: Wrong size for input argument #%d: A scalar or a matrix of size %d expected.\n"), "dasrt", iPos + 1, pDblX0->getRows());
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
@@ -187,11 +187,11 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
                 pDblRtol = in[iPos]->getAs<types::Double>();
                 if (pDblAtol->getSize() != pDblRtol->getSize())
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : Atol and Rtol must have the same size.\n"), "dasrt", iPos + 1, pDblX0->getRows());
+                    Scierror(267, _("%s: Wrong size for input argument #%d: Atol and Rtol must have the same size.\n"), "dasrt", iPos + 1, pDblX0->getRows());
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
@@ -200,11 +200,11 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
                 pDblNg = in[iPos]->getAs<types::Double>();
                 if (pDblNg->isScalar() == false)
                 {
-                    Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "dasrt", iPos + 1);
+                    Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), "dasrt", iPos + 1);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
                 ng = (int)pDblNg->get(0);
@@ -216,19 +216,19 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
                 {
                     Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "dasrt", iPos + 1);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A function expected.\n"), "dasrt", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A function expected.\n"), "dasrt", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -252,11 +252,11 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a list expected.\n"), "dasrt", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a list expected.\n"), "dasrt", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -282,11 +282,11 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a list expected.\n"), "dasrt", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a list expected.\n"), "dasrt", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
@@ -296,9 +296,9 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
                 Scierror(50, _("%s: Subroutine not found: %s\n"), "dasrt", pst);
                 FREE(pst);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -308,21 +308,21 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
 
             if (pList->getSize() == 0)
             {
-                Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "dasrt", iPos + 1, "(string empty)");
+                Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "dasrt", iPos + 1, "(string empty)");
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
             if (bFuncF && bListInfo)
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "dasrt", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "dasrt", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
@@ -359,19 +359,19 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
                 if (bOK == false)
                 {
                     char* pst = wide_string_to_UTF8(pStr->get(0));
-                    Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "dasrt", iPos + 1, pst);
+                    Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "dasrt", iPos + 1, pst);
                     FREE(pst);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
 
                 int* sizeTemp = YSize;
                 int totalSize = sizeOfpdYData;
 
-                YSize = (int*)malloc((sizeOfYSize + pList->getSize() - 1) * sizeof(int));
+                YSize = (int*)MALLOC((sizeOfYSize + pList->getSize() - 1) * sizeof(int));
                 memcpy(YSize, sizeTemp, sizeOfYSize * sizeof(int));
 
                 std::vector<types::Double*> vpDbl;
@@ -379,11 +379,11 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
                 {
                     if (pList->get(iter + 1)->isDouble() == false)
                     {
-                        Scierror(999, _("%s: Wrong type for input argument #%d : Argument %d in the list must be a matrix.\n"), "dasrt", iPos + 1, iter + 1);
+                        Scierror(999, _("%s: Wrong type for input argument #%d: Argument %d in the list must be a matrix.\n"), "dasrt", iPos + 1, iter + 1);
                         DifferentialEquation::removeDifferentialEquationFunctions();
-                        free(pdYdotData);
-                        free(pdYData);
-                        free(YSize);
+                        FREE(pdYdotData);
+                        FREE(pdYData);
+                        FREE(YSize);
                         return types::Function::Error;
                     }
 
@@ -393,7 +393,7 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
                 }
 
                 double* pdYDataTemp = pdYData;
-                pdYData = (double*)malloc(totalSize * sizeof(double));
+                pdYData = (double*)MALLOC(totalSize * sizeof(double));
                 C2F(dcopy)(&sizeOfpdYData, pdYDataTemp, &one, pdYData, &one);
 
                 int position = sizeOfpdYData;
@@ -405,8 +405,8 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
                 vpDbl.clear();
                 sizeOfpdYData = totalSize;
                 sizeOfYSize += pList->getSize() - 1;
-                free(pdYDataTemp);
-                free(sizeTemp);
+                FREE(pdYDataTemp);
+                FREE(sizeTemp);
             }
             else if (pList->get(0)->isCallable())
             {
@@ -442,11 +442,11 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
             {
                 if (pList->getSize() != 7)
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : A list of size %d expected.\n"), "dasrt", iPos + 1, 7);
+                    Scierror(267, _("%s: Wrong size for input argument #%d: A list of size %d expected.\n"), "dasrt", iPos + 1, 7);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
 
@@ -456,16 +456,16 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
                     {
                         if (i == 1 || i == 5 || i == 6)
                         {
-                            Scierror(999, _("%s: Wrong type for input argument #%d : Element %d in the info list must be a scalar.\n"), "dasrt", iPos + 1, i);
+                            Scierror(999, _("%s: Wrong type for input argument #%d: Element %d in the info list must be a scalar.\n"), "dasrt", iPos + 1, i);
                         }
                         else
                         {
-                            Scierror(999, _("%s: Wrong type for input argument #%d : Element %d in the info list must be a matrix.\n"), "dasrt", iPos + 1, i);
+                            Scierror(999, _("%s: Wrong type for input argument #%d: Element %d in the info list must be a matrix.\n"), "dasrt", iPos + 1, i);
                         }
                         DifferentialEquation::removeDifferentialEquationFunctions();
-                        free(pdYdotData);
-                        free(pdYData);
-                        free(YSize);
+                        FREE(pdYdotData);
+                        FREE(pdYData);
+                        FREE(YSize);
                         return types::Function::Error;
                     }
                 }
@@ -490,11 +490,11 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
                 }
                 else if (pDblTemp->getSize() != 0)
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : Argument %d in te list must be of size %d.\n"), "dasrt", iPos + 1, 3, 2);
+                    Scierror(267, _("%s: Wrong size for input argument #%d: Argument %d in te list must be of size %d.\n"), "dasrt", iPos + 1, 3, 2);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
 
@@ -522,21 +522,21 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : The first argument in the list must be a string, a function or a matrix in case of argument info.\n"), "dasrt", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: The first argument in the list must be a string, a function or a matrix in case of argument info.\n"), "dasrt", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
         else
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a function expected.\n"), "dasrt", iPos + 1);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a function expected.\n"), "dasrt", iPos + 1);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYdotData);
-            free(pdYData);
-            free(YSize);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
             return types::Function::Error;
         }
     }
@@ -545,9 +545,9 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
     {
         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "dasrt", in.size() + 3);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYdotData);
-        free(pdYData);
-        free(YSize);
+        FREE(pdYdotData);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
@@ -555,9 +555,9 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
     {
         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "dasrt", in.size() + 2);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYdotData);
-        free(pdYData);
-        free(YSize);
+        FREE(pdYdotData);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
@@ -565,9 +565,9 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
     {
         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "dasrt", in.size() + 1);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYdotData);
-        free(pdYData);
-        free(YSize);
+        FREE(pdYdotData);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
@@ -591,7 +591,7 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
     {
         if (pDblAtol->isScalar())
         {
-            atol  = (double*)malloc(sizeof(double));
+            atol  = (double*)MALLOC(sizeof(double));
             *atol = pDblAtol->get(0);
         }
         else
@@ -602,7 +602,7 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
     }
     else
     {
-        atol  = (double*)malloc(sizeof(double));
+        atol  = (double*)MALLOC(sizeof(double));
         *atol = 1.e-7;
     }
 
@@ -610,7 +610,7 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
     {
         if (pDblRtol->isScalar())
         {
-            rtol  = (double*)malloc(sizeof(double));
+            rtol  = (double*)MALLOC(sizeof(double));
             *rtol = pDblRtol->get(0);
         }
         else
@@ -627,12 +627,12 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
             int iOne = 1;
             int iZero = 0;
 
-            rtol = (double*)malloc(iSize * sizeof(double));
+            rtol = (double*)MALLOC(iSize * sizeof(double));
             C2F(dcopy)(&iSize, &dblSrc, &iZero, rtol, &iOne);
         }
         else
         {
-            rtol    = (double*)malloc(sizeof(double));
+            rtol    = (double*)MALLOC(sizeof(double));
             *rtol   = 1.e-9;
         }
     }
@@ -658,9 +658,9 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
         rworksize = 50 + (maxord + 4) * pDblX0->getRows() + (2 * ml + mu + 1) * pDblX0->getRows() + 2 * (pDblX0->getRows() / (ml + mu + 1) + 1) + 3 * ng;
     }
 
-    iwork = (int*)malloc(iworksize * sizeof(int));
-    rwork = (double*)malloc(rworksize * sizeof(double));
-    root  = (int*)malloc(ng * sizeof(int));
+    iwork = (int*)MALLOC(iworksize * sizeof(int));
+    rwork = (double*)MALLOC(rworksize * sizeof(double));
+    root  = (int*)MALLOC(ng * sizeof(int));
 
     if (pDblHd != NULL)
     {
@@ -668,18 +668,18 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
         {
             Scierror(77, _("%s: Wrong size for input argument(s) %d: %d expected.\n"), "dasrt", in.size(), iworksize + rworksize);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYdotData);
-            free(pdYData);
-            free(YSize);
-            free(iwork);
-            free(rwork);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
+            FREE(iwork);
+            FREE(rwork);
             if (pDblAtol == NULL || pDblAtol->isScalar())
             {
-                free(atol);
+                FREE(atol);
             }
             if (pDblRtol == NULL || pDblRtol->isScalar())
             {
-                free(rtol);
+                FREE(rtol);
             }
             return types::Function::Error;
         }
@@ -719,6 +719,7 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
     std::list<types::Double*> lpDblOut;
     int size = pDblX0->getRows();
     int rowsOut = 1 + pDblX0->getRows() * 2;
+    int iret = 0;
 
     for (int i = 0; i < pDblT->getSize(); i++)
     {
@@ -739,28 +740,41 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
             continue;
         }
 
-        C2F(ddasrt)(dassl_f, YSize, &t0, pdYData, pdYdotData, &t, info, rtol, atol, &idid, rwork, &rworksize, iwork, &iworksize, &rpar, &ipar, dassl_jac, dasrt_g, &ng, root);
-
-        int iret = checkDasslError(idid);
+        try
+        {
+            C2F(ddasrt)(dassl_f, YSize, &t0, pdYData, pdYdotData, &t, info, rtol, atol, &idid, rwork, &rworksize, iwork, &iworksize, &rpar, &ipar, dassl_jac, dasrt_g, &ng, root);
+            iret = checkDasslError(idid);
+            if (iret == 1) // error
+            {
+                Scierror(999, _("%s: ddasrt return with state %d.\n"), "dasrt", idid);
+            }
+        }
+        catch (ScilabError &e)
+        {
+            char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+            sciprint(_("%s: exception caught in '%s' subroutine.\n"), "dasrt", "ddasrt");
+            Scierror(999, pstrMsg);
+            FREE(pstrMsg);
+            iret = 1;
+        }
 
-        if (iret == 1) // error
+        if (iret == 1)
         {
-            Scierror(999, _("%s: ddasrt return with state %d.\n"), "dasrt", idid);
             lpDblOut.clear();
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYdotData);
-            free(pdYData);
-            free(YSize);
-            free(iwork);
-            free(rwork);
-            free(root);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
+            FREE(iwork);
+            FREE(rwork);
+            FREE(root);
             if (pDblAtol == NULL || pDblAtol->isScalar())
             {
-                free(atol);
+                FREE(atol);
             }
             if (pDblRtol == NULL || pDblRtol->isScalar())
             {
-                free(rtol);
+                FREE(rtol);
             }
             return types::Function::Error;
         }
@@ -842,23 +856,23 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
         out.push_back(pDblHdOut);
     }
 
-    // *** free. ***
+    // *** FREE. ***
     if (pDblAtol == NULL || pDblAtol->isScalar())
     {
-        free(atol);
+        FREE(atol);
     }
 
     if (pDblRtol == NULL || pDblRtol->isScalar())
     {
-        free(rtol);
+        FREE(rtol);
     }
 
-    free(pdYData);
-    free(pdYdotData);
-    free(YSize);
-    free(rwork);
-    free(iwork);
-    free(root);
+    FREE(pdYData);
+    FREE(pdYdotData);
+    FREE(YSize);
+    FREE(rwork);
+    FREE(iwork);
+    FREE(root);
 
     DifferentialEquation::removeDifferentialEquationFunctions();
 
index 0caf36c..16762ce 100644 (file)
@@ -87,7 +87,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     // x0 = [y0, yd0]
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "dassl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -95,13 +95,13 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
 
     if (pDblX0->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "dassl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
     if (pDblX0->getCols() > 2)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A real matrix with %d to %d colomn(s) expected.\n"), "dassl", iPos + 1, 1, 2);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A real matrix with %d to %d colomn(s) expected.\n"), "dassl", iPos + 1, 1, 2);
         return types::Function::Error;
     }
 
@@ -114,7 +114,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "dassl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -122,7 +122,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
 
     if (pDblT0->isScalar() == false)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "dassl", iPos + 1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -130,7 +130,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "dassl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -138,7 +138,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
 
     if (pDblT->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "dassl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -146,11 +146,11 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     DifferentialEquationFunctions* deFunctionsManager = new DifferentialEquationFunctions(L"dassl");
     DifferentialEquation::addDifferentialEquationFunctions(deFunctionsManager);
 
-    YSize = (int*)malloc(sizeOfYSize * sizeof(int));
+    YSize = (int*)MALLOC(sizeOfYSize * sizeof(int));
     *YSize = pDblX0->getRows();
 
-    pdYData = (double*)malloc(*YSize * sizeof(double));
-    pdYdotData = (double*)malloc(*YSize * sizeof(double));
+    pdYData = (double*)MALLOC(*YSize * sizeof(double));
+    pdYdotData = (double*)MALLOC(*YSize * sizeof(double));
 
     C2F(dcopy)(YSize, pDblX0->get(), &one, pdYData, &one);
     if (pDblX0->getCols() == 2)
@@ -173,11 +173,11 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 pDblAtol = in[iPos]->getAs<types::Double>();
                 if (pDblAtol->getSize() != pDblX0->getRows() && pDblAtol->isScalar() == false)
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : A scalar or a matrix of size %d expected.\n"), "dassl", iPos + 1, pDblX0->getRows());
+                    Scierror(267, _("%s: Wrong size for input argument #%d: A scalar or a matrix of size %d expected.\n"), "dassl", iPos + 1, pDblX0->getRows());
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
@@ -186,11 +186,11 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 pDblRtol = in[iPos]->getAs<types::Double>();
                 if (pDblAtol->getSize() != pDblRtol->getSize())
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : Atol and Rtol must have the same size.\n"), "dassl", iPos + 1, pDblX0->getRows());
+                    Scierror(267, _("%s: Wrong size for input argument #%d: Atol and Rtol must have the same size.\n"), "dassl", iPos + 1, pDblX0->getRows());
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
@@ -201,19 +201,19 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 {
                     Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "dassl", iPos + 1);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A function expected.\n"), "dassl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A function expected.\n"), "dassl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -232,11 +232,11 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a list expected.\n"), "dassl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a list expected.\n"), "dassl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -257,11 +257,11 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a list expected.\n"), "dassl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a list expected.\n"), "dassl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
@@ -271,9 +271,9 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 Scierror(50, _("%s: Subroutine not found: %s\n"), "dassl", pst);
                 FREE(pst);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -283,21 +283,21 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
 
             if (pList->getSize() == 0)
             {
-                Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "dassl", iPos + 1, "(string empty)");
+                Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "dassl", iPos + 1, "(string empty)");
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
             if (bFuncF && bListInfo)
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "dassl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "dassl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
@@ -325,19 +325,19 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 if (bOK == false)
                 {
                     char* pst = wide_string_to_UTF8(pStr->get(0));
-                    Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "dassl", iPos + 1, pst);
+                    Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "dassl", iPos + 1, pst);
                     FREE(pst);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
 
                 int* sizeTemp = YSize;
                 int totalSize = sizeOfpdYData;
 
-                YSize = (int*)malloc((sizeOfYSize + pList->getSize() - 1) * sizeof(int));
+                YSize = (int*)MALLOC((sizeOfYSize + pList->getSize() - 1) * sizeof(int));
                 memcpy(YSize, sizeTemp, sizeOfYSize * sizeof(int));
 
                 std::vector<types::Double*> vpDbl;
@@ -345,11 +345,11 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 {
                     if (pList->get(iter + 1)->isDouble() == false)
                     {
-                        Scierror(999, _("%s: Wrong type for input argument #%d : Argument %d in the list must be a matrix.\n"), "dassl", iPos + 1, iter + 1);
+                        Scierror(999, _("%s: Wrong type for input argument #%d: Argument %d in the list must be a matrix.\n"), "dassl", iPos + 1, iter + 1);
                         DifferentialEquation::removeDifferentialEquationFunctions();
-                        free(pdYdotData);
-                        free(pdYData);
-                        free(YSize);
+                        FREE(pdYdotData);
+                        FREE(pdYData);
+                        FREE(YSize);
                         return types::Function::Error;
                     }
 
@@ -359,7 +359,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 }
 
                 double* pdYDataTemp = pdYData;
-                pdYData = (double*)malloc(totalSize * sizeof(double));
+                pdYData = (double*)MALLOC(totalSize * sizeof(double));
                 C2F(dcopy)(&sizeOfpdYData, pdYDataTemp, &one, pdYData, &one);
 
                 int position = sizeOfpdYData;
@@ -371,8 +371,8 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 vpDbl.clear();
                 sizeOfpdYData = totalSize;
                 sizeOfYSize += pList->getSize() - 1;
-                free(pdYDataTemp);
-                free(sizeTemp);
+                FREE(pdYDataTemp);
+                FREE(sizeTemp);
             }
             else if (pList->get(0)->isCallable())
             {
@@ -399,11 +399,11 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
             {
                 if (pList->getSize() != 7)
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : A list of size %d expected.\n"), "dassl", iPos + 1, 7);
+                    Scierror(267, _("%s: Wrong size for input argument #%d: A list of size %d expected.\n"), "dassl", iPos + 1, 7);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
 
@@ -413,16 +413,16 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                     {
                         if (i == 1 || i == 5 || i == 6)
                         {
-                            Scierror(999, _("%s: Wrong type for input argument #%d : Element %d in the info list must be a scalar.\n"), "dassl", iPos + 1, i);
+                            Scierror(999, _("%s: Wrong type for input argument #%d: Element %d in the info list must be a scalar.\n"), "dassl", iPos + 1, i);
                         }
                         else
                         {
-                            Scierror(999, _("%s: Wrong type for input argument #%d : Element %d in the info list must be a matrix.\n"), "dassl", iPos + 1, i);
+                            Scierror(999, _("%s: Wrong type for input argument #%d: Element %d in the info list must be a matrix.\n"), "dassl", iPos + 1, i);
                         }
                         DifferentialEquation::removeDifferentialEquationFunctions();
-                        free(pdYdotData);
-                        free(pdYData);
-                        free(YSize);
+                        FREE(pdYdotData);
+                        FREE(pdYData);
+                        FREE(YSize);
                         return types::Function::Error;
                     }
                 }
@@ -447,11 +447,11 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 }
                 else if (pDblTemp->getSize() != 0)
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : Argument %d in te list must be of size %d.\n"), "dassl", iPos + 1, 3, 2);
+                    Scierror(267, _("%s: Wrong size for input argument #%d: Argument %d in te list must be of size %d.\n"), "dassl", iPos + 1, 3, 2);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
 
@@ -479,21 +479,21 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : The first argument in the list must be a string, a function or a matrix in case of argument info.\n"), "dassl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: The first argument in the list must be a string, a function or a matrix in case of argument info.\n"), "dassl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
         else
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a function expected.\n"), "dassl", iPos + 1);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a function expected.\n"), "dassl", iPos + 1);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYdotData);
-            free(pdYData);
-            free(YSize);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
             return types::Function::Error;
         }
     }
@@ -502,9 +502,9 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     {
         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "dassl", in.size() + 1);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYdotData);
-        free(pdYData);
-        free(YSize);
+        FREE(pdYdotData);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
@@ -528,7 +528,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     {
         if (pDblAtol->isScalar())
         {
-            atol  = (double*)malloc(sizeof(double));
+            atol  = (double*)MALLOC(sizeof(double));
             *atol = pDblAtol->get(0);
         }
         else
@@ -539,7 +539,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     }
     else
     {
-        atol  = (double*)malloc(sizeof(double));
+        atol  = (double*)MALLOC(sizeof(double));
         *atol = 1.e-7;
     }
 
@@ -547,7 +547,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     {
         if (pDblRtol->isScalar())
         {
-            rtol  = (double*)malloc(sizeof(double));
+            rtol  = (double*)MALLOC(sizeof(double));
             *rtol = pDblRtol->get(0);
         }
         else
@@ -564,12 +564,12 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
             int iOne = 1;
             int iZero = 0;
 
-            rtol = (double*)malloc(iSize * sizeof(double));
+            rtol = (double*)MALLOC(iSize * sizeof(double));
             C2F(dcopy)(&iSize, &dblSrc, &iZero, rtol, &iOne);
         }
         else
         {
-            rtol    = (double*)malloc(sizeof(double));
+            rtol    = (double*)MALLOC(sizeof(double));
             *rtol   = 1.e-9;
         }
     }
@@ -594,8 +594,8 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
         rworksize = 40 + (maxord + 4) * pDblX0->getRows() + (2 * ml + mu + 1) * pDblX0->getRows() + 2 * (pDblX0->getRows() / (ml + mu + 1) + 1);
     }
 
-    iwork = (int*)malloc(iworksize * sizeof(int));
-    rwork = (double*)malloc(rworksize * sizeof(double));
+    iwork = (int*)MALLOC(iworksize * sizeof(int));
+    rwork = (double*)MALLOC(rworksize * sizeof(double));
 
     if (pDblHd != NULL)
     {
@@ -603,18 +603,18 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
         {
             Scierror(77, _("%s: Wrong size for input argument(s) %d: %d expected.\n"), "dassl", in.size(), iworksize + rworksize);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYdotData);
-            free(pdYData);
-            free(YSize);
-            free(iwork);
-            free(rwork);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
+            FREE(iwork);
+            FREE(rwork);
             if (pDblAtol == NULL || pDblAtol->isScalar())
             {
-                free(atol);
+                FREE(atol);
             }
             if (pDblRtol == NULL || pDblRtol->isScalar())
             {
-                free(rtol);
+                FREE(rtol);
             }
             return types::Function::Error;
         }
@@ -654,6 +654,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     std::list<types::Double*> lpDblOut;
     int size = pDblX0->getRows();
     int rowsOut = 1 + pDblX0->getRows() * 2;
+    int iret = 0;
 
     for (int i = 0; i < pDblT->getSize(); i++)
     {
@@ -674,27 +675,41 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
             continue;
         }
 
-        C2F(dassl)(dassl_f, YSize, &t0, pdYData, pdYdotData, &t, info, rtol, atol, &idid, rwork, &rworksize, iwork, &iworksize, &rpar, &ipar, dassl_jac);
+        try
+        {
+            C2F(dassl)(dassl_f, YSize, &t0, pdYData, pdYdotData, &t, info, rtol, atol, &idid, rwork, &rworksize, iwork, &iworksize, &rpar, &ipar, dassl_jac);
 
-        int iret = checkDasslError(idid);
+            iret = checkDasslError(idid);
+            if (iret == 1) // error
+            {
+                Scierror(999, _("%s: dassl return with state %d.\n"), "dassl", idid);
+            }
+        }
+        catch (ScilabError &e)
+        {
+            char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+            sciprint(_("%s: exception caught in '%s' subroutine.\n"), "dassl", "dassl");
+            Scierror(999, pstrMsg);
+            // set iret to 1 for FREE allocated memory
+            iret = 1;
+        }
 
         if (iret == 1) // error
         {
-            Scierror(999, _("%s: dassl return with state %d.\n"), "dassl", idid);
             lpDblOut.clear();
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYdotData);
-            free(pdYData);
-            free(YSize);
-            free(iwork);
-            free(rwork);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
+            FREE(iwork);
+            FREE(rwork);
             if (pDblAtol == NULL || pDblAtol->isScalar())
             {
-                free(atol);
+                FREE(atol);
             }
             if (pDblRtol == NULL || pDblRtol->isScalar())
             {
-                free(rtol);
+                FREE(rtol);
             }
             return types::Function::Error;
         }
@@ -753,22 +768,22 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
         out.push_back(pDblHdOut);
     }
 
-    // *** free. ***
+    // *** FREE. ***
     if (pDblAtol == NULL || pDblAtol->isScalar())
     {
-        free(atol);
+        FREE(atol);
     }
 
     if (pDblRtol == NULL || pDblRtol->isScalar())
     {
-        free(rtol);
+        FREE(rtol);
     }
 
-    free(pdYData);
-    free(pdYdotData);
-    free(YSize);
-    free(rwork);
-    free(iwork);
+    FREE(pdYData);
+    FREE(pdYdotData);
+    FREE(YSize);
+    FREE(rwork);
+    FREE(iwork);
 
     DifferentialEquation::removeDifferentialEquationFunctions();
 
index 4c2e3ee..6aa52ea 100644 (file)
@@ -24,6 +24,7 @@ extern "C"
 #include "MALLOC.h"
 #include "localization.h"
 #include "Scierror.h"
+#include "sciprint.h"
 #include "scifunctions.h"
 #include "feval.h"
 }
@@ -96,20 +97,6 @@ types::Function::ReturnValue sci_feval(types::typed_list &in, int _iRetCount, ty
     {
         types::Callable* pCall = in[iPos]->getAs<types::Callable>();
         deFunctionsManager->setFFunction(pCall);
-
-        // check function
-        int iflag   = 0;
-        double x    = 1;
-        double y    = 1;
-        double res[2];
-
-        int ret  = deFunctionsManager->execFevalF(&nn, &x, &y, res, &iflag);
-        if (ret)
-        {
-            Scierror(50, _("%s: Argument #%d : Variable returned by scilab argument function is incorrect.\n"), "int3d", 4);
-            DifferentialEquation::removeDifferentialEquationFunctions();
-            return types::Function::Error;
-        }
     }
     else if (in[iPos]->isString())
     {
@@ -161,7 +148,7 @@ types::Function::ReturnValue sci_feval(types::typed_list &in, int _iRetCount, ty
 
     // *** Perform operation. ***
     int itype       = 0; // output value
-    double* res     = (double*)malloc(2 * sizeof(double));
+    double* res     = (double*)MALLOC(2 * sizeof(double));
     int sizeOfY     = pDblY ? pDblY->getSize() : 1;
 
     if (nn == 2)
@@ -181,12 +168,17 @@ types::Function::ReturnValue sci_feval(types::typed_list &in, int _iRetCount, ty
             // if pDblY == NULL, nn == 1 so valY will be never used.
             double valY = pDblY ? pDblY->get(y) : 0;
 
-            int iret = deFunctionsManager->execFevalF(&nn, &valX, &valY, res, &itype);
-
-            if (iret)
+            try
+            {
+                deFunctionsManager->execFevalF(&nn, &valX, &valY, res, &itype);
+            }
+            catch (ScilabError &e)
             {
-                Scierror(999, _("%s: Error during the function execution.\n"), "feval");
+                char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+                sciprint(_("%s: exception caught in '%s' subroutine.\n"), "feval", "execFevalF");
+                Scierror(999, pstrMsg);
                 DifferentialEquation::removeDifferentialEquationFunctions();
+                FREE(res);
                 delete pDblOut;
                 return types::Function::Error;
             }
@@ -208,7 +200,7 @@ types::Function::ReturnValue sci_feval(types::typed_list &in, int _iRetCount, ty
 
     out.push_back(pDblOut);
 
-    free(res);
+    FREE(res);
     DifferentialEquation::removeDifferentialEquationFunctions();
 
     return types::Function::OK;
index 90d160e..38b2897 100644 (file)
@@ -110,7 +110,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
         }
         else
         {
-            Scierror(999, _("%s: Wrong value for input argument #%d : It must be one of the following strings : adams or stiff.\n"), "impl", 1);
+            Scierror(999, _("%s: Wrong value for input argument #%d: It must be one of the following strings: adams or stiff.\n"), "impl", 1);
             return types::Function::Error;
         }
     }
@@ -119,7 +119,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
     // y0
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "impl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "impl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -127,13 +127,13 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
 
     if (pDblY0->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "impl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "impl", iPos + 1);
         return types::Function::Error;
     }
 
     if (pDblY0->getCols() != 1 && pDblY0->getRows() != 1)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real vector expected.\n"), "impl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real vector expected.\n"), "impl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -141,7 +141,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "impl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "impl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -149,13 +149,13 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
 
     if (pDblYdot0->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "impl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "impl", iPos + 1);
         return types::Function::Error;
     }
 
     if (pDblYdot0->getCols() != 1 && pDblYdot0->getRows() != 1)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real vector expected.\n"), "impl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real vector expected.\n"), "impl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -163,7 +163,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "impl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "impl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -171,7 +171,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
 
     if (pDblT0->isScalar() == false)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "impl", iPos + 1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), "impl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -179,7 +179,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "impl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "impl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -228,7 +228,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
                 {
                     if (in[iPos + 1]->isDouble() == false)
                     {
-                        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "impl", iPos + 2);
+                        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "impl", iPos + 2);
                         DifferentialEquation::removeDifferentialEquationFunctions();
                         free(pdYData);
                         free(YSize);
@@ -250,7 +250,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A function expected.\n"), "impl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A function expected.\n"), "impl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
                 free(pdYData);
                 free(YSize);
@@ -277,7 +277,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "impl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "impl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
                 free(pdYData);
                 free(YSize);
@@ -306,7 +306,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "impl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "impl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
                 free(pdYData);
                 free(YSize);
@@ -330,7 +330,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
 
             if (pList->getSize() == 0)
             {
-                Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "impl", iPos + 1, "(string empty)");
+                Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "impl", iPos + 1, "(string empty)");
                 DifferentialEquation::removeDifferentialEquationFunctions();
                 free(pdYData);
                 free(YSize);
@@ -339,7 +339,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
 
             if (bFuncF && bFuncG && bFuncJac)
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "impl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "impl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
                 free(pdYData);
                 free(YSize);
@@ -379,7 +379,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
                 if (bOK == false)
                 {
                     char* pst = wide_string_to_UTF8(pStr->get(0));
-                    Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "impl", iPos + 1, pst);
+                    Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "impl", iPos + 1, pst);
                     FREE(pst);
                     DifferentialEquation::removeDifferentialEquationFunctions();
                     free(pdYData);
@@ -398,7 +398,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
                 {
                     if (pList->get(iter + 1)->isDouble() == false)
                     {
-                        Scierror(999, _("%s: Wrong type for input argument #%d : Argument %d in the list must be a matrix.\n"), "impl", iPos + 1, iter + 1);
+                        Scierror(999, _("%s: Wrong type for input argument #%d: Argument %d in the list must be a matrix.\n"), "impl", iPos + 1, iter + 1);
                         DifferentialEquation::removeDifferentialEquationFunctions();
                         free(pdYData);
                         free(YSize);
@@ -458,7 +458,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : The first argument in the list must be a string or a function.\n"), "impl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: The first argument in the list must be a string or a function.\n"), "impl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
                 free(pdYData);
                 free(YSize);
@@ -467,7 +467,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
         }
         else
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a function expected.\n"), "impl", iPos + 1);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a function expected.\n"), "impl", iPos + 1);
             DifferentialEquation::removeDifferentialEquationFunctions();
             free(pdYData);
             free(YSize);
@@ -588,7 +588,7 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
     {
         if (pDblW->getSize() != rwSize || pDblIw->getSize() != iwSize)
         {
-            Scierror(9999, _("%s: Wrong size for w and iw : w = %d and iw = %d expected.\n"), "impl", rwSize, iwSize);
+            Scierror(9999, _("%s: Wrong size for w and iw: w = %d and iw = %d expected.\n"), "impl", rwSize, iwSize);
             DifferentialEquation::removeDifferentialEquationFunctions();
             free(pdYData);
             free(YSize);
@@ -629,27 +629,38 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
     }
 
     // *** Perform operation. ***
+    int err = 0;
     for (int i = 0; i < pDblT->getSize(); i++)
     {
         double t = pDblT->get(i);
-
-        C2F(lsodi)(impl_f, impl_g, impl_jac, YSize, pdYData, pDblYdot0->get(), &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, &jacType);
-
-        // check error
-        int err = 0;
-        if (istate == 3)
+        try
         {
-            sciprint(_("The user-supplied subroutine res signalled lsodi to halt the integration and return (ires=2). Execution of the external function has failed.\n"));
-            err = 1;
+            C2F(lsodi)(impl_f, impl_g, impl_jac, YSize, pdYData, pDblYdot0->get(), &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, &jacType);
+
+            // check error
+            if (istate == 3)
+            {
+                sciprint(_("The user-supplied subroutine res signalled lsodi to halt the integration and return (ires=2). Execution of the external function has failed.\n"));
+                err = 1;
+                Scierror(999, _("%s: %s exit with state %d.\n"), "impl", "lsodi", istate);
+            }
+            else
+            {
+                err = checkOdeError(meth, istate);
+                Scierror(999, _("%s: %s exit with state %d.\n"), "impl", "lsodi", istate);
+            }
         }
-        else
+        catch (ScilabError &e)
         {
-            err = checkOdeError(meth, istate);
+            char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+            sciprint(_("%s: exception caught in '%s' subroutine.\n"), "impl", "lsodi");
+            Scierror(999, pstrMsg);
+            FREE(pstrMsg);
+            err = 1;
         }
 
         if (err == 1)
         {
-            Scierror(999, _("%s: %s exit with state %d.\n"), "impl", "lsodi", istate);
             DifferentialEquation::removeDifferentialEquationFunctions();
             free(pdYData);
             free(YSize);
index f01544e..71d06f9 100644 (file)
@@ -68,44 +68,44 @@ types::Function::ReturnValue sci_int2d(types::typed_list &in, int _iRetCount, ty
     // X
     if (in[0]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int2d", 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int2d", 1);
         return types::Function::Error;
     }
     pDblX = in[0]->getAs<types::Double>();//->clone()->getAs<types::Double>();
     if (pDblX->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int2d", 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int2d", 1);
         return types::Function::Error;
     }
 
     if (pDblX->getRows() != 3)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A 3 by N matrix expected.\n"), "int2d", 1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A 3 by N matrix expected.\n"), "int2d", 1);
         return types::Function::Error;
     }
 
     // Y
     if (in[1]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int2d", 2);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int2d", 2);
         return types::Function::Error;
     }
     pDblY = in[1]->getAs<types::Double>();//->clone()->getAs<types::Double>();
     if (pDblY->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int2d", 2);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int2d", 2);
         return types::Function::Error;
     }
 
     if (pDblY->getRows() != 3)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A 3 by N matrix expected.\n"), "int2d", 2);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A 3 by N matrix expected.\n"), "int2d", 2);
         return types::Function::Error;
     }
 
     if (pDblY->getCols() != pDblX->getCols())
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : Same size of input argument %d expected.\n"), "int2d", 2, 1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: Same size of input argument %d expected.\n"), "int2d", 2, 1);
         return types::Function::Error;
     }
 
@@ -125,7 +125,7 @@ types::Function::ReturnValue sci_int2d(types::typed_list &in, int _iRetCount, ty
         double ret = int2d_f(&x, &y);
         if (ret == 0)
         {
-            Scierror(50, _("%s: Argument #%d : Variable returned by scilab argument function is incorrect.\n"), "int2d", 3);
+            Scierror(50, _("%s: Argument #%d: Variable returned by scilab argument function is incorrect.\n"), "int2d", 3);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -151,7 +151,7 @@ types::Function::ReturnValue sci_int2d(types::typed_list &in, int _iRetCount, ty
 
         if (pList->getSize() == 0)
         {
-            Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "int2d", 3, "(string empty)");
+            Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "int2d", 3, "(string empty)");
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -166,14 +166,14 @@ types::Function::ReturnValue sci_int2d(types::typed_list &in, int _iRetCount, ty
         }
         else
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : The first argument in the list must be a Scilab function.\n"), "int2d", 3);
+            Scierror(999, _("%s: Wrong type for input argument #%d: The first argument in the list must be a Scilab function.\n"), "int2d", 3);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
     }
     else
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A function expected.\n"), "int2d", 3);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A function expected.\n"), "int2d", 3);
         DifferentialEquation::removeDifferentialEquationFunctions();
         return types::Function::Error;
     }
@@ -183,7 +183,7 @@ types::Function::ReturnValue sci_int2d(types::typed_list &in, int _iRetCount, ty
     {
         if (in[3]->isDouble() == false)
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int2d", 4);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int2d", 4);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -191,14 +191,14 @@ types::Function::ReturnValue sci_int2d(types::typed_list &in, int _iRetCount, ty
         pDblParams = in[3]->getAs<types::Double>();
         if (pDblParams->isComplex())
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int2d", 4);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int2d", 4);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
 
         if (pDblParams->getSize() != 5)
         {
-            Scierror(999, _("%s: Wrong size for input argument #%d : %d expected.\n"), "int2d", 4, 5);
+            Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), "int2d", 4, 5);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -207,17 +207,17 @@ types::Function::ReturnValue sci_int2d(types::typed_list &in, int _iRetCount, ty
         {
             if (pDblParams->get(0) < 0.0e0)
             {
-                sciprint(_("%ls: Warning : Wrong value for the first element of argument #%d : The default value will be used.\n"), L"int2d", 4);
+                sciprint(_("%ls: Warning: Wrong value for the first element of argument #%d: The default value will be used.\n"), L"int2d", 4);
             }
 
             if (pDblParams->get(2) < 1)
             {
-                sciprint(_("%ls: Warning : Wrong value for the third element of argument #%d : The default value will be used.\n"), L"int2d", 4);
+                sciprint(_("%ls: Warning: Wrong value for the third element of argument #%d: The default value will be used.\n"), L"int2d", 4);
             }
 
             if (pDblParams->get(3) < 1)
             {
-                sciprint(_("%ls: Warning : Wrong value for the fourth element of argument #%d : The default value will be used.\n"), L"int2d", 4);
+                sciprint(_("%ls: Warning: Wrong value for the fourth element of argument #%d: The default value will be used.\n"), L"int2d", 4);
             }
         }
 
@@ -231,13 +231,26 @@ types::Function::ReturnValue sci_int2d(types::typed_list &in, int _iRetCount, ty
     // *** Perform operation. ***
     int size = pDblX->getCols();
 
-    double* dwork   = (double*)malloc(9 * maxtri * sizeof(double));
-    int* iwork      = (int*)malloc(2 * maxtri * sizeof(int));
+    double* dwork   = (double*)MALLOC(9 * maxtri * sizeof(double));
+    int* iwork      = (int*)MALLOC(2 * maxtri * sizeof(int));
 
-    C2F(twodq)(int2d_f, &size, pDblX->get(), pDblY->get(), &tol, &iclose, &maxtri, &mevals, &result, &err, &nu, &nd, &nevals, &iflag, dwork, iwork);
+    try
+    {
+        C2F(twodq)(int2d_f, &size, pDblX->get(), pDblY->get(), &tol, &iclose, &maxtri, &mevals, &result, &err, &nu, &nd, &nevals, &iflag, dwork, iwork);
+    }
+    catch (ScilabError &e)
+    {
+        char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+        sciprint(_("%s: exception caught in '%s' subroutine.\n"), "int2d", "twodq");
+        Scierror(999, pstrMsg);
+        FREE(dwork);
+        FREE(iwork);
+        DifferentialEquation::removeDifferentialEquationFunctions();
+        return types::Function::Error;
+    }
 
-    free(dwork);
-    free(iwork);
+    FREE(dwork);
+    FREE(iwork);
     DifferentialEquation::removeDifferentialEquationFunctions();
 
     if (iflag)
@@ -271,7 +284,7 @@ types::Function::ReturnValue sci_int2d(types::typed_list &in, int _iRetCount, ty
             }
             default :// normaly nerver call.
             {
-                Scierror(999, _("%s: twodq return with error %d.\n"), "int2d", iflag);
+                Scierror(999, _("%s: twodq return with state %d.\n"), "int2d", iflag);
             }
         }
         return types::Function::Error;
index b16b166..d438b08 100644 (file)
@@ -67,69 +67,69 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
     // X
     if (in[0]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int3d", 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int3d", 1);
         return types::Function::Error;
     }
     pDblX = in[0]->getAs<types::Double>();
     if (pDblX->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int3d", 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int3d", 1);
         return types::Function::Error;
     }
 
     if (pDblX->getRows() != 4)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A 4 by N matrix expected.\n"), "int3d", 1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A 4 by N matrix expected.\n"), "int3d", 1);
         return types::Function::Error;
     }
 
     // Y
     if (in[1]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int3d", 2);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int3d", 2);
         return types::Function::Error;
     }
     pDblY = in[1]->getAs<types::Double>();
     if (pDblY->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int3d", 2);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int3d", 2);
         return types::Function::Error;
     }
 
     if (pDblY->getRows() != 4)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A 4 by N matrix expected.\n"), "int3d", 2);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A 4 by N matrix expected.\n"), "int3d", 2);
         return types::Function::Error;
     }
 
     if (pDblY->getCols() != pDblX->getCols())
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : Same size of input argument %d expected.\n"), "int3d", 2, 1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: Same size of input argument %d expected.\n"), "int3d", 2, 1);
         return types::Function::Error;
     }
 
     // Z
     if (in[2]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int3d", 3);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int3d", 3);
         return types::Function::Error;
     }
     pDblZ = in[2]->getAs<types::Double>();
     if (pDblZ->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int3d", 3);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int3d", 3);
         return types::Function::Error;
     }
 
     if (pDblZ->getRows() != 4)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A 4 by N matrix expected.\n"), "int3d", 4);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A 4 by N matrix expected.\n"), "int3d", 4);
         return types::Function::Error;
     }
 
     if (pDblZ->getCols() != pDblX->getCols())
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : Same size of input argument %d expected.\n"), "int3d", 3, 1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: Same size of input argument %d expected.\n"), "int3d", 3, 1);
         return types::Function::Error;
     }
 
@@ -141,18 +141,6 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
     {
         types::Callable* pCall = in[3]->getAs<types::Callable>();
         deFunctionsManager->setFFunction(pCall);
-
-        // check function
-        double xyz[3] = {1, 1, 1};
-        int numfun = 1;
-        double out;
-        double ret = int3d_f(xyz, &numfun, &out);
-        if (ret == 0)
-        {
-            Scierror(50, _("%s: Argument #%d : Variable returned by scilab argument function is incorrect.\n"), "int3d", 4);
-            DifferentialEquation::removeDifferentialEquationFunctions();
-            return types::Function::Error;
-        }
     }
     else if (in[3]->isString())
     {
@@ -175,7 +163,7 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
 
         if (pList->getSize() == 0)
         {
-            Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "int3d", 4, "(string empty)");
+            Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "int3d", 4, "(string empty)");
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -190,14 +178,14 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
         }
         else
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : The first argument in the list must be a Scilab function.\n"), "int3d", 4);
+            Scierror(999, _("%s: Wrong type for input argument #%d: The first argument in the list must be a Scilab function.\n"), "int3d", 4);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
     }
     else
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A function expected.\n"), "int3d", 4);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A function expected.\n"), "int3d", 4);
         DifferentialEquation::removeDifferentialEquationFunctions();
         return types::Function::Error;
     }
@@ -207,21 +195,21 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
     {
         if (in[4]->isDouble() == false)
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int3d", 5);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int3d", 5);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
         types::Double* pDblNf = in[4]->getAs<types::Double>();
         if (pDblNf->isComplex())
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int3d", 5);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int3d", 5);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
 
         if (pDblNf->isScalar() == false)
         {
-            Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "int3d", 5);
+            Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), "int3d", 5);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -229,7 +217,7 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
 
         if (nf < 1)
         {
-            Scierror(999, _("%s: Wrong value for input argument #%d : A positive value expected.\n"), "int3d", 5);
+            Scierror(999, _("%s: Wrong value for input argument #%d: A positive value expected.\n"), "int3d", 5);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -240,7 +228,7 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
     {
         if (in[5]->isDouble() == false)
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int3d", 6);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int3d", 6);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -248,14 +236,14 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
         types::Double* pDblParams = in[5]->getAs<types::Double>();
         if (pDblParams->isComplex())
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "int3d", 6);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "int3d", 6);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
 
         if (pDblParams->getSize() != 4)
         {
-            Scierror(999, _("%s: Wrong size for input argument #%d : %d expected.\n"), "int3d", 6, 4);
+            Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), "int3d", 6, 4);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -266,7 +254,7 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
             {
                 if (pDblParams->get(i) < 0)
                 {
-                    sciprint(_("%ls: Warning : Wrong value for the element %d of argument #%d : The default value will be used.\n"), L"int3d", i + 1, 6);
+                    sciprint(_("%ls: Warning: Wrong value for the element %d of argument #%d: The default value will be used.\n"), L"int3d", i + 1, 6);
                 }
             }
         }
@@ -280,7 +268,7 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
         {
             if (getWarningMode())
             {
-                sciprint(_("%ls: Warning : Wrong value for the element %d and %d of argument #%d : The default value will be used.\n"), L"int3d", 3, 4, 6);
+                sciprint(_("%ls: Warning: Wrong value for the element %d and %d of argument #%d: The default value will be used.\n"), L"int3d", 3, 4, 6);
             }
             epsabs = 0.0;
             epsrel = 1.0e-5;
@@ -288,7 +276,7 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
 
         if (minpts > maxpts)
         {
-            Scierror(999, _("%s: Wrong value for input argument #%d : minpts smaller than maxpts expected.\n"), "int3d", 6);
+            Scierror(999, _("%s: Wrong value for input argument #%d: minpts smaller than maxpts expected.\n"), "int3d", 6);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -302,32 +290,46 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
     int maxsub  = 7 * (maxpts - 43 * pDblX->getCols()) / (8 * 43) + pDblX->getCols();
     int size    = 4 * pDblX->getCols();
 
-    // input data : 3 rows, 4*maxsub cols
+    // input data: 3 rows, 4*maxsub cols
     int dataSize = 3 * 4 * maxsub;
-    double* pdData = (double*)malloc(dataSize * sizeof(double));
+    double* pdData = (double*)MALLOC(dataSize * sizeof(double));
     C2F(dcopy)(&size, pDblX->get(), &one, pdData, &three);
     C2F(dcopy)(&size, pDblY->get(), &one, pdData + 1, &three);
     C2F(dcopy)(&size, pDblZ->get(), &one, pdData + 2, &three);
 
     // output result
-    double* pdResult = (double*)malloc(nf * sizeof(double));
+    double* pdResult = (double*)MALLOC(nf * sizeof(double));
 
     // output err
-    double* pdErr = (double*)malloc(nf * sizeof(double));
+    double* pdErr = (double*)MALLOC(nf * sizeof(double));
 
     // workspace
     int mdiv = 1; // default value, but can be changed on parallel computers. (see dcutet.f)
     int dworkSize   = maxsub * (2 * nf + 1) + 7 * Max(8 * mdiv, pDblX->getCols()) * nf + 1;
     int iworkSize   = maxsub + mdiv;
-    double* dwork   = (double*)malloc(dworkSize * sizeof(double));
-    int* iwork      = (int*)malloc(iworkSize * sizeof(int));
+    double* dwork   = (double*)MALLOC(dworkSize * sizeof(double));
+    int* iwork      = (int*)MALLOC(iworkSize * sizeof(int));
 
     int cols = pDblX->getCols();
-    C2F(dcutet)(int3d_f, &nf, pdData, &cols, &minpts, &maxpts, &epsabs, &epsrel, &maxsub, &dworkSize, &irestar, pdResult, pdErr, &nevals, &ifail, dwork, iwork);
+    try
+    {
+        C2F(dcutet)(int3d_f, &nf, pdData, &cols, &minpts, &maxpts, &epsabs, &epsrel, &maxsub, &dworkSize, &irestar, pdResult, pdErr, &nevals, &ifail, dwork, iwork);
+    }
+    catch (ScilabError &e)
+    {
+        char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+        sciprint(_("%s: exception caught in '%s' subroutine.\n"), "int3d", "dcutet");
+        Scierror(999, pstrMsg);
+        FREE(pdData);
+        FREE(dwork);
+        FREE(iwork);
+        DifferentialEquation::removeDifferentialEquationFunctions();
+        return types::Function::Error;
+    }
 
-    free(pdData);
-    free(dwork);
-    free(iwork);
+    FREE(pdData);
+    FREE(dwork);
+    FREE(iwork);
     DifferentialEquation::removeDifferentialEquationFunctions();
 
     if (ifail)
@@ -336,21 +338,21 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
         {
             if (getWarningMode())
             {
-                sciprint(_("%ls: Warning : maxpts was too small to obtain the required accuracy.\n"), L"int3d");
+                sciprint(_("%ls: Warning: maxpts was too small to obtain the required accuracy.\n"), L"int3d");
             }
         }
         else if (ifail == 3)
         {
             Scierror(999, _("%s: The volume of one of the initially given tetrahedrons is zero.\n"), "int3d");
-            free(pdResult);
-            free(pdErr);
+            FREE(pdResult);
+            FREE(pdErr);
             return types::Function::Error;
         }
         else // normaly nerver call.
         {
             Scierror(999, _("%s: dcutet return with error %d.\n"), "int3d", ifail);
-            free(pdResult);
-            free(pdErr);
+            FREE(pdResult);
+            FREE(pdErr);
             return types::Function::Error;
         }
     }
@@ -373,8 +375,8 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
         out.push_back(pDblNevalsOut);
     }
 
-    free(pdResult);
-    free(pdErr);
+    FREE(pdResult);
+    FREE(pdErr);
 
     return types::Function::OK;
 }
index 61e4d5c..32f7459 100644 (file)
@@ -69,7 +69,7 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
     // A
     if (in[0]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "intg", 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "intg", 1);
         return types::Function::Error;
     }
 
@@ -77,7 +77,7 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
 
     if (pDblA->isScalar() == false)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "intg", 1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), "intg", 1);
         return types::Function::Error;
     }
 
@@ -85,14 +85,14 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
 
     if (ISNAN(pdA) || C2F(vfinite)(&iOne , &pdA) == false)
     {
-        Scierror(264, _("%s: Wrong type for input argument #%d : Must not contain NaN or Inf.\n"), "intg", 1);
+        Scierror(264, _("%s: Wrong type for input argument #%d: Must not contain NaN or Inf.\n"), "intg", 1);
         return types::Function::Error;
     }
 
     // B
     if (in[1]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "intg", 2);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "intg", 2);
         return types::Function::Error;
     }
 
@@ -100,7 +100,7 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
 
     if (pDblB->isScalar() == false)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "intg", 2);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), "intg", 2);
         return types::Function::Error;
     }
 
@@ -108,7 +108,7 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
 
     if (ISNAN(pdB) || C2F(vfinite)(&iOne , &pdB) == false)
     {
-        Scierror(264, _("%s: Wrong type for input argument #%d : Must not contain NaN or Inf.\n"), "intg", 1);
+        Scierror(264, _("%s: Wrong type for input argument #%d: Must not contain NaN or Inf.\n"), "intg", 1);
         return types::Function::Error;
     }
 
@@ -126,7 +126,7 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
         double ret = intg_f(&t);
         if (ret == 0)
         {
-            Scierror(50, _("%s: Argument #%d : Variable returned by scilab argument function is incorrect.\n"), "intg", 3);
+            Scierror(50, _("%s: Argument #%d: Variable returned by scilab argument function is incorrect.\n"), "intg", 3);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -152,7 +152,7 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
 
         if (pList->getSize() == 0)
         {
-            Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "intg", 3, "(string empty)");
+            Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "intg", 3, "(string empty)");
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -167,14 +167,14 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
         }
         else
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : The first argument in the list must be a Scilab function.\n"), "intg", 3);
+            Scierror(999, _("%s: Wrong type for input argument #%d: The first argument in the list must be a Scilab function.\n"), "intg", 3);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
     }
     else
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A function expected.\n"), "intg", 3);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A function expected.\n"), "intg", 3);
         DifferentialEquation::removeDifferentialEquationFunctions();
         return types::Function::Error;
     }
@@ -183,7 +183,7 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
     {
         if (in[3]->isDouble() == false)
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "intg", 4);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "intg", 4);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -192,7 +192,7 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
 
         if (pDblEpsR->isScalar() == false)
         {
-            Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "intg", 4);
+            Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), "intg", 4);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -204,7 +204,7 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
     {
         if (in[4]->isDouble() == false)
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "intg", 5);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "intg", 5);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -213,7 +213,7 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
 
         if (pDblEpsA->isScalar() == false)
         {
-            Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "intg", 5);
+            Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), "intg", 5);
             DifferentialEquation::removeDifferentialEquationFunctions();
             return types::Function::Error;
         }
@@ -226,20 +226,33 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
     int last    = 0;
     int lenw    = 4 * limit;
 
-    double* dwork   = (double*)malloc(lenw * sizeof(double));
-    int* iwork      = (int*)malloc(limit * sizeof(int));
+    double* dwork   = (double*)MALLOC(lenw * sizeof(double));
+    int* iwork      = (int*)MALLOC(limit * sizeof(int));
 
     double epsabs   = fabs(pdEpsA);
     double epsrel   = fabs(pdEpsR);
 
     // *** Perform operation. ***
     int ier = 0;
-    C2F(dqags)(intg_f, &pdA, &pdB, &epsabs, &epsrel,
-               &result, &abserr, &neval, &ier,
-               &limit, &lenw, &last, iwork, dwork);
+    try
+    {
+        C2F(dqags)(intg_f, &pdA, &pdB, &epsabs, &epsrel,
+                   &result, &abserr, &neval, &ier,
+                   &limit, &lenw, &last, iwork, dwork);
+    }
+    catch (ScilabError &e)
+    {
+        char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+        sciprint(_("%s: exception caught in '%s' subroutine.\n"), "intg", "dqags");
+        Scierror(999, pstrMsg);
+        FREE(dwork);
+        FREE(iwork);
+        DifferentialEquation::removeDifferentialEquationFunctions();
+        return types::Function::Error;
+    }
 
-    free(dwork);
-    free(iwork);
+    FREE(dwork);
+    FREE(iwork);
     DifferentialEquation::removeDifferentialEquationFunctions();
 
     if (ier)
@@ -290,7 +303,7 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
         }
         else
         {
-            Scierror(999, msg, "intg : Error");
+            Scierror(999, msg, "intg: Error");
             return types::Function::Error;
         }
     }
diff --git a/scilab/modules/differential_equations/sci_gateway/cpp/sci_intg2.cpp b/scilab/modules/differential_equations/sci_gateway/cpp/sci_intg2.cpp
deleted file mode 100644 (file)
index edab30e..0000000
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
-* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-* Copyright (C) 2011 - DIGITEO - Cedric DELAMARRE
-*
-* 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
-*
-*/
-/*--------------------------------------------------------------------------*/
-
-#include "differential_equations_gw.hxx"
-#include "function.hxx"
-#include "double.hxx"
-#include "overload.hxx"
-#include "execvisitor.hxx"
-#include "callable.hxx"
-
-extern "C"
-{
-#include "localization.h"
-#include "Scierror.h"
-#include "scifunctions.h"
-#include "sci_warning.h"
-#include "sciprint.h"
-}
-
-/*--------------------------------------------------------------------------*/
-types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, types::typed_list &out)
-{
-    double pdA    = 0;
-    double pdB    = 0;
-    double pdEpsR = 1.0e-8;
-    double pdEpsA = 1.0e-14;
-
-    double result = 0;
-    double abserr = 0;
-
-    DifferentialEquationFunctions* deFunctionsManager = new DifferentialEquationFunctions(L"intg");
-    ConfigVariable::addDifferentialEquationFunctions(deFunctionsManager);
-
-    // *** check the minimal number of input args. ***
-    if (in.size() < 3 || in.size() > 5)
-    {
-        ScierrorW(77, _W("%ls: Wrong number of input argument(s): %d expected.\n"), L"intg", 3);
-        return types::Function::Error;
-    }
-
-    // *** check number of output args ***
-    if (_iRetCount > 2)
-    {
-        ScierrorW(78, _W("%ls: Wrong number of output argument(s): %d expected.\n"), L"intg", 2);
-        return types::Function::Error;
-    }
-
-    // *** check type of input args and get it. ***
-    // A
-    if (in[0]->isDouble() == false)
-    {
-        ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A matrix expected.\n"), L"intg", 1);
-        return types::Function::Error;
-    }
-
-    types::Double* pDblA = in[0]->getAs<types::Double>();
-
-    if (pDblA->isScalar() == false)
-    {
-        ScierrorW(999, _W("%ls: Wrong size for input argument #%d : A scalar expected.\n"), L"intg", 1);
-        return types::Function::Error;
-    }
-
-    pdA = pDblA->get(0);
-
-    // B
-    if (in[1]->isDouble() == false)
-    {
-        ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A matrix expected.\n"), L"intg", 2);
-        return types::Function::Error;
-    }
-
-    types::Double* pDblB = in[1]->getAs<types::Double>();
-
-    if (pDblB->isScalar() == false)
-    {
-        ScierrorW(999, _W("%ls: Wrong size for input argument #%d : A scalar expected.\n"), L"intg", 2);
-        return types::Function::Error;
-    }
-
-    pdB = pDblB->get(0);
-
-    // function
-    if (in[2]->isCallable())
-    {
-        types::Callable* pCall = in[2]->getAs<types::Callable>();
-        deFunctionsManager->setFFunction(pCall);
-
-    }
-    else if (in[2]->isString())
-    {
-        bool bOK = false;
-        types::String* pStr = in[2]->getAs<types::String>();
-        bOK = deFunctionsManager->setFFunction(pStr);
-
-        if (bOK == false)
-        {
-            ScierrorW(50, _W("%ls: Subroutine not found: %ls\n"), L"intg", pStr->get(0));
-            return types::Function::Error;
-        }
-    }
-    /*    else if(in[2]->isList())
-        {
-            types::List* pList = in[2]->getAs<types::List>();
-
-            if(pList->getSize() == 0)
-            {
-                ScierrorW(50,_W("%ls: Argument #%d : Subroutine not found in list: %ls\n"), L"intg", 3, L"(string empty)");
-                return types::Function::Error;
-            }
-
-            if(pList->get(0)->isString())
-            {
-                bool bOK = false;
-                types::String* pStr = pList->get(0)->getAs<types::String>();
-                bOK = deFunctionsManager->setOdeFFunction(pStr);
-
-                if(bOK == false)
-                {
-                    ScierrorW(50,_W("%ls: Argument #%d : Subroutine not found in list: %ls\n"), L"intg", 3, pStr->get(0));
-                    return types::Function::Error;
-                }
-
-                // realloc YSize to store the arguments size
-                int totalSize = *YSize;
-                free(YSize);
-                YSize = (int*)malloc((pList->getSize() - 1) * sizeof(int));
-                YSize[0] = totalSize;
-
-                // get arguments and store their size in YSize
-                std::vector<types::Double*> vpDbl;
-                for(int iter = 0; iter < pList->getSize() - 1; iter++)
-                {
-                    if(pList->get(iter + 1)->isDouble() == false)
-                    {
-                        ScierrorW(999, _W("%ls: Wrong type for input argument #%d : Argument %d in the list must be a matrix.\n"), L"intg", 3, iter+1);
-                        return types::Function::Error;
-                    }
-
-                    vpDbl.push_back(pList->get(iter+1)->getAs<types::Double>());
-                    YSize[iter + 1] = vpDbl[iter]->getSize();
-                    totalSize += YSize[iter + 1];
-                }
-
-                // realloc Y to store arguments data in pdYData
-                double* pdYDataTemp = pdYData;
-                pdYData = (double*)malloc(totalSize * sizeof(double));
-                C2F(dcopy)(&YSize[0], pdYDataTemp, &one, pdYData, &one);
-                free(pdYDataTemp);
-
-                int position = YSize[0];
-                for(int iter = 0; iter < pList->getSize()-1; iter++)
-                {
-                    C2F(dcopy)(&YSize[iter + 1], vpDbl[iter]->get(), &one, &pdYData[position], &one);
-                    position += vpDbl[iter]->getSize();
-                }
-                vpDbl.clear();
-            }
-            else if(pList->get(0)->isCallable())
-            {
-                deFunctionsManager->setOdeFFunction(pList->get(0)->getAs<types::Callable>());
-                for(int iter = 1; iter < pList->getSize(); iter++)
-                {
-                    deFunctionsManager->setOdeFArgs(pList->get(iter)->getAs<types::InternalType>());
-                }
-            }
-            else
-            {
-                ScierrorW(999, _W("%ls: Wrong type for input argument #%d : The first argument in the list must be a string or a function.\n"), L"intg", 3);
-                return types::Function::Error;
-            }
-        }
-    */
-    else
-    {
-        ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A function expected.\n"), L"intg", 3);
-        return types::Function::Error;
-    }
-
-    if (in.size() > 3)
-    {
-        if (in[3]->isDouble() == false)
-        {
-            ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A matrix expected.\n"), L"intg", 4);
-            return types::Function::Error;
-        }
-
-        types::Double* pDblEpsR = in[3]->getAs<types::Double>();
-
-        if (pDblEpsR->isScalar() == false)
-        {
-            ScierrorW(999, _W("%ls: Wrong size for input argument #%d : A scalar expected.\n"), L"intg", 4);
-            return types::Function::Error;
-        }
-
-        pdEpsR = pDblEpsR->get(0);
-    }
-
-    if (in.size() == 5)
-    {
-        if (in[4]->isDouble() == false)
-        {
-            ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A matrix expected.\n"), L"intg", 5);
-            return types::Function::Error;
-        }
-
-        types::Double* pDblEpsA = in[4]->getAs<types::Double>();
-
-        if (pDblEpsA->isScalar() == false)
-        {
-            ScierrorW(999, _W("%ls: Wrong size for input argument #%d : A scalar expected.\n"), L"intg", 5);
-            return types::Function::Error;
-        }
-        pdEpsA = pDblEpsA->get(0);
-    }
-
-    // *** Create working table. ***
-    int limit = 3000 / 4;
-    int workSize = 3000;
-    int iworkSize = (3000 / 8 + 2) * 2 + 1;
-
-    double* work = (double*)malloc(workSize * sizeof(double));
-    int* iwork = (int*)malloc(iworkSize * sizeof(int));
-    double epsabs = fabs(pdEpsA);
-    double epsrel = fabs(pdEpsR);
-
-    // *** Perform operation. ***
-    //C2F(dqag0)(intg_f, &pdA, &pdB, &pdEpsa, &pdEpsr, val, abserr, stk(lpal), lw, stk(lpali), liw, ifail);
-
-    double* alist = work;
-    double* blist = work  + limit;
-    double* elist = blist + limit;
-    double* rlist = elist + limit;
-
-    int ier = 0;
-
-    C2F(dqags)(intg_f, &pdA, &pdB, &epsabs, &epsrel, alist, blist, elist, rlist, &limit, iwork, &iworkSize, &result, &abserr, &ier);
-
-    if (ier)
-    {
-        switch (ier)
-        {
-            case 1 :
-            {
-                ScierrorW(999, _W("%ls: Maximum number of subdivisions allowed has been achieved.\n"), L"intg");
-                return types::Function::Error;
-            }
-            case 2 :
-            {
-                if (getWarningMode())
-                {
-                    sciprintW(_W("%ls: Warning : The occurrence of roundoff error is detected, which prevents the requested tolerance from being achieved. The error may be under-estimated.\n"), L"intg");
-                }
-                break;
-            }
-            case 3 :
-            {
-                ScierrorW(999, _W("%ls: Extremely bad integrand behaviour occurs at some points of the integration interval.\n"), L"intg");
-                return types::Function::Error;
-            }
-            case 4 :
-            {
-                if (getWarningMode())
-                {
-                    sciprintW(_W("%ls: Warning : The algorithm does not converge. Roundoff error is detected in the extrapolation table. It is presumed that the requested tolerance cannot be achieved, and that the returned result is the best which can be obtained.\n"), L"intg");
-                }
-                break;
-            }
-            case 5 :
-            {
-                ScierrorW(999, _W("%ls: The integral is probably divergent, or slowly convergent.\n"), L"intg");
-                return types::Function::Error;
-            }
-        }
-    }
-
-    // *** Return result in Scilab. ***
-    types::Double* pDblOut = new types::Double(result);
-    out.push_back(pDblOut);
-
-    if (_iRetCount == 2)
-    {
-        types::Double* pDblErrOut = new types::Double(abserr);
-        out.push_back(pDblErrOut);
-    }
-
-    // *** free. ***
-    free(work);
-    free(iwork);
-
-    ConfigVariable::removeDifferentialEquationFunctions();
-
-    return types::Function::OK;
-}
-/*--------------------------------------------------------------------------*/
-
index 11d5e34..305b55f 100644 (file)
@@ -131,7 +131,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
         }
         else
         {
-            Scierror(999, _("%s: Wrong value for input argument #%d : It must be one of the following strings : adams, stiff, rk, rkf, fix, root or discrete.\n"), "ode", 1);
+            Scierror(999, _("%s: Wrong value for input argument #%d: It must be one of the following strings: adams, stiff, rk, rkf, fix, root or discrete.\n"), "ode", 1);
             return types::Function::Error;
         }
     }
@@ -169,13 +169,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
         pDblY0 = in[iPos]->getAs<types::Double>();
         if (pDblY0->isComplex())
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "ode", iPos + 1);
-            return types::Function::Error;
-        }
-
-        if (pDblY0->getCols() != 1)
-        {
-            Scierror(999, _("%s: Wrong size for input argument #%d : A real colunm vector expected (n x 1).\n"), "ode", iPos + 1);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "ode", iPos + 1);
             return types::Function::Error;
         }
     }
@@ -185,17 +179,17 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
             pPolyY0 = in[iPos]->getAs<types::Polynom>();
             if(pPolyY0->isComplex())
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A real polynom expected.\n"), "ode", iPos+1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A real polynom expected.\n"), "ode", iPos+1);
                 return types::Function::Error;
             }
 
             if(pPolyY0->isScalar() == false)
             {
-                Scierror(999, _("%s: Wrong size for input argument #%d : A real scalar polynom expected.\n"), "ode", iPos+1);
+                Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar polynom expected.\n"), "ode", iPos+1);
                 return types::Function::Error;
             }
 
-            double* dbl = (double*)malloc(pPolyY0->getCoef()->getSize() * sizeof(double));
+            double* dbl = (double*)MALLOC(pPolyY0->getCoef()->getSize() * sizeof(double));
             vTransposeRealMatrix(   pPolyY0->getCoef()->get(),
                                     pPolyY0->getCoef()->getRows(),
                                     pPolyY0->getCoef()->getCols(),
@@ -207,7 +201,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
     */
     else
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "ode", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "ode", iPos + 1);
         return types::Function::Error;
     }
 
@@ -215,7 +209,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "ode", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "ode", iPos + 1);
         return types::Function::Error;
     }
 
@@ -223,7 +217,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
 
     if (pDblT0->isScalar() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "ode", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "ode", iPos + 1);
         return types::Function::Error;
     }
 
@@ -231,7 +225,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "ode", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "ode", iPos + 1);
         return types::Function::Error;
     }
 
@@ -243,9 +237,9 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
     deFunctionsManager->setOdeYRows(pDblY0->getRows());
     deFunctionsManager->setOdeYCols(pDblY0->getCols());
 
-    YSize = (int*)malloc(sizeOfYSize * sizeof(int));
+    YSize = (int*)MALLOC(sizeOfYSize * sizeof(int));
     *YSize = pDblY0->getSize();
-    pdYData = (double*)malloc(pDblY0->getSize() * sizeof(double));
+    pdYData = (double*)MALLOC(pDblY0->getSize() * sizeof(double));
     C2F(dcopy)(YSize, pDblY0->get(), &one, pdYData, &one);
 
     if (meth == 4)
@@ -254,22 +248,22 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
         {
             Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "ode", 5);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYData);
-            free(YSize);
+            FREE(pdYData);
+            FREE(YSize);
             return types::Function::Error;
         }
 
         if (in[4]->isCallable() == false && in[4]->isString() == false && in[4]->isList() == false)
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A function expected.\n"), "ode", 5);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A function expected.\n"), "ode", 5);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYData);
-            free(YSize);
+            FREE(pdYData);
+            FREE(YSize);
             return types::Function::Error;
         }
     }
 
-    for (iPos++; iPos < in.size(); iPos++)
+    for (iPos++; iPos < (int)in.size(); iPos++)
     {
         if (in[iPos]->isDouble())
         {
@@ -280,8 +274,8 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                 {
                     Scierror(267, _("%s: Arg %d and arg %d must have equal dimensions.\n"), "ode", pStrType ? 2 : 1, iPos + 1);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
@@ -292,8 +286,8 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                 {
                     Scierror(267, _("%s: Arg %d and arg %d must have equal dimensions.\n"), "ode", pStrType ? 2 : 1, iPos + 1);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
@@ -303,14 +297,14 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
             }
             else if (pDblW == NULL && bFuncF == true && (bFuncG == true || meth != 3))
             {
-                if (in.size() == iPos + 2)
+                if ((int)in.size() == iPos + 2)
                 {
                     if (in[iPos + 1]->isDouble() == false)
                     {
-                        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "ode", iPos + 2);
+                        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "ode", iPos + 2);
                         DifferentialEquation::removeDifferentialEquationFunctions();
-                        free(pdYData);
-                        free(YSize);
+                        FREE(pdYData);
+                        FREE(YSize);
                         return types::Function::Error;
                     }
 
@@ -322,17 +316,17 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                 {
                     Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "ode", iPos + 2);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A function expected.\n"), "ode", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A function expected.\n"), "ode", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -356,10 +350,10 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "ode", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "ode", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -385,10 +379,10 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "ode", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "ode", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
@@ -398,8 +392,8 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                 Scierror(50, _("%s: Subroutine not found: %s\n"), "ode", pst);
                 FREE(pst);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -409,19 +403,19 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
 
             if (pList->getSize() == 0)
             {
-                Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "ode", iPos + 1, "(string empty)");
+                Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "ode", iPos + 1, "(string empty)");
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
             if (bFuncF && (bFuncJac || pDblNg) && (bFuncG || meth != 3))
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "ode", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "ode", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
@@ -458,18 +452,18 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                 if (bOK == false)
                 {
                     char* pst = wide_string_to_UTF8(pStr->get(0));
-                    Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "ode", iPos + 1, pst);
+                    Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "ode", iPos + 1, pst);
                     FREE(pst);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
 
                 int* sizeTemp = YSize;
                 int totalSize = sizeOfpdYData;
 
-                YSize = (int*)malloc((sizeOfYSize + pList->getSize() - 1) * sizeof(int));
+                YSize = (int*)MALLOC((sizeOfYSize + pList->getSize() - 1) * sizeof(int));
                 memcpy(YSize, sizeTemp, sizeOfYSize * sizeof(int));
 
                 std::vector<types::Double*> vpDbl;
@@ -477,10 +471,10 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                 {
                     if (pList->get(iter + 1)->isDouble() == false)
                     {
-                        Scierror(999, _("%s: Wrong type for input argument #%d : Argument %d in the list must be a matrix.\n"), "ode", iPos + 1, iter + 1);
+                        Scierror(999, _("%s: Wrong type for input argument #%d: Argument %d in the list must be a matrix.\n"), "ode", iPos + 1, iter + 1);
                         DifferentialEquation::removeDifferentialEquationFunctions();
-                        free(pdYData);
-                        free(YSize);
+                        FREE(pdYData);
+                        FREE(YSize);
                         return types::Function::Error;
                     }
 
@@ -490,7 +484,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                 }
 
                 double* pdYDataTemp = pdYData;
-                pdYData = (double*)malloc(totalSize * sizeof(double));
+                pdYData = (double*)MALLOC(totalSize * sizeof(double));
                 C2F(dcopy)(&sizeOfpdYData, pdYDataTemp, &one, pdYData, &one);
 
                 int position = sizeOfpdYData;
@@ -502,8 +496,8 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                 vpDbl.clear();
                 sizeOfpdYData = totalSize;
                 sizeOfYSize += pList->getSize() - 1;
-                free(pdYDataTemp);
-                free(sizeTemp);
+                FREE(pdYDataTemp);
+                FREE(sizeTemp);
             }
             else if (pList->get(0)->isCallable())
             {
@@ -537,19 +531,19 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : The first argument in the list must be a string or a function.\n"), "ode", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: The first argument in the list must be a string or a function.\n"), "ode", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
         else
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a function expected.\n"), "ode", iPos + 1);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a function expected.\n"), "ode", iPos + 1);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYData);
-            free(YSize);
+            FREE(pdYData);
+            FREE(YSize);
             return types::Function::Error;
         }
     }
@@ -559,24 +553,24 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
         int val = (meth == 3) ? 3 : 1;
         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "ode", in.size() + val);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYData);
-        free(YSize);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
     if (pDblNg == NULL && meth == 3)
     {
         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "ode", in.size() + 2);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYData);
-        free(YSize);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
     if (bFuncG == false && meth == 3)
     {
         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "ode", in.size() + 1);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYData);
-        free(YSize);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
@@ -631,19 +625,19 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
 
     if (iopt == 1 && (pDblOdeOptions->get(4) > pDblOdeOptions->get(3))) // hmin > hmax ?
     {
-        Scierror(9999, _("%s: Wrong value of hmin and hmax : hmin = %d is greater than hmax = %d.\n"), "ode", pDblOdeOptions->get(4), pDblOdeOptions->get(3));
+        Scierror(9999, _("%s: Wrong value of hmin and hmax: hmin = %d is greater than hmax = %d.\n"), "ode", pDblOdeOptions->get(4), pDblOdeOptions->get(3));
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYData);
-        free(YSize);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
     if (jt < 0 || jt > 5)
     {
-        Scierror(9999, _("%s: Wrong value of Jacobian type : A number between %d and %d expected.\n"), "ode", 0, 5);
+        Scierror(9999, _("%s: Wrong value of Jacobian type: A number between %d and %d expected.\n"), "ode", 0, 5);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYData);
-        free(YSize);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
@@ -675,7 +669,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
     {
         if (pDblRtol->isScalar())
         {
-            rtol = (double*)malloc(sizeof(double));
+            rtol = (double*)MALLOC(sizeof(double));
             *rtol = pDblRtol->get(0);
         }
         else
@@ -686,7 +680,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
     }
     else
     {
-        rtol = (double*)malloc(sizeof(double));
+        rtol = (double*)MALLOC(sizeof(double));
         if (meth == 6 || meth == 7)
         {
             *rtol = 1.e-3;
@@ -701,7 +695,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
     {
         if (pDblAtol->isScalar())
         {
-            atol = (double*)malloc(sizeof(double));
+            atol = (double*)MALLOC(sizeof(double));
             *atol = pDblAtol->get(0);
         }
         else
@@ -712,7 +706,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
     }
     else
     {
-        atol = (double*)malloc(sizeof(double));
+        atol = (double*)MALLOC(sizeof(double));
         if (meth == 6 || meth == 7)
         {
             *atol = 1.e-4;
@@ -758,7 +752,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
 
     switch (meth)
     {
-        case 3 : // lsodar (root)
+        case 3: // lsodar (root)
         {
             //             lrn = 20 + nyh*(mxordn+1) + 3*neq + 3*ng,
             //             lrs = 20 + nyh*(mxords+1) + 3*neq + lmat + 3*ng,
@@ -776,9 +770,9 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
             lrs = lrn;
             dStructTabSize = 246 - 241;
             iStructTabSize = 59 - 50;
-            jroot = (int*)malloc((int)pDblNg->get(0) * sizeof(int));
+            jroot = (int*)MALLOC((int)pDblNg->get(0) * sizeof(int));
         }
-        case 0 : // lsoda
+        case 0: // lsoda
         {
             //             lrn = 20 + nyh*(mxordn+1) + 3*neq,
             //             lrs = 20 + nyh*(mxords+1) + 3*neq + lmat,
@@ -813,11 +807,11 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
 
             break;
         }
-        case 1 : // lsode (adams) (non stiff)
+        case 1: // lsode (adams) (non stiff)
         {
             maxord = mxordn;
         }
-        case 2 : // lsode (stiff)
+        case 2: // lsode (stiff)
         {
             //          20 + nyh*(maxord + 1) + 3*neq + lmat
             //        where
@@ -853,25 +847,25 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
             iStructTabSize = 41;
             break;
         }
-        case 4 : // lsdisc (discrete)
+        case 4: // lsdisc (discrete)
         {
             rworkSize = *YSize;
             iworkSize = 1;
             break;
         }
-        case 5 : // lsrgk (rk)
+        case 5: // lsrgk (rk)
         {
             rworkSize = 9 * (*YSize);
             iworkSize = 1;
             break;
         }
-        case 6 : // rkf45 (rkf)
+        case 6: // rkf45 (rkf)
         {
             rworkSize = 3 + 8 * (*YSize);
             iworkSize = 5;
             break;
         }
-        case 7 : // rksimp (fix)
+        case 7: // rksimp (fix)
         {
             rworkSize = 3 + 8 * (*YSize);
             iworkSize = 1;
@@ -882,8 +876,8 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
     rwSize = rworkSize + dStructTabSize;
     iwSize = iworkSize + iStructTabSize;
 
-    rwork = (double*)malloc(rworkSize * sizeof(double));
-    iwork = (int*)malloc(iworkSize * sizeof(int));
+    rwork = (double*)MALLOC(rworkSize * sizeof(double));
+    iwork = (int*)MALLOC(iworkSize * sizeof(int));
 
     if (meth < 4)
     {
@@ -891,31 +885,31 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
         {
             if (pDblW->getSize() != rwSize || pDblIw->getSize() != iwSize)
             {
-                Scierror(9999, _("%s: Wrong size for w and iw : w = %d and iw = %d expected.\n"), "ode", rwSize, iwSize);
+                Scierror(9999, _("%s: Wrong size for w and iw: w = %d and iw = %d expected.\n"), "ode", rwSize, iwSize);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
-                free(rwork);
-                free(iwork);
+                FREE(pdYData);
+                FREE(YSize);
+                FREE(rwork);
+                FREE(iwork);
                 if (jroot)
                 {
-                    free(jroot);
+                    FREE(jroot);
                 }
                 if (itol == 1 || itol == 3)
                 {
-                    free(atol);
+                    FREE(atol);
                 }
                 if (itol < 3)
                 {
-                    free(rtol);
+                    FREE(rtol);
                 }
                 return types::Function::Error;
             }
 
             istate = 2; // 1 means this is the first call | 2  means this is not the first call
 
-            dStructTab = (double*)malloc(dStructTabSize * sizeof(double));
-            iStructTab = (int*)malloc(iStructTabSize * sizeof(int));
+            dStructTab = (double*)MALLOC(dStructTabSize * sizeof(double));
+            iStructTab = (int*)MALLOC(iStructTabSize * sizeof(int));
 
             C2F(dcopy)(&rworkSize, pDblW->get(), &one, rwork, &one);
             C2F(dcopy)(&dStructTabSize, pDblW->get() + rworkSize, &one, dStructTab, &one);
@@ -997,7 +991,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
     }
 
     // *** Perform operation. ***
-    double ret = 0;
+    int err = 0;
     double t0 = pDblT0->get(0);
     bool bOneStep = false;
 
@@ -1006,7 +1000,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
         bOneStep = true;
         if (getWarningMode() && pDblT->isScalar() == false)
         {
-            sciprint(_("itask = %d : At most one value of t is allowed, the last element of t is used.\n"), itask);
+            sciprint(_("itask = %d: At most one value of t is allowed, the last element of t is used.\n"), itask);
         }
     }
 
@@ -1020,84 +1014,100 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
 
         do
         {
-            char* strMeth;
-            switch (meth)
+            std::string strMeth;
+            try
             {
-                case 0 : // lsoda
-                {
-                    strMeth = "lsoda";
-                    ret = C2F(lsoda)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt);
-                    break;
-                }
-                case 1 : // lsode (adams)
-                case 2 : // lsode (stiff)
-                {
-                    strMeth = "lsode";
-                    int jacType = 10 * meth + jt;
-                    ret = C2F(lsode)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jacType);
-                    break;
-                }
-                case 3 : // lsodar
+                switch (meth)
                 {
-                    strMeth = "lsodar";
-                    int ng = (int)pDblNg->get(0);
-                    ret = C2F(lsodar)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt, ode_g, &ng, jroot);
-                    break;
-                }
-                case 4 : // lsdisc (discrete)
-                {
-                    strMeth = "lsdisc";
-                    ret = C2F(lsdisc)(ode_f, YSize, pdYData, &t0, &t, rwork, &rworkSize, &istate);
-                    break;
-                }
-                case 5 : // lsrgk (rk)
-                {
-                    strMeth = "lsrgk";
-                    ret = C2F(lsrgk)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
-                    break;
-                }
-                case 6 : // rkf45 (rkf)
-                {
-                    strMeth = "rkf45";
-                    ret = C2F(rkf45)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
-                    break;
+                    case 1: // lsode (adams)
+                    case 2: // lsode (stiff)
+                    {
+                        strMeth = "lsode";
+                        int jacType = 10 * meth + jt;
+                        C2F(lsode)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jacType);
+                        break;
+                    }
+                    case 3: // lsodar
+                    {
+                        strMeth = "lsodar";
+                        int ng = (int)pDblNg->get(0);
+                        C2F(lsodar)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt, ode_g, &ng, jroot);
+                        break;
+                    }
+                    case 4: // lsdisc (discrete)
+                    {
+                        strMeth = "lsdisc";
+                        C2F(lsdisc)(ode_f, YSize, pdYData, &t0, &t, rwork, &rworkSize, &istate);
+                        break;
+                    }
+                    case 5: // lsrgk (rk)
+                    {
+                        strMeth = "lsrgk";
+                        C2F(lsrgk)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
+                        break;
+                    }
+                    case 6: // rkf45 (rkf)
+                    {
+                        strMeth = "rkf45";
+                        C2F(rkf45)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
+                        break;
+                    }
+                    case 7: // rksimp (fix)
+                    {
+                        strMeth = "rksimp";
+                        C2F(rksimp)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
+                        break;
+                    }
+                    default: // case 0: // lsoda
+                    {
+                        strMeth = "lsoda";
+                        C2F(lsoda)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt);
+                    }
                 }
-                case 7 : // rksimp (fix)
+
+                // check error
+                err = checkOdeError(meth, istate);
+                if (err == 1)
                 {
-                    strMeth = "rksimp";
-                    ret = C2F(rksimp)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
-                    break;
+                    Scierror(999, _("%s: %s exit with state %d.\n"), "ode", strMeth.c_str(), istate);
                 }
             }
-            // check error
-            int err = checkOdeError(meth, istate);
+            catch (ScilabError &e)
+            {
+                char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+                sciprint(_("%s: exception caught in '%s' subroutine.\n"), "ode", strMeth.c_str());
+                Scierror(999, pstrMsg);
+                FREE(pstrMsg);
+                err = 1;
+            }
+
+            // FREE allocated data
             if (err == 1) // error case
             {
-                Scierror(999, _("%s: %s exit with state %d.\n"), "ode", strMeth, istate);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
-                free(rwork);
-                free(iwork);
+                FREE(pdYData);
+                FREE(YSize);
+                FREE(rwork);
+                FREE(iwork);
                 if (jroot)
                 {
-                    free(jroot);
+                    FREE(jroot);
                 }
                 if (dStructTab)
                 {
-                    free(dStructTab);
+                    FREE(dStructTab);
                 }
                 if (iStructTab)
                 {
-                    free(iStructTab);
+                    FREE(iStructTab);
                 }
                 if (itol == 1 || itol == 3)
                 {
-                    free(atol);
+                    FREE(atol);
                 }
                 if (itol < 3)
                 {
-                    free(rtol);
+                    FREE(rtol);
                 }
                 return types::Function::Error;
             }
@@ -1138,7 +1148,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                     // result format = [2 x iSizeList]
                     // first lime is the time of result stored in second line.
                     int size = 2 * iSizeList;
-                    int* iRanks = (int*)malloc(size * sizeof(int));
+                    int* iRanks = (int*)MALLOC(size * sizeof(int));
 
                     for(int i = 0; i < iSizeList; i++)
                     {
@@ -1152,7 +1162,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
 
                     for(int i = 0; i < iSizeList; i++)
                     {
-                        // pDblY0 contain pPolyY0 (ie : pPolyY0 = 2 + x => pDblY0 = [2 1])
+                        // pDblY0 contain pPolyY0 (ie: pPolyY0 = 2 + x => pDblY0 = [2 1])
                         for(int j = 0; j < pDblY0->getRows(); j++)
                         {
                             pDblYOut->set(j, pDblYOutList.front()[j]);
@@ -1188,7 +1198,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
         /*        if(pPolyY0)
                 {
                     int size = pDblT->getSize();
-                    int* iRanks = (int*)malloc(size * sizeof(int));
+                    int* iRanks = (int*)MALLOC(size * sizeof(int));
                     for(int i = 0; i < size; i++)
                     {
                         iRanks[i] = pPolyY0->getMaxRank();
@@ -1207,7 +1217,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
         for (int i = 0; i < pDblT->getSize(); i++)
         {
             double t = pDblT->get(i);
-            char* strMeth;
+            std::string strMeth;
 
             if (itask >= 4 && t > rwork[0]) // rwork[0] => tcrit
             {
@@ -1215,83 +1225,99 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                 bBreak = true;
             }
 
-            switch (meth)
+            try
             {
-                case 0 : // lsoda
-                {
-                    strMeth = "lsoda";
-                    ret = C2F(lsoda)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt);
-                    break;
-                }
-                case 1 : // lsode (adams)
-                case 2 : // lsode (stiff)
-                {
-                    strMeth = "lsode";
-                    int jacType = 10 * meth + jt;
-                    ret = C2F(lsode)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jacType);
-                    break;
-                }
-                case 3 : // lsodar
-                {
-                    strMeth = "lsodar";
-                    int ng = (int)pDblNg->get(0);
-                    ret = C2F(lsodar)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt, ode_g, &ng, jroot);
-                    break;
-                }
-                case 4 : // lsdisc (discrete)
+                switch (meth)
                 {
-                    strMeth = "lsdisc";
-                    ret = C2F(lsdisc)(ode_f, YSize, pdYData, &t0, &t, rwork, &rworkSize, &istate);
-                    break;
-                }
-                case 5 : // lsrgk (rk)
-                {
-                    strMeth = "lsrgk";
-                    ret = C2F(lsrgk)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
-                    break;
-                }
-                case 6 : // rkf45 (rkf)
-                {
-                    strMeth = "rkf45";
-                    ret = C2F(rkf45)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
-                    break;
+                    case 1: // lsode (adams)
+                    case 2: // lsode (stiff)
+                    {
+                        strMeth = "lsode";
+                        int jacType = 10 * meth + jt;
+                        C2F(lsode)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jacType);
+                        break;
+                    }
+                    case 3: // lsodar
+                    {
+                        strMeth = "lsodar";
+                        int ng = (int)pDblNg->get(0);
+                        C2F(lsodar)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt, ode_g, &ng, jroot);
+                        break;
+                    }
+                    case 4: // lsdisc (discrete)
+                    {
+                        strMeth = "lsdisc";
+                        C2F(lsdisc)(ode_f, YSize, pdYData, &t0, &t, rwork, &rworkSize, &istate);
+                        break;
+                    }
+                    case 5: // lsrgk (rk)
+                    {
+                        strMeth = "lsrgk";
+                        C2F(lsrgk)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
+                        break;
+                    }
+                    case 6: // rkf45 (rkf)
+                    {
+                        strMeth = "rkf45";
+                        C2F(rkf45)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
+                        break;
+                    }
+                    case 7: // rksimp (fix)
+                    {
+                        strMeth = "rksimp";
+                        C2F(rksimp)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
+                        break;
+                    }
+                    default: // case 0: // lsoda
+                    {
+                        strMeth = "lsoda";
+                        C2F(lsoda)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt);
+                    }
                 }
-                case 7 : // rksimp (fix)
+
+                // check error
+                err = checkOdeError(meth, istate);
+                if (err == 1)
                 {
-                    strMeth = "rksimp";
-                    ret = C2F(rksimp)(ode_f, YSize, pdYData, &t0, &t, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
-                    break;
+                    Scierror(999, _("%s: %s exit with state %d.\n"), "ode", strMeth.c_str(), istate);
                 }
             }
-            // check error
-            int err = checkOdeError(meth, istate);
+            catch (ScilabError &e)
+            {
+                char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+                sciprint(_("%s: exception caught in '%s' subroutine.\n"), "ode", strMeth.c_str());
+                Scierror(999, pstrMsg);
+                FREE(pstrMsg);
+                err = 1;
+            }
+
+            // FREE allocated data
             if (err == 1) // error case
             {
-                Scierror(999, _("%s: %s exit with state %d.\n"), "ode", strMeth, istate);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
-                free(rwork);
-                free(iwork);
+                FREE(pdYData);
+                FREE(YSize);
+                FREE(rwork);
+                FREE(iwork);
                 if (jroot)
                 {
-                    free(jroot);
+                    FREE(jroot);
                 }
                 if (dStructTab)
                 {
-                    free(dStructTab);
+                    FREE(dStructTab);
                 }
                 if (iStructTab)
                 {
-                    free(iStructTab);
+                    FREE(iStructTab);
                 }
                 if (itol == 1 || itol == 3)
                 {
-                    free(atol);
+                    FREE(atol);
                 }
                 if (itol < 3)
                 {
-                    free(rtol);
+                    FREE(rtol);
                 }
                 return types::Function::Error;
             }
@@ -1378,8 +1404,8 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
 
             if (dStructTab == NULL)
             {
-                dStructTab = (double*)malloc(dStructTabSize * sizeof(double));
-                iStructTab = (int*)malloc(iStructTabSize * sizeof(int));
+                dStructTab = (double*)MALLOC(dStructTabSize * sizeof(double));
+                iStructTab = (int*)MALLOC(iStructTabSize * sizeof(int));
             }
 
             C2F(dcopy)(&dSize, ls0001d, &one, dStructTab, &one);
@@ -1439,7 +1465,7 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
         }
 
         types::Double* pDblRd = new types::Double(1, sizeOfRd);
-        //rd : The first entry contains the stopping time.
+        //rd: The first entry contains the stopping time.
         pDblRd->set(0, C2F(lsr001).tlast);
         for (int i = 0; i < pDblNg->get(0); i++)
         {
@@ -1473,31 +1499,31 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
         out.push_back(pDblIwOut); // iw
     }
 
-    // *** free. ***
+    // *** FREE. ***
     if (itol == 1 || itol == 3) // atol is scalar
     {
-        free(atol);
+        FREE(atol);
     }
 
     if (itol < 3) // rtol is scalar
     {
-        free(rtol);
+        FREE(rtol);
     }
 
-    free(pdYData);
-    free(YSize);
-    free(rwork);
-    free(iwork);
+    FREE(pdYData);
+    FREE(YSize);
+    FREE(rwork);
+    FREE(iwork);
 
     if (jroot)
     {
-        free(jroot);
+        FREE(jroot);
     }
 
     if (dStructTab)
     {
-        free(dStructTab);
-        free(iStructTab);
+        FREE(dStructTab);
+        FREE(iStructTab);
     }
 
     DifferentialEquation::removeDifferentialEquationFunctions();
index 952ba62..e77e212 100644 (file)
@@ -131,7 +131,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
         }
         else
         {
-            Scierror(999, _("%s: Wrong value for input argument #%d : It must be one of the following strings : adams, stiff, rk, rkf, fix, root or discrete.\n"), "odedc", 1);
+            Scierror(999, _("%s: Wrong value for input argument #%d: It must be one of the following strings: adams, stiff, rk, rkf, fix, root or discrete.\n"), "odedc", 1);
             return types::Function::Error;
         }
     }
@@ -169,19 +169,19 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
         pDblY0 = in[iPos]->getAs<types::Double>();
         if (pDblY0->isComplex())
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "odedc", iPos + 1);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "odedc", iPos + 1);
             return types::Function::Error;
         }
 
         if (pDblY0->getCols() != 1)
         {
-            Scierror(999, _("%s: Wrong size for input argument #%d : A real colunm vector expected (n x 1).\n"), "odedc", iPos + 1);
+            Scierror(999, _("%s: Wrong size for input argument #%d: A real colunm vector expected (n x 1).\n"), "odedc", iPos + 1);
             return types::Function::Error;
         }
     }
     else
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix\n"), "odedc", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix\n"), "odedc", iPos + 1);
         return types::Function::Error;
     }
 
@@ -189,7 +189,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real scalar expected.\n"), "odedc", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real scalar expected.\n"), "odedc", iPos + 1);
         return types::Function::Error;
     }
 
@@ -197,13 +197,13 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
 
     if (pDblNd->isComplex() || pDblNd->isScalar() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real scalar expected.\n"), "odedc", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real scalar expected.\n"), "odedc", iPos + 1);
         return types::Function::Error;
     }
 
     if (pDblNd->get(0) > pDblY0->getSize())
     {
-        Scierror(999, _("%s: Wrong value for input argument #%d : Value must not exceeds dimension of argument %d.\n"), "odedc", iPos + 1, iPos);
+        Scierror(999, _("%s: Wrong value for input argument #%d: Value must not exceeds dimension of argument %d.\n"), "odedc", iPos + 1, iPos);
         return types::Function::Error;
     }
 
@@ -211,7 +211,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "odedc", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "odedc", iPos + 1);
         return types::Function::Error;
     }
 
@@ -219,13 +219,13 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
 
     if (pDblStdel->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real scalar expected.\n"), "odedc", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real scalar expected.\n"), "odedc", iPos + 1);
         return types::Function::Error;
     }
 
     if (pDblStdel->getSize() > 2)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : %d or %d values expected.\n"), "odedc", iPos + 1, 1, 2);
+        Scierror(999, _("%s: Wrong size for input argument #%d: %d or %d values expected.\n"), "odedc", iPos + 1, 1, 2);
         return types::Function::Error;
     }
 
@@ -233,7 +233,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "odedc", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "odedc", iPos + 1);
         return types::Function::Error;
     }
 
@@ -241,7 +241,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
 
     if (pDblT0->isScalar() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "odedc", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "odedc", iPos + 1);
         return types::Function::Error;
     }
 
@@ -249,7 +249,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "odedc", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "odedc", iPos + 1);
         return types::Function::Error;
     }
 
@@ -259,7 +259,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     sizeYc = pDblY0->getSize() - (int)pDblNd->get(0);
     if (sizeYc < 0)
     {
-        Scierror(999, _("%s: Wrong value for input argument #%d : Value of nd exceeds dimension of y0.\n"), "odedc", 2);
+        Scierror(999, _("%s: Wrong value for input argument #%d: Value of nd exceeds dimension of y0.\n"), "odedc", 2);
         return types::Function::Error;
     }
 
@@ -270,9 +270,9 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     deFunctionsManager->setOdeYRows(pDblY0->getRows());
     deFunctionsManager->setOdeYCols(pDblY0->getCols());
 
-    YSize = (int*)malloc(sizeOfYSize * sizeof(int));
+    YSize = (int*)MALLOC(sizeOfYSize * sizeof(int));
     *YSize = pDblY0->getSize();
-    pdYData = (double*)malloc(pDblY0->getSize() * sizeof(double));
+    pdYData = (double*)MALLOC(pDblY0->getSize() * sizeof(double));
     C2F(dcopy)(YSize, pDblY0->get(), &one, pdYData, &one);
 
     if (meth == 4)
@@ -281,17 +281,17 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
         {
             Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "odedc", 7);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYData);
-            free(YSize);
+            FREE(pdYData);
+            FREE(YSize);
             return types::Function::Error;
         }
 
         if (in[6]->isCallable() == false && in[6]->isString() == false && in[6]->isList() == false)
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A function expected.\n"), "odedc", 7);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A function expected.\n"), "odedc", 7);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYData);
-            free(YSize);
+            FREE(pdYData);
+            FREE(YSize);
             return types::Function::Error;
         }
     }
@@ -307,8 +307,8 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 {
                     Scierror(267, _("%s: Arg %d and arg %d must have equal dimensions.\n"), "odedc", pStrType ? 2 : 1, iPos + 1);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
@@ -319,8 +319,8 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 {
                     Scierror(267, _("%s: Arg %d and arg %d must have equal dimensions.\n"), "odedc", pStrType ? 2 : 1, iPos + 1);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
@@ -334,10 +334,10 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 {
                     if (in[iPos + 1]->isDouble() == false)
                     {
-                        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "odedc", iPos + 2);
+                        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "odedc", iPos + 2);
                         DifferentialEquation::removeDifferentialEquationFunctions();
-                        free(pdYData);
-                        free(YSize);
+                        FREE(pdYData);
+                        FREE(YSize);
                         return types::Function::Error;
                     }
 
@@ -349,17 +349,17 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 {
                     Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "odedc", iPos + 2);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A function expected.\n"), "odedc", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A function expected.\n"), "odedc", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -383,10 +383,10 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "odedc", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "odedc", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -412,10 +412,10 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "odedc", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "odedc", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
@@ -425,8 +425,8 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 Scierror(50, _("%s: Subroutine not found: %s\n"), "odedc", pst);
                 FREE(pst);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -436,19 +436,19 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
 
             if (pList->getSize() == 0)
             {
-                Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "odedc", iPos + 1, "(string empty)");
+                Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "odedc", iPos + 1, "(string empty)");
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
             if (bFuncF && (bFuncJac || pDblNg) && (bFuncG || meth != 3))
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "odedc", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "odedc", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
@@ -485,11 +485,11 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 if (bOK == false)
                 {
                     char* pst = wide_string_to_UTF8(pStr->get(0));
-                    Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "odedc", iPos + 1, pst);
+                    Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "odedc", iPos + 1, pst);
                     FREE(pst);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
 
@@ -497,7 +497,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 int* sizeTemp = YSize;
                 int totalSize = sizeOfpdYData;
 
-                YSize = (int*)malloc((sizeOfYSize + pList->getSize() - 1) * sizeof(int));
+                YSize = (int*)MALLOC((sizeOfYSize + pList->getSize() - 1) * sizeof(int));
                 memcpy(YSize, sizeTemp, sizeOfYSize * sizeof(int));
 
                 std::vector<types::Double*> vpDbl;
@@ -505,9 +505,9 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 {
                     if (pList->get(iter + 1)->isDouble() == false)
                     {
-                        Scierror(999, _("%s: Wrong type for input argument #%d : Argument %d in the list must be a matrix.\n"), "odedc", iPos + 1, iter + 1);
-                        free(pdYData);
-                        free(YSize);
+                        Scierror(999, _("%s: Wrong type for input argument #%d: Argument %d in the list must be a matrix.\n"), "odedc", iPos + 1, iter + 1);
+                        FREE(pdYData);
+                        FREE(YSize);
                         return types::Function::Error;
                     }
 
@@ -518,7 +518,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
 
                 // store in pdYData "args" input
                 double* pdYDataTemp = pdYData;
-                pdYData = (double*)malloc(totalSize * sizeof(double));
+                pdYData = (double*)MALLOC(totalSize * sizeof(double));
                 C2F(dcopy)(&sizeOfpdYData, pdYDataTemp, &one, pdYData, &one);
 
                 int position = sizeOfpdYData;
@@ -530,8 +530,8 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 vpDbl.clear();
                 sizeOfpdYData = totalSize;
                 sizeOfYSize += pList->getSize() - 1;
-                free(pdYDataTemp);
-                free(sizeTemp);
+                FREE(pdYDataTemp);
+                FREE(sizeTemp);
             }
             else if (pList->get(0)->isCallable())
             {
@@ -565,19 +565,19 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : The first argument in the list must be a string or a function.\n"), "odedc", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: The first argument in the list must be a string or a function.\n"), "odedc", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
         else
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a function expected.\n"), "odedc", iPos + 1);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a function expected.\n"), "odedc", iPos + 1);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYData);
-            free(YSize);
+            FREE(pdYData);
+            FREE(YSize);
             return types::Function::Error;
         }
     }
@@ -587,24 +587,24 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
         int val = (meth == 3) ? 3 : 1;
         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "odedc", in.size() + val);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYData);
-        free(YSize);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
     if (pDblNg == NULL && meth == 3)
     {
         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "odedc", in.size() + 2);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYData);
-        free(YSize);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
     if (bFuncG == false && meth == 3)
     {
         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "odedc", in.size() + 1);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYData);
-        free(YSize);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
@@ -676,19 +676,19 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
 
     if (iopt == 1 && (pDblOdeOptions->get(4) > pDblOdeOptions->get(3))) // hmin > hmax ?
     {
-        Scierror(9999, _("%s: Wrong value of hmin and hmax : hmin = %d is greater than hmax = %d.\n"), "odedc", pDblOdeOptions->get(4), pDblOdeOptions->get(3));
+        Scierror(9999, _("%s: Wrong value of hmin and hmax: hmin = %d is greater than hmax = %d.\n"), "odedc", pDblOdeOptions->get(4), pDblOdeOptions->get(3));
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYData);
-        free(YSize);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
     if (jt < 0 || jt > 5)
     {
-        Scierror(9999, _("%s: Wrong value of Jacobian type : A number between %d and %d expected.\n"), "odedc", 0, 5);
+        Scierror(9999, _("%s: Wrong value of Jacobian type: A number between %d and %d expected.\n"), "odedc", 0, 5);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYData);
-        free(YSize);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
@@ -720,7 +720,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     {
         if (pDblRtol->isScalar())
         {
-            rtol = (double*)malloc(sizeof(double));
+            rtol = (double*)MALLOC(sizeof(double));
             *rtol = pDblRtol->get(0);
         }
         else
@@ -731,7 +731,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     }
     else
     {
-        rtol = (double*)malloc(sizeof(double));
+        rtol = (double*)MALLOC(sizeof(double));
         if (meth == 6 || meth == 7)
         {
             *rtol = 1.e-3;
@@ -746,7 +746,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     {
         if (pDblAtol->isScalar())
         {
-            atol = (double*)malloc(sizeof(double));
+            atol = (double*)MALLOC(sizeof(double));
             *atol = pDblAtol->get(0);
         }
         else
@@ -757,7 +757,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     }
     else
     {
-        atol = (double*)malloc(sizeof(double));
+        atol = (double*)MALLOC(sizeof(double));
         if (meth == 6 || meth == 7)
         {
             *atol = 1.e-4;
@@ -802,7 +802,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
 
     switch (meth)
     {
-        case 3 : // lsodar (root)
+        case 3: // lsodar (root)
         {
             //             lrn = 20 + nyh*(mxordn+1) + 3*neq + 3*ng,
             //             lrs = 20 + nyh*(mxords+1) + 3*neq + lmat + 3*ng,
@@ -820,9 +820,9 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
             lrs = lrn;
             dStructTabSize = 246 - 241;
             iStructTabSize = 59 - 50;
-            jroot = (int*)malloc((int)pDblNg->get(0) * sizeof(int));
+            jroot = (int*)MALLOC((int)pDblNg->get(0) * sizeof(int));
         }
-        case 0 : // lsoda
+        case 0: // lsoda
         {
             //             lrn = 20 + nyh*(mxordn+1) + 3*neq,
             //             lrs = 20 + nyh*(mxords+1) + 3*neq + lmat,
@@ -857,11 +857,11 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
 
             break;
         }
-        case 1 : // lsode (adams) (non stiff)
+        case 1: // lsode (adams) (non stiff)
         {
             maxord = mxordn;
         }
-        case 2 : // lsode (stiff)
+        case 2: // lsode (stiff)
         {
             //          20 + nyh*(maxord + 1) + 3*neq + lmat
             //        where
@@ -897,25 +897,25 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
             iStructTabSize = 41;
             break;
         }
-        case 4 : // lsdisc (discrete)
+        case 4: // lsdisc (discrete)
         {
             rworkSize = sizeYc;
             iworkSize = 1;
             break;
         }
-        case 5 : // lsrgk (rk)
+        case 5: // lsrgk (rk)
         {
             rworkSize = 3 * (sizeYc);
             iworkSize = 1;
             break;
         }
-        case 6 : // rkf45 (rkf)
+        case 6: // rkf45 (rkf)
         {
             rworkSize = 3 + 8 * (sizeYc);
             iworkSize = 5;
             break;
         }
-        case 7 : // rksimp (fix)
+        case 7: // rksimp (fix)
         {
             rworkSize = 3 + 8 * (sizeYc);
             iworkSize = 1;
@@ -926,8 +926,8 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     rwSize = rworkSize + dStructTabSize;
     iwSize = iworkSize + iStructTabSize;
 
-    rwork = (double*)malloc(rworkSize * sizeof(double));
-    iwork = (int*)malloc(iworkSize * sizeof(int));
+    rwork = (double*)MALLOC(rworkSize * sizeof(double));
+    iwork = (int*)MALLOC(iworkSize * sizeof(int));
 
     if (meth < 4)
     {
@@ -935,29 +935,29 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
         {
             if (pDblW->getSize() != rwSize || pDblIw->getSize() != iwSize)
             {
-                Scierror(9999, _("%s: Wrong size for w and iw : w = %d and iw = %d expected.\n"), "odedc", rwSize, iwSize);
+                Scierror(9999, _("%s: Wrong size for w and iw: w = %d and iw = %d expected.\n"), "odedc", rwSize, iwSize);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 if (jroot)
                 {
-                    free(jroot);
+                    FREE(jroot);
                 }
                 if (itol == 1 || itol == 3)
                 {
-                    free(atol);
+                    FREE(atol);
                 }
                 if (itol < 3)
                 {
-                    free(rtol);
+                    FREE(rtol);
                 }
                 return types::Function::Error;
             }
 
             istate = 2; // 1 means this is the first call | 2  means this is not the first call
 
-            dStructTab = (double*)malloc(dStructTabSize * sizeof(double));
-            iStructTab = (int*)malloc(iStructTabSize * sizeof(int));
+            dStructTab = (double*)MALLOC(dStructTabSize * sizeof(double));
+            iStructTab = (int*)MALLOC(iStructTabSize * sizeof(int));
 
             C2F(dcopy)(&rworkSize, pDblW->get(), &one, rwork, &one);
             C2F(dcopy)(&dStructTabSize, pDblW->get() + rworkSize, &one, dStructTab, &one);
@@ -1040,7 +1040,6 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     }
 
     // *** Perform operation. ***
-    double ret      = 0;
     double nhpass   = 0;
     double delta    = 0;
     double tleft    = pDblT0->get(0);
@@ -1052,7 +1051,8 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     bool bUpdate    = false;
     bool bOneStep   = false;
 
-    char* strMeth;
+    std::string strMeth;
+    int err = 0;
 
     if (pDblStdel->isScalar() == false)
     {
@@ -1064,7 +1064,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
         bOneStep = true;
         if (getWarningMode() && pDblT->isScalar() == false)
         {
-            sciprint(_("itask = %d : At most one value of t is allowed, the last element of t is used.\n"), itask);
+            sciprint(_("itask = %d: At most one value of t is allowed, the last element of t is used.\n"), itask);
         }
     }
 
@@ -1091,32 +1091,38 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 {
                     sciprint(_("update at t = %lf\n"), tright);
                 }
-
-                if (ode_f(&sizeYc, &tright, pdYData, pdYData + sizeYc) == 0)
+                try
+                {
+                    ode_f(&sizeYc, &tright, pdYData, pdYData + sizeYc);
+                }
+                catch (ScilabError &e)
                 {
-                    Scierror(999, _("%s: Update failed at t = %lf\n"), "odedc", tright);
+                    char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+                    sciprint(_("%s: Update failed at t = %lf\n"), "odedc", tright);
+                    Scierror(999, pstrMsg);
+
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYData);
+                    FREE(YSize);
                     if (jroot)
                     {
-                        free(jroot);
+                        FREE(jroot);
                     }
                     if (dStructTab)
                     {
-                        free(dStructTab);
+                        FREE(dStructTab);
                     }
                     if (iStructTab)
                     {
-                        free(iStructTab);
+                        FREE(iStructTab);
                     }
                     if (itol == 1 || itol == 3)
                     {
-                        free(atol);
+                        FREE(atol);
                     }
                     if (itol < 3)
                     {
-                        free(rtol);
+                        FREE(rtol);
                     }
                     return types::Function::Error;
                 }
@@ -1124,7 +1130,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 deFunctionsManager->resetOdedcFlag();
                 nhpass++;
 
-                double* copy = (double*)malloc(*YSize * sizeof(double));
+                double* copy = (double*)MALLOC(*YSize * sizeof(double));
                 C2F(dcopy)(YSize, pdYData, &one, copy, &one);
                 pDblYOutList.push_back(copy);
                 pDblTOutList.push_back(tleft);
@@ -1140,81 +1146,96 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                     sciprint(_("integ. from tleft= %lf to tf= %lf\n"), tleft, tright);
                 }
 
-                switch (meth)
+                try
                 {
-                    case 0 : // lsoda
-                    {
-                        strMeth = "lsoda";
-                        ret = C2F(lsoda)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt);
-                        break;
-                    }
-                    case 1 : // lsode (adams)
-                    case 2 : // lsode (stiff)
-                    {
-                        strMeth = "lsode";
-                        int jacType = 10 * meth + jt;
-                        ret = C2F(lsode)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jacType);
-                        break;
-                    }
-                    case 3 : // lsodar
-                    {
-                        strMeth = "lsodar";
-                        int ng = (int)pDblNg->get(0);
-                        ret = C2F(lsodar)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt, ode_g, &ng, jroot);
-                        break;
-                    }
-                    case 4 : // lsdisc (discrete)
-                    {
-                        strMeth = "lsdisc";
-                        ret = C2F(lsdisc)(ode_f, &sizeYc, pdYData, &tleft, &tright, rwork, &rworkSize, &istate);
-                        break;
-                    }
-                    case 5 : // lsrgk (rk)
+                    switch (meth)
                     {
-                        strMeth = "lsrgk";
-                        ret = C2F(lsrgk)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
-                        break;
-                    }
-                    case 6 : // rkf45 (rkf)
-                    {
-                        strMeth = "rkf45";
-                        ret = C2F(rkf45)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
-                        break;
+                        case 1: // lsode (adams)
+                        case 2: // lsode (stiff)
+                        {
+                            strMeth = "lsode";
+                            int jacType = 10 * meth + jt;
+                            C2F(lsode)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jacType);
+                            break;
+                        }
+                        case 3: // lsodar
+                        {
+                            strMeth = "lsodar";
+                            int ng = (int)pDblNg->get(0);
+                            C2F(lsodar)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt, ode_g, &ng, jroot);
+                            break;
+                        }
+                        case 4: // lsdisc (discrete)
+                        {
+                            strMeth = "lsdisc";
+                            C2F(lsdisc)(ode_f, &sizeYc, pdYData, &tleft, &tright, rwork, &rworkSize, &istate);
+                            break;
+                        }
+                        case 5: // lsrgk (rk)
+                        {
+                            strMeth = "lsrgk";
+                            C2F(lsrgk)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
+                            break;
+                        }
+                        case 6: // rkf45 (rkf)
+                        {
+                            strMeth = "rkf45";
+                            C2F(rkf45)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
+                            break;
+                        }
+                        case 7: // rksimp (fix)
+                        {
+                            strMeth = "rksimp";
+                            C2F(rksimp)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
+                            break;
+                        }
+                        default: // case 0: // lsoda
+                        {
+                            strMeth = "lsoda";
+                            C2F(lsoda)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt);
+                        }
                     }
-                    case 7 : // rksimp (fix)
+
+                    // check error
+                    err = checkOdeError(meth, istate);
+                    if (err == 1) // error case
                     {
-                        strMeth = "rksimp";
-                        ret = C2F(rksimp)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
-                        break;
+                        Scierror(999, _("%s: %s exit with state %d.\n"), "odedc", strMeth.c_str(), istate);
                     }
                 }
-                // check error
-                int err = checkOdeError(meth, istate);
+                catch (ScilabError &e)
+                {
+                    char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+                    sciprint(_("%s: exception caught in '%s' subroutine.\n"), "odedc", strMeth.c_str());
+                    Scierror(999, pstrMsg);
+                    FREE(pstrMsg);
+                    err = 1;
+                }
+
                 if (err == 1) // error case
                 {
-                    Scierror(999, _("%s: %s exit with state %d.\n"), "odedc", strMeth, istate);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYData);
+                    FREE(YSize);
                     if (jroot)
                     {
-                        free(jroot);
+                        FREE(jroot);
                     }
                     if (dStructTab)
                     {
-                        free(dStructTab);
+                        FREE(dStructTab);
                     }
                     if (iStructTab)
                     {
-                        free(iStructTab);
+                        FREE(iStructTab);
                     }
                     if (itol == 1 || itol == 3)
                     {
-                        free(atol);
+                        FREE(atol);
                     }
                     if (itol < 3)
                     {
-                        free(rtol);
+                        FREE(rtol);
                     }
                     return types::Function::Error;
                 }
@@ -1228,7 +1249,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                     break;
                 }
 
-                double* copy = (double*)malloc(*YSize * sizeof(double));
+                double* copy = (double*)MALLOC(*YSize * sizeof(double));
                 C2F(dcopy)(YSize, pdYData, &one, copy, &one);
                 pDblYOutList.push_back(copy);
                 pDblTOutList.push_back(tleft);
@@ -1312,81 +1333,97 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
             }
 
             rwork[0] = hf; // tcrit = hf
-            switch (meth)
+            try
             {
-                case 0 : // lsoda
-                {
-                    strMeth = "lsoda";
-                    ret = C2F(lsoda)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt);
-                    break;
-                }
-                case 1 : // lsode (adams)
-                case 2 : // lsode (stiff)
-                {
-                    strMeth = "lsode";
-                    int jacType = 10 * meth + jt;
-                    ret = C2F(lsode)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jacType);
-                    break;
-                }
-                case 3 : // lsodar
-                {
-                    strMeth = "lsodar";
-                    int ng = (int)pDblNg->get(0);
-                    ret = C2F(lsodar)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt, ode_g, &ng, jroot);
-                    break;
-                }
-                case 4 : // lsdisc (discrete)
-                {
-                    strMeth = "lsdisc";
-                    ret = C2F(lsdisc)(ode_f, &sizeYc, pdYData, &tleft, &tright, rwork, &rworkSize, &istate);
-                    break;
-                }
-                case 5 : // lsrgk (rk)
-                {
-                    strMeth = "lsrgk";
-                    ret = C2F(lsrgk)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
-                    break;
-                }
-                case 6 : // rkf45 (rkf)
+                switch (meth)
                 {
-                    strMeth = "rkf45";
-                    ret = C2F(rkf45)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
-                    break;
+                    case 1: // lsode (adams)
+                    case 2: // lsode (stiff)
+                    {
+                        strMeth = "lsode";
+                        int jacType = 10 * meth + jt;
+                        C2F(lsode)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jacType);
+                        break;
+                    }
+                    case 3: // lsodar
+                    {
+                        strMeth = "lsodar";
+                        int ng = (int)pDblNg->get(0);
+                        C2F(lsodar)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt, ode_g, &ng, jroot);
+                        break;
+                    }
+                    case 4: // lsdisc (discrete)
+                    {
+                        strMeth = "lsdisc";
+                        C2F(lsdisc)(ode_f, &sizeYc, pdYData, &tleft, &tright, rwork, &rworkSize, &istate);
+                        break;
+                    }
+                    case 5: // lsrgk (rk)
+                    {
+                        strMeth = "lsrgk";
+                        C2F(lsrgk)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
+                        break;
+                    }
+                    case 6: // rkf45 (rkf)
+                    {
+                        strMeth = "rkf45";
+                        C2F(rkf45)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
+                        break;
+                    }
+                    case 7: // rksimp (fix)
+                    {
+                        strMeth = "rksimp";
+                        C2F(rksimp)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
+                        break;
+                    }
+                    default: // case 0: // lsoda
+                    {
+                        strMeth = "lsoda";
+                        C2F(lsoda)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &jt);
+                        break;
+                    }
                 }
-                case 7 : // rksimp (fix)
+
+                // check error
+                err = checkOdeError(meth, istate);
+                if (err == 1) // error case
                 {
-                    strMeth = "rksimp";
-                    ret = C2F(rksimp)(ode_f, &sizeYc, pdYData, &tleft, &tright, &itol, rtol, atol, &itask, &istate, &iopt, rwork, &rworkSize, iwork, &iworkSize, bFuncJac ? ode_jac : NULL, &meth);
-                    break;
+                    Scierror(999, _("%s: %s exit with state %d.\n"), "odedc", strMeth.c_str(), istate);
                 }
             }
-            // check error
-            int err = checkOdeError(meth, istate);
+            catch (ScilabError &e)
+            {
+                char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+                sciprint(_("%s: exception caught in '%s' subroutine.\n"), "odedc", strMeth.c_str());
+                Scierror(999, pstrMsg);
+                FREE(pstrMsg);
+                err = 1;
+            }
+
             if (err == 1) // error case
             {
-                Scierror(999, _("%s: %s exit with state %d.\n"), "odedc", strMeth, istate);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYData);
-                free(YSize);
+                FREE(pdYData);
+                FREE(YSize);
                 if (jroot)
                 {
-                    free(jroot);
+                    FREE(jroot);
                 }
                 if (dStructTab)
                 {
-                    free(dStructTab);
+                    FREE(dStructTab);
                 }
                 if (iStructTab)
                 {
-                    free(iStructTab);
+                    FREE(iStructTab);
                 }
                 if (itol == 1 || itol == 3)
                 {
-                    free(atol);
+                    FREE(atol);
                 }
                 if (itol < 3)
                 {
-                    free(rtol);
+                    FREE(rtol);
                 }
                 return types::Function::Error;
             }
@@ -1400,31 +1437,37 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                     sciprint(_("update at t = %lf\n"), tright);
                 }
 
-                if (ode_f(&sizeYc, &tright, pdYData, pdYData + sizeYc) == 0)
+                try
+                {
+                    ode_f(&sizeYc, &tright, pdYData, pdYData + sizeYc);
+                }
+                catch (ScilabError &e)
                 {
-                    Scierror(999, _("%s: Update failed at t = %lf\n"), "odedc", tright);
+                    char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
+                    sciprint(_("%s: Update failed at t = %lf\n"), "odedc", tright);
+                    Scierror(999, pstrMsg);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYData);
+                    FREE(YSize);
                     if (jroot)
                     {
-                        free(jroot);
+                        FREE(jroot);
                     }
                     if (dStructTab)
                     {
-                        free(dStructTab);
+                        FREE(dStructTab);
                     }
                     if (iStructTab)
                     {
-                        free(iStructTab);
+                        FREE(iStructTab);
                     }
                     if (itol == 1 || itol == 3)
                     {
-                        free(atol);
+                        FREE(atol);
                     }
                     if (itol < 3)
                     {
-                        free(rtol);
+                        FREE(rtol);
                     }
                     return types::Function::Error;
                 }
@@ -1497,8 +1540,8 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
 
             if (dStructTab == NULL)
             {
-                dStructTab = (double*)malloc(dStructTabSize * sizeof(double));
-                iStructTab = (int*)malloc(iStructTabSize * sizeof(int));
+                dStructTab = (double*)MALLOC(dStructTabSize * sizeof(double));
+                iStructTab = (int*)MALLOC(iStructTabSize * sizeof(int));
             }
 
             C2F(dcopy)(&dSize, ls0001d, &one, dStructTab, &one);
@@ -1550,7 +1593,7 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
         }
 
         types::Double* pDblRd = new types::Double(1, sizeOfRd);
-        //rd : The first entry contains the stopping time.
+        //rd: The first entry contains the stopping time.
         pDblRd->set(0, C2F(lsr001).tlast);
         for (int i = 0; i < pDblNg->get(0); i++)
         {
@@ -1584,31 +1627,31 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
         out.push_back(pDblIwOut); // iw
     }
 
-    // *** free. ***
+    // *** FREE. ***
     if (itol == 1 || itol == 3) // atol is scalar
     {
-        free(atol);
+        FREE(atol);
     }
 
     if (itol < 3) // rtol is scalar
     {
-        free(rtol);
+        FREE(rtol);
     }
 
-    free(pdYData);
-    free(YSize);
-    free(rwork);
-    free(iwork);
+    FREE(pdYData);
+    FREE(YSize);
+    FREE(rwork);
+    FREE(iwork);
 
     if (jroot)
     {
-        free(jroot);
+        FREE(jroot);
     }
 
     if (dStructTab)
     {
-        free(dStructTab);
-        free(iStructTab);
+        FREE(dStructTab);
+        FREE(iStructTab);
     }
 
     DifferentialEquation::removeDifferentialEquationFunctions();
index e687248..e44c503 100644 (file)
     <ClCompile Include="cpp\sci_odedc.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\ast\ast-tools\ast-tools.vcxproj">
+      <Project>{1f4a0344-99ed-461b-bd53-1593788fb34d}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\console\src\c\console.vcxproj">
       <Project>{445d3b85-c9b1-498b-9c88-0a3c2390b1cc}</Project>
     </ProjectReference>