differential_equations error management. 50/16050/5
Cedric Delamarre [Thu, 26 Feb 2015 16:30:02 +0000 (17:30 +0100)]
test_run differential_equations bug_2396
test_run differential_equations bug_13512

Change-Id: I55f7c929cfbe2c92b837cf38f46d555d6527209a

17 files changed:
scilab/modules/ast/src/cpp/ast/run_CallExp.hpp
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_ode.cpp
scilab/modules/differential_equations/sci_gateway/cpp/sci_odedc.cpp
scilab/modules/differential_equations/src/cpp/differentialequationfunctions.cpp
scilab/modules/differential_equations/tests/nonreg_tests/bug_13512.dia.ref
scilab/modules/differential_equations/tests/nonreg_tests/bug_13512.tst
scilab/modules/differential_equations/tests/nonreg_tests/bug_2396.dia.ref
scilab/modules/differential_equations/tests/nonreg_tests/bug_2396.tst

index bcd7d71..a2559b9 100644 (file)
@@ -243,6 +243,22 @@ void RunVisitorT<T>::visitprivate(const CallExp &e)
             cleanOpt(opt);
             pIT->killMe();
 
+            if (pIT->isCallable())
+            {
+                Callable *pCall = pIT->getAs<Callable>();
+                if (ConfigVariable::getLastErrorFunction() == L"")
+                {
+                    ConfigVariable::setLastErrorFunction(pCall->getName());
+                }
+
+                if (pCall->isMacro() || pCall->isMacroFile())
+                {
+                    wchar_t szError[bsiz];
+                    os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), sm.GetErrorLocation().first_line, pCall->getName().c_str());
+                    throw ScilabMessage(szError);
+                }
+            }
+
             throw sm;
         }
         catch (InternalAbort & ia)
index f674013..1bcd887 100644 (file)
@@ -50,6 +50,10 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     int iflag       = 0;
     int ipar[11];
 
+    // error message catched
+    std::wostringstream os;
+    bool bCatch = false;
+
     // *** check the minimal number of input args. ***
     if (in.size() != 15)
     {
@@ -553,19 +557,29 @@ types::Function::ReturnValue sci_bvode(types::typed_list &in, int _iRetCount, ty
     {
         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);
     }
+    catch (ast::ScilabMessage &sm)
+    {
+        os << sm.GetErrorMessage();
+        bCatch = true;
+    }
     catch (ast::ScilabError &e)
     {
-        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);
+        os << e.GetErrorMessage();
+        bCatch = true;
+    }
+
+    if (bCatch)
+    {
         FREE(iwork);
         FREE(rwork);
         FREE(M);
         FREE(ltol);
         DifferentialEquation::removeDifferentialEquationFunctions();
 
-        return types::Function::Error;
+        wchar_t szError[bsiz];
+        os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "bvode", "bvode");
+        os << szError;
+        throw ast::ScilabMessage(os.str());
     }
 
     if (iflag != 1)
index 4ef2f0b..2a6fac9 100644 (file)
@@ -97,6 +97,10 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
     // Indicate if info list is given.
     bool bListInfo  = false;
 
+    // error message catched
+    std::wostringstream os;
+    bool bCatch = false;
+
     // *** check the minimal number of input args. ***
     if ((int)in.size() < 6 || (int)in.size() > 13)
     {
@@ -593,8 +597,14 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
 
                 //  --   subvariable consistent(info) --
                 pDblTemp = pList->get(6)->getAs<types::Double>();
-                if (pDblTemp->getSize() != 0)
+                if (pDblTemp->isEmpty() || (pDblTemp->isScalar() && pDblTemp->get(0) == 0))
                 {
+                    // info(11) is then [] or [0]
+                    info[10] = 0;
+                }
+                else
+                {
+                    //info then looks like list(..., [+-1 +-1 ... +-1 +-1],...)
                     info[10] = 1;
                     if (info[9] == 0 || info[9] == 2)
                     {
@@ -1019,6 +1029,7 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
             // 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,
@@ -1049,15 +1060,19 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
             iret = checkError(idid, "daskr");
             if (iret == 1) // error
             {
-                Scierror(999, _("%s: ddaskr return with state %d.\n"), "daskr", ididtmp);
+                Scierror(999, _("%s: %s return with state %d.\n"), "daskr", "ddaskr", ididtmp);
             }
         }
+        catch (ast::ScilabMessage &sm)
+        {
+            os << sm.GetErrorMessage();
+            bCatch = true;
+            iret = 1;
+        }
         catch (ast::ScilabError &e)
         {
-            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
+            os << e.GetErrorMessage();
+            bCatch = true;
             iret = 1;
         }
 
@@ -1080,6 +1095,15 @@ types::Function::ReturnValue sci_daskr(types::typed_list &in, int _iRetCount, ty
             {
                 FREE(rtol);
             }
+
+            if (bCatch)
+            {
+                wchar_t szError[bsiz];
+                os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "daskr", "ddaskr");
+                os << szError;
+                throw ast::ScilabMessage(os.str());
+            }
+
             return types::Function::Error;
         }
 
index d33b2f2..d24a36f 100644 (file)
@@ -71,6 +71,10 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
     // Indicate if info list is given.
     bool bListInfo  = false;
 
+    // error message catched
+    std::wostringstream os;
+    bool bCatch = false;
+
     // *** check the minimal number of input args. ***
     if (in.size() < 6 || in.size() > 11)
     {
@@ -747,15 +751,19 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
             iret = checkError(idid, "dasrt");
             if (iret == 1) // error
             {
-                Scierror(999, _("%s: ddasrt return with state %d.\n"), "dasrt", idid);
+                Scierror(999, _("%s: %s return with state %d.\n"), "dasrt", "ddasrt", idid);
             }
         }
+        catch (ast::ScilabMessage &sm)
+        {
+            os << sm.GetErrorMessage();
+            bCatch = true;
+            iret = 1;
+        }
         catch (ast::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);
+            os << e.GetErrorMessage();
+            bCatch = true;
             iret = 1;
         }
 
@@ -777,6 +785,15 @@ types::Function::ReturnValue sci_dasrt(types::typed_list &in, int _iRetCount, ty
             {
                 FREE(rtol);
             }
+
+            if (bCatch)
+            {
+                wchar_t szError[bsiz];
+                os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "dasrt", "ddasrt");
+                os << szError;
+                throw ast::ScilabMessage(os.str());
+            }
+
             return types::Function::Error;
         }
 
index 5e1c103..cccbbc9 100644 (file)
@@ -70,6 +70,10 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     // Indicate if info list is given.
     bool bListInfo  = false;
 
+    // error message catched
+    std::wostringstream os;
+    bool bCatched = false;
+
     // *** check the minimal number of input args. ***
     if (in.size() < 4 || in.size() > 9)
     {
@@ -683,15 +687,19 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
             iret = checkError(idid, "dassl");
             if (iret == 1) // error
             {
-                Scierror(999, _("%s: dassl return with state %d.\n"), "dassl", idid);
+                Scierror(999, _("%s: %s return with state %d.\n"), "dassl", "dassl",  idid);
             }
         }
+        catch (ast::ScilabMessage &sm)
+        {
+            os << sm.GetErrorMessage();
+            bCatched = true;
+            iret = 1;
+        }
         catch (ast::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
+            os << e.GetErrorMessage();
+            bCatched = true;
             iret = 1;
         }
 
@@ -712,6 +720,15 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
             {
                 FREE(rtol);
             }
+
+            if (bCatched)
+            {
+                wchar_t szError[bsiz];
+                os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "dassl", "dassl");
+                os << szError;
+                throw ast::ScilabMessage(os.str());
+            }
+
             return types::Function::Error;
         }
 
index ab45219..3064e97 100644 (file)
@@ -34,6 +34,7 @@ types::Function::ReturnValue sci_feval(types::typed_list &in, int _iRetCount, ty
 {
     int iPos = 0;
     int nn   = 1;
+    int iErr = 0;
 
     //input
     types::Double* pDblX = NULL;
@@ -42,6 +43,10 @@ types::Function::ReturnValue sci_feval(types::typed_list &in, int _iRetCount, ty
     // output
     types::Double* pDblOut = NULL;
 
+    // error message catched
+    std::wostringstream os;
+    bool bCatch = false;
+
     // *** check the minimal number of input args. ***
     if (in.size() < 2 || in.size() > 3)
     {
@@ -172,15 +177,27 @@ types::Function::ReturnValue sci_feval(types::typed_list &in, int _iRetCount, ty
             {
                 deFunctionsManager->execFevalF(&nn, &valX, &valY, res, &itype);
             }
+            catch (ast::ScilabMessage &sm)
+            {
+                os << sm.GetErrorMessage();
+                bCatch = true;
+            }
             catch (ast::ScilabError &e)
             {
-                char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
-                sciprint(_("%s: exception caught in '%s' subroutine.\n"), "feval", "execFevalF");
-                Scierror(999, pstrMsg);
+                os << e.GetErrorMessage();
+                bCatch = true;
+            }
+
+            if (bCatch)
+            {
                 DifferentialEquation::removeDifferentialEquationFunctions();
                 FREE(res);
                 delete pDblOut;
-                return types::Function::Error;
+
+                wchar_t szError[bsiz];
+                os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "feval", "execFevalF");
+                os << szError;
+                throw ast::ScilabMessage(os.str());
             }
 
             if (itype) // is complex
index 78ebdce..c398eb6 100644 (file)
@@ -75,6 +75,10 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
 
     int one = 1; // use in dcopy
 
+    // error message catched
+    std::wostringstream os;
+    bool bCatch = false;
+
     // *** check the minimal number of input args. ***
     if (in.size() < 6 || in.size() > 12)
     {
@@ -653,12 +657,16 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
                 }
             }
         }
+        catch (ast::ScilabMessage &sm)
+        {
+            os << sm.GetErrorMessage();
+            bCatch = true;
+            err = 1;
+        }
         catch (ast::ScilabError &e)
         {
-            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);
+            os << e.GetErrorMessage();
+            bCatch = true;
             err = 1;
         }
 
@@ -681,6 +689,15 @@ types::Function::ReturnValue sci_impl(types::typed_list &in, int _iRetCount, typ
             {
                 free(rtol);
             }
+
+            if (bCatch)
+            {
+                wchar_t szError[bsiz];
+                os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "impl", "lsodi");
+                os << szError;
+                throw ast::ScilabMessage(os.str());
+            }
+
             return types::Function::Error;
         }
 
index dc6cdc3..8364076 100644 (file)
@@ -50,6 +50,10 @@ types::Function::ReturnValue sci_int2d(types::typed_list &in, int _iRetCount, ty
     int nu          = 0;
     int nd          = 0;
 
+    // error message catched
+    std::wostringstream os;
+    bool bCatch = false;
+
     // *** check the minimal number of input args. ***
     if (in.size() < 3 || in.size() > 4)
     {
@@ -238,21 +242,29 @@ types::Function::ReturnValue sci_int2d(types::typed_list &in, int _iRetCount, ty
     {
         C2F(twodq)(int2d_f, &size, pDblX->get(), pDblY->get(), &tol, &iclose, &maxtri, &mevals, &result, &err, &nu, &nd, &nevals, &iflag, dwork, iwork);
     }
+    catch (ast::ScilabMessage &sm)
+    {
+        os << sm.GetErrorMessage();
+        bCatch = false;
+    }
     catch (ast::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;
+        os << e.GetErrorMessage();
+        bCatch = false;
     }
 
     FREE(dwork);
     FREE(iwork);
     DifferentialEquation::removeDifferentialEquationFunctions();
 
+    if (bCatch)
+    {
+        wchar_t szError[bsiz];
+        os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "int2d", "twodq");
+        os << szError;
+        throw ast::ScilabMessage(os.str());
+    }
+
     if (iflag)
     {
         switch (iflag)
index 77e6859..314e8ad 100644 (file)
@@ -49,6 +49,10 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
     int ifail = 0;
     int nevals = 0;
 
+    // error message catched
+    std::wostringstream os;
+    bool bCatch = false;
+
     // *** check the minimal number of input args. ***
     if (in.size() < 4 || in.size() > 6)
     {
@@ -315,23 +319,31 @@ types::Function::ReturnValue sci_int3d(types::typed_list &in, int _iRetCount, ty
     {
         C2F(dcutet)(int3d_f, &nf, pdData, &cols, &minpts, &maxpts, &epsabs, &epsrel, &maxsub, &dworkSize, &irestar, pdResult, pdErr, &nevals, &ifail, dwork, iwork);
     }
+    catch (ast::ScilabMessage &sm)
+    {
+        os << sm.GetErrorMessage();
+        bCatch = true;
+    }
     catch (ast::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;
+        os << e.GetErrorMessage();
+        bCatch = true;
     }
 
+
     FREE(pdData);
     FREE(dwork);
     FREE(iwork);
     DifferentialEquation::removeDifferentialEquationFunctions();
 
+    if (bCatch)
+    {
+        wchar_t szError[bsiz];
+        os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "int3d", "dcutet");
+        os << szError;
+        throw ast::ScilabMessage(os.str());
+    }
+
     if (ifail)
     {
         if (ifail == 1)
index c2fb4f7..97cbfee 100644 (file)
@@ -45,6 +45,10 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
 
     int iOne = 1;
 
+    // error message catched
+    std::wostringstream os;
+    bool bCatch = false;
+
     // *** check the minimal number of input args. ***
     if (in.size() < 3 || in.size() > 5)
     {
@@ -234,21 +238,29 @@ types::Function::ReturnValue sci_intg(types::typed_list &in, int _iRetCount, typ
                    &result, &abserr, &neval, &ier,
                    &limit, &lenw, &last, iwork, dwork);
     }
+    catch (ast::ScilabMessage &sm)
+    {
+        os << sm.GetErrorMessage();
+        bCatch = true;
+    }
     catch (ast::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;
+        os << e.GetErrorMessage();
+        bCatch = true;
     }
 
     FREE(dwork);
     FREE(iwork);
     DifferentialEquation::removeDifferentialEquationFunctions();
 
+    if (bCatch)
+    {
+        wchar_t szError[bsiz];
+        os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "intg", "dqags");
+        os << szError;
+        throw ast::ScilabMessage(os.str());
+    }
+
     if (ier)
     {
         char* msg = NULL;
index bf35d2a..ce0fa27 100644 (file)
@@ -85,6 +85,10 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
     // For root methode
     int* jroot = NULL;
 
+    // error message catched
+    std::wostringstream os;
+    bool bCatch = false;
+
     // *** check the minimal number of input args. ***
     if (in.size() < 4)
     {
@@ -1095,13 +1099,15 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                     Scierror(999, _("%s: %s exit with state %d.\n"), "ode", strMeth.c_str(), istate);
                 }
             }
+            catch (ast::ScilabMessage &sm)
+            {
+                os << sm.GetErrorMessage();
+                bCatch = true;
+            }
             catch (ast::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;
+                os << e.GetErrorMessage();
+                bCatch = true;
             }
 
             // FREE allocated data
@@ -1132,6 +1138,15 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                 {
                     FREE(rtol);
                 }
+
+                if (bCatch)
+                {
+                    wchar_t szError[bsiz];
+                    os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "ode", strMeth.c_str());
+                    os << szError;
+                    throw ast::ScilabMessage(os.str());
+                }
+
                 return types::Function::Error;
             }
 
@@ -1309,12 +1324,16 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                     Scierror(999, _("%s: %s exit with state %d.\n"), "ode", strMeth.c_str(), istate);
                 }
             }
+            catch (ast::ScilabMessage &sm)
+            {
+                os << sm.GetErrorMessage();
+                bCatch = true;
+                err = 1;
+            }
             catch (ast::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);
+                os << e.GetErrorMessage();
+                bCatch = true;
                 err = 1;
             }
 
@@ -1346,6 +1365,15 @@ types::Function::ReturnValue sci_ode(types::typed_list &in, int _iRetCount, type
                 {
                     FREE(rtol);
                 }
+
+                if (bCatch)
+                {
+                    wchar_t szError[bsiz];
+                    os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "ode", strMeth.c_str());
+                    os << szError;
+                    throw ast::ScilabMessage(os.str());
+                }
+
                 return types::Function::Error;
             }
 
index ea0dc3e..ec1ef3f 100644 (file)
@@ -85,6 +85,10 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
     // For root methode
     int* jroot = NULL;
 
+    // error message catched
+    std::wostringstream os;
+    bool bCatch = false;
+
     // *** check the minimal number of input args. ***
     if (in.size() < 4)
     {
@@ -1092,16 +1096,24 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 {
                     sciprint(_("update at t = %lf\n"), tright);
                 }
+
                 try
                 {
                     ode_f(&sizeYc, &tright, pdYData, pdYData + sizeYc);
                 }
+                catch (ast::ScilabMessage &sm)
+                {
+                    os << sm.GetErrorMessage();
+                    bCatch = true;
+                }
                 catch (ast::ScilabError &e)
                 {
-                    char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
-                    sciprint(_("%s: Update failed at t = %lf\n"), "odedc", tright);
-                    Scierror(999, pstrMsg);
+                    os << e.GetErrorMessage();
+                    bCatch = true;
+                }
 
+                if (bCatch)
+                {
                     DifferentialEquation::removeDifferentialEquationFunctions();
                     FREE(pdYData);
                     FREE(YSize);
@@ -1125,7 +1137,11 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                     {
                         FREE(rtol);
                     }
-                    return types::Function::Error;
+
+                    wchar_t szError[bsiz];
+                    os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "odedc", "tright");
+                    os << szError;
+                    throw ast::ScilabMessage(os.str());
                 }
 
                 deFunctionsManager->resetOdedcFlag();
@@ -1204,12 +1220,16 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                         Scierror(999, _("%s: %s exit with state %d.\n"), "odedc", strMeth.c_str(), istate);
                     }
                 }
+                catch (ast::ScilabMessage &sm)
+                {
+                    os << sm.GetErrorMessage();
+                    bCatch = true;
+                    err = 1;
+                }
                 catch (ast::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);
+                    os << e.GetErrorMessage();
+                    bCatch = true;
                     err = 1;
                 }
 
@@ -1238,6 +1258,15 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                     {
                         FREE(rtol);
                     }
+
+                    if (bCatch)
+                    {
+                        wchar_t szError[bsiz];
+                        os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "odedc", strMeth.c_str());
+                        os << szError;
+                        throw ast::ScilabMessage(os.str());
+                    }
+
                     return types::Function::Error;
                 }
 
@@ -1392,12 +1421,16 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                     Scierror(999, _("%s: %s exit with state %d.\n"), "odedc", strMeth.c_str(), istate);
                 }
             }
+            catch (ast::ScilabMessage &sm)
+            {
+                os << sm.GetErrorMessage();
+                bCatch = true;
+                err = 1;
+            }
             catch (ast::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);
+                os << e.GetErrorMessage();
+                bCatch = true;
                 err = 1;
             }
 
@@ -1426,6 +1459,15 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 {
                     FREE(rtol);
                 }
+
+                if (bCatch)
+                {
+                    wchar_t szError[bsiz];
+                    os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "odedc", strMeth.c_str());
+                    os << szError;
+                    throw ast::ScilabMessage(os.str());
+                }
+
                 return types::Function::Error;
             }
 
@@ -1442,11 +1484,19 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                 {
                     ode_f(&sizeYc, &tright, pdYData, pdYData + sizeYc);
                 }
+                catch (ast::ScilabMessage &sm)
+                {
+                    os << sm.GetErrorMessage();
+                    bCatch = true;
+                }
                 catch (ast::ScilabError &e)
                 {
-                    char* pstrMsg = wide_string_to_UTF8(e.GetErrorMessage().c_str());
-                    sciprint(_("%s: Update failed at t = %lf\n"), "odedc", tright);
-                    Scierror(999, pstrMsg);
+                    os << e.GetErrorMessage();
+                    bCatch = true;
+                }
+
+                if (bCatch)
+                {
                     DifferentialEquation::removeDifferentialEquationFunctions();
                     FREE(pdYData);
                     FREE(YSize);
@@ -1470,7 +1520,11 @@ types::Function::ReturnValue sci_odedc(types::typed_list &in, int _iRetCount, ty
                     {
                         FREE(rtol);
                     }
-                    return types::Function::Error;
+
+                    wchar_t szError[bsiz];
+                    os_swprintf(szError, bsiz, _W("%s: An error occured in '%s' subroutine.\n").c_str(), "odedc", tright);
+                    os << szError;
+                    throw ast::ScilabMessage(os.str());
                 }
 
                 deFunctionsManager->resetOdedcFlag();
index e027a76..dfdb7c5 100644 (file)
@@ -1153,6 +1153,7 @@ void DifferentialEquationFunctions::callOdeMacroF(int* n, double* t, double* y,
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -1205,7 +1206,14 @@ void DifferentialEquationFunctions::callOdeMacroF(int* n, double* t, double* y,
         in.push_back(m_FArgs[i]);
     }
 
-    bool bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
 
     for (int i = 0; i < (int)m_FArgs.size(); i++)
     {
@@ -1214,14 +1222,25 @@ void DifferentialEquationFunctions::callOdeMacroF(int* n, double* t, double* y,
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallFFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallFFunction->getName());
+        }
+
+        if (m_pCallFFunction->isMacro() || m_pCallFFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallFFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -1300,6 +1319,7 @@ void DifferentialEquationFunctions::callMacroJac(int* n, double* t, double* y, i
     int iRetCount   = 1;
     int one         = 1;
     int size        = (*n) * (*nrpd);
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -1318,15 +1338,39 @@ void DifferentialEquationFunctions::callMacroJac(int* n, double* t, double* y, i
 
     for (int i = 0; i < (int)m_JacArgs.size(); i++)
     {
+        m_JacArgs[i]->IncreaseRef();
         in.push_back(m_JacArgs[i]);
     }
 
-    bool bOk = m_pCallJacFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallJacFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
+
+    for (int i = 0; i < (int)m_JacArgs.size(); i++)
+    {
+        m_JacArgs[i]->DecreaseRef();
+    }
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallJacFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallJacFunction->getName());
+        }
+
+        if (m_pCallJacFunction->isMacro() || m_pCallJacFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallJacFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     out[0]->IncreaseRef();
@@ -1346,7 +1390,7 @@ void DifferentialEquationFunctions::callMacroJac(int* n, double* t, double* y, i
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -1369,6 +1413,7 @@ void DifferentialEquationFunctions::callMacroG(int* n, double* t, double* y, int
     char errorMsg[256];
     int iRetCount   = 1;
     int one         = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -1387,21 +1432,45 @@ void DifferentialEquationFunctions::callMacroG(int* n, double* t, double* y, int
 
     for (int i = 0; i < (int)m_odeGArgs.size(); i++)
     {
+        m_odeGArgs[i]->IncreaseRef();
         in.push_back(m_odeGArgs[i]);
     }
 
-    bool bOk = m_pCallGFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallGFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
+
+    for (int i = 0; i < (int)m_odeGArgs.size(); i++)
+    {
+        m_odeGArgs[i]->DecreaseRef();
+    }
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallGFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallGFunction->getName());
+        }
+
+        if (m_pCallGFunction->isMacro() || m_pCallGFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallGFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -1442,6 +1511,7 @@ double DifferentialEquationFunctions::callIntgMacroF(double* t)
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -1461,7 +1531,14 @@ double DifferentialEquationFunctions::callIntgMacroF(double* t)
         in.push_back(m_FArgs[i]);
     }
 
-    bool bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
 
     for (int i = 0; i < (int)m_FArgs.size(); i++)
     {
@@ -1470,14 +1547,25 @@ double DifferentialEquationFunctions::callIntgMacroF(double* t)
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallFFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallFFunction->getName());
+        }
+
+        if (m_pCallFFunction->isMacro() || m_pCallFFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallFFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -1523,6 +1611,7 @@ double DifferentialEquationFunctions::callInt2dMacroF(double* x, double* y)
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -1545,7 +1634,14 @@ double DifferentialEquationFunctions::callInt2dMacroF(double* x, double* y)
         in.push_back(m_FArgs[i]);
     }
 
-    bool bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
 
     for (int i = 0; i < (int)m_FArgs.size(); i++)
     {
@@ -1554,14 +1650,25 @@ double DifferentialEquationFunctions::callInt2dMacroF(double* x, double* y)
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallFFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallFFunction->getName());
+        }
+
+        if (m_pCallFFunction->isMacro() || m_pCallFFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallFFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -1612,6 +1719,7 @@ void DifferentialEquationFunctions::callInt3dMacroF(double* xyz, int* numfun, do
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -1635,7 +1743,14 @@ void DifferentialEquationFunctions::callInt3dMacroF(double* xyz, int* numfun, do
         in.push_back(m_FArgs[i]);
     }
 
-    bool bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
 
     for (int i = 0; i < (int)m_FArgs.size(); i++)
     {
@@ -1644,14 +1759,25 @@ void DifferentialEquationFunctions::callInt3dMacroF(double* xyz, int* numfun, do
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallFFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallFFunction->getName());
+        }
+
+        if (m_pCallFFunction->isMacro() || m_pCallFFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallFFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -1700,6 +1826,7 @@ void DifferentialEquationFunctions::callFevalMacroF(int* nn, double* x1, double*
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -1727,8 +1854,14 @@ void DifferentialEquationFunctions::callFevalMacroF(int* nn, double* x1, double*
         m_FArgs[i]->IncreaseRef();
         in.push_back(m_FArgs[i]);
     }
-
-    bool bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
 
     for (int i = 0; i < (int)m_FArgs.size(); i++)
     {
@@ -1737,14 +1870,25 @@ void DifferentialEquationFunctions::callFevalMacroF(int* nn, double* x1, double*
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallFFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallFFunction->getName());
+        }
+
+        if (m_pCallFFunction->isMacro() || m_pCallFFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallFFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -1808,6 +1952,7 @@ void DifferentialEquationFunctions::callBvodeMacroGsub(int* i, double* z, double
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -1829,21 +1974,45 @@ void DifferentialEquationFunctions::callBvodeMacroGsub(int* i, double* z, double
 
     for (int i = 0; i < (int)m_GsubArgs.size(); i++)
     {
+        m_GsubArgs[i]->IncreaseRef();
         in.push_back(m_GsubArgs[i]);
     }
 
-    bool bOk = m_pCallGsubFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallGsubFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
+
+    for (int i = 0; i < (int)m_GsubArgs.size(); i++)
+    {
+        m_GsubArgs[i]->DecreaseRef();
+    }
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallGsubFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallGsubFunction->getName());
+        }
+
+        if (m_pCallGsubFunction->isMacro() || m_pCallGsubFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallGsubFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallGsubFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -1892,6 +2061,7 @@ void DifferentialEquationFunctions::callBvodeMacroDgsub(int* i, double* z, doubl
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -1912,21 +2082,45 @@ void DifferentialEquationFunctions::callBvodeMacroDgsub(int* i, double* z, doubl
 
     for (int i = 0; i < (int)m_DgsubArgs.size(); i++)
     {
+        m_DgsubArgs[i]->IncreaseRef();
         in.push_back(m_DgsubArgs[i]);
     }
 
-    bool bOk = m_pCallDgsubFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallDgsubFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
+
+    for (int i = 0; i < (int)m_DgsubArgs.size(); i++)
+    {
+        m_DgsubArgs[i]->DecreaseRef();
+    }
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallDgsubFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallDgsubFunction->getName());
+        }
+
+        if (m_pCallDgsubFunction->isMacro() || m_pCallDgsubFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallDgsubFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallDgsubFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -1975,6 +2169,7 @@ void DifferentialEquationFunctions::callBvodeMacroFsub(double* x, double* z, dou
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -1993,24 +2188,47 @@ void DifferentialEquationFunctions::callBvodeMacroFsub(double* x, double* z, dou
     pDblZ->IncreaseRef();
     in.push_back(pDblZ);
 
-
     for (int i = 0; i < (int)m_FsubArgs.size(); i++)
     {
+        m_FsubArgs[i]->IncreaseRef();
         in.push_back(m_FsubArgs[i]);
     }
 
-    bool bOk = m_pCallFsubFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallFsubFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
+
+    for (int i = 0; i < (int)m_FsubArgs.size(); i++)
+    {
+        m_FsubArgs[i]->DecreaseRef();
+    }
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallFsubFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallFsubFunction->getName());
+        }
+
+        if (m_pCallFsubFunction->isMacro() || m_pCallFsubFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallFsubFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallFsubFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -2059,6 +2277,7 @@ void DifferentialEquationFunctions::callBvodeMacroDfsub(double* x, double* z, do
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -2077,24 +2296,47 @@ void DifferentialEquationFunctions::callBvodeMacroDfsub(double* x, double* z, do
     pDblZ->IncreaseRef();
     in.push_back(pDblZ);
 
-
     for (int i = 0; i < (int)m_DfsubArgs.size(); i++)
     {
+        m_DfsubArgs[i]->IncreaseRef();
         in.push_back(m_DfsubArgs[i]);
     }
 
-    bool bOk = m_pCallDfsubFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallDfsubFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
+
+    for (int i = 0; i < (int)m_DfsubArgs.size(); i++)
+    {
+        m_DfsubArgs[i]->DecreaseRef();
+    }
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallDfsubFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallDfsubFunction->getName());
+        }
+
+        if (m_pCallDfsubFunction->isMacro() || m_pCallDfsubFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallDfsubFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallDfsubFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -2144,6 +2386,7 @@ void DifferentialEquationFunctions::callBvodeMacroGuess(double* x, double* z, do
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 2;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -2158,21 +2401,45 @@ void DifferentialEquationFunctions::callBvodeMacroGuess(double* x, double* z, do
 
     for (int i = 0; i < (int)m_GuessArgs.size(); i++)
     {
+        m_GuessArgs[i]->IncreaseRef();
         in.push_back(m_GuessArgs[i]);
     }
 
-    bool bOk = m_pCallGuessFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallGuessFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
+
+    for (int i = 0; i < (int)m_GuessArgs.size(); i++)
+    {
+        m_GuessArgs[i]->DecreaseRef();
+    }
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallGuessFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallGuessFunction->getName());
+        }
+
+        if (m_pCallGuessFunction->isMacro() || m_pCallGuessFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallGuessFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallGuessFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -2240,6 +2507,8 @@ void DifferentialEquationFunctions::callImplMacroF(int* neq, double* t, double*
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
+
     *ires = 2;
 
     typed_list in;
@@ -2267,7 +2536,14 @@ void DifferentialEquationFunctions::callImplMacroF(int* neq, double* t, double*
         in.push_back(m_FArgs[i]);
     }
 
-    bool bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
 
     for (int i = 0; i < (int)m_FArgs.size(); i++)
     {
@@ -2276,14 +2552,25 @@ void DifferentialEquationFunctions::callImplMacroF(int* neq, double* t, double*
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallFFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallFFunction->getName());
+        }
+
+        if (m_pCallFFunction->isMacro() || m_pCallFFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallFFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -2339,6 +2626,7 @@ void DifferentialEquationFunctions::callImplMacroG(int* neq, double* t, double*
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -2365,23 +2653,41 @@ void DifferentialEquationFunctions::callImplMacroG(int* neq, double* t, double*
         in.push_back(m_odeGArgs[i]);
     }
 
-    bool bOk = m_pCallGFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallGFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
 
-    for (int i = 0; i < (int)m_FArgs.size(); i++)
+    for (int i = 0; i < (int)m_odeGArgs.size(); i++)
     {
-        m_FArgs[i]->DecreaseRef();
+        m_odeGArgs[i]->DecreaseRef();
     }
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallGFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallGFunction->getName());
+        }
+
+        if (m_pCallGFunction->isMacro() || m_pCallGFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallGFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -2431,6 +2737,7 @@ void DifferentialEquationFunctions::callImplMacroJac(int* neq, double* t, double
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -2457,23 +2764,41 @@ void DifferentialEquationFunctions::callImplMacroJac(int* neq, double* t, double
         in.push_back(m_JacArgs[i]);
     }
 
-    bool bOk = m_pCallJacFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallJacFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
 
-    for (int i = 0; i < (int)m_FArgs.size(); i++)
+    for (int i = 0; i < (int)m_JacArgs.size(); i++)
     {
-        m_FArgs[i]->DecreaseRef();
+        m_JacArgs[i]->DecreaseRef();
     }
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallJacFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallJacFunction->getName());
+        }
+
+        if (m_pCallJacFunction->isMacro() || m_pCallJacFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallJacFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -2529,6 +2854,7 @@ void DifferentialEquationFunctions::callDasslMacroF(double* t, double* y, double
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 2;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -2555,7 +2881,14 @@ void DifferentialEquationFunctions::callDasslMacroF(double* t, double* y, double
         in.push_back(m_FArgs[i]);
     }
 
-    bool bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallFFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
 
     for (int i = 0; i < (int)m_FArgs.size(); i++)
     {
@@ -2564,14 +2897,25 @@ void DifferentialEquationFunctions::callDasslMacroF(double* t, double* y, double
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallFFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallFFunction->getName());
+        }
+
+        if (m_pCallFFunction->isMacro() || m_pCallFFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallFFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallFFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -2652,6 +2996,7 @@ void DifferentialEquationFunctions::callDasslMacroJac(double* t, double* y, doub
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -2682,23 +3027,41 @@ void DifferentialEquationFunctions::callDasslMacroJac(double* t, double* y, doub
         in.push_back(m_JacArgs[i]);
     }
 
-    bool bOk = m_pCallJacFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallJacFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
 
-    for (int i = 0; i < (int)m_FArgs.size(); i++)
+    for (int i = 0; i < (int)m_JacArgs.size(); i++)
     {
-        m_FArgs[i]->DecreaseRef();
+        m_JacArgs[i]->DecreaseRef();
     }
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallJacFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallJacFunction->getName());
+        }
+
+        if (m_pCallJacFunction->isMacro() || m_pCallJacFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallJacFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallJacFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -2762,6 +3125,7 @@ void DifferentialEquationFunctions::callDasrtMacroG(int* ny, double* t, double*
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 1;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -2783,23 +3147,41 @@ void DifferentialEquationFunctions::callDasrtMacroG(int* ny, double* t, double*
         in.push_back(m_odeGArgs[i]);
     }
 
-    bool bOk = m_pCallGFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallGFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
 
-    for (int i = 0; i < (int)m_FArgs.size(); i++)
+    for (int i = 0; i < (int)m_odeGArgs.size(); i++)
     {
-        m_FArgs[i]->DecreaseRef();
+        m_odeGArgs[i]->DecreaseRef();
     }
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallGFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallGFunction->getName());
+        }
+
+        if (m_pCallGFunction->isMacro() || m_pCallGFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallGFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallGFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -2851,6 +3233,7 @@ void DifferentialEquationFunctions::callDaskrMacroPjac(double* res, int* ires, i
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 3;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -2895,21 +3278,45 @@ void DifferentialEquationFunctions::callDaskrMacroPjac(double* res, int* ires, i
 
     for (int i = 0; i < (int)m_pJacArgs.size(); i++)
     {
+        m_pJacArgs[i]->IncreaseRef();
         in.push_back(m_pJacArgs[i]);
     }
 
-    bool bOk = m_pCallPjacFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        bOk = m_pCallPjacFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
+
+    for (int i = 0; i < (int)m_pJacArgs.size(); i++)
+    {
+        m_pJacArgs[i]->DecreaseRef();
+    }
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallPjacFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallPjacFunction->getName());
+        }
+
+        if (m_pCallPjacFunction->isMacro() || m_pCallPjacFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallPjacFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallPjacFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
@@ -3061,6 +3468,7 @@ void DifferentialEquationFunctions::callDaskrMacroPsol(int* neq, double* t, doub
     char errorMsg[256];
     int one         = 1;
     int iRetCount   = 2;
+    bool bOk        = false;
 
     typed_list in;
     typed_list out;
@@ -3090,23 +3498,47 @@ void DifferentialEquationFunctions::callDaskrMacroPsol(int* neq, double* t, doub
     // optional arguments
     for (int i = 0; i < (int)m_pSolArgs.size(); i++)
     {
+        m_pSolArgs[i]->IncreaseRef();
         in.push_back(m_pSolArgs[i]);
     }
 
-    // call macro
-    bool bOk = m_pCallPsolFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    try
+    {
+        // call macro
+        bOk = m_pCallPsolFunction->call(in, opt, iRetCount, out, &execFunc) == types::Function::OK;
+    }
+    catch (ast::ScilabMessage & /* sm */)
+    {
+        bOk = false;
+    }
+
+    for (int i = 0; i < (int)m_pSolArgs.size(); i++)
+    {
+        m_pSolArgs[i]->DecreaseRef();
+    }
 
     if (bOk == false)
     {
-        sprintf(errorMsg, _("%ls: error while calling user function.\n"), m_pCallPsolFunction->getName().c_str());
-        throw ast::ScilabError(errorMsg);
+        if (ConfigVariable::getLastErrorFunction() == L"")
+        {
+            ConfigVariable::setLastErrorFunction(m_pCallPsolFunction->getName());
+        }
+
+        if (m_pCallPsolFunction->isMacro() || m_pCallPsolFunction->isMacroFile())
+        {
+            wchar_t szError[bsiz];
+            os_swprintf(szError, bsiz, _W("at line % 5d of function %ls called by :\n").c_str(), ConfigVariable::getLastErrorLine(), m_pCallPsolFunction->getName().c_str());
+            throw ast::ScilabMessage(szError);
+        }
+
+        throw ast::ScilabMessage();
     }
 
     // get output
     if (out.size() != iRetCount)
     {
         char* pstrName = wide_string_to_UTF8(m_pCallPsolFunction->getName().c_str());
-        sprintf(errorMsg, _("%s: Wrong number of input argument(s): %d expected.\n"), pstrName, iRetCount);
+        sprintf(errorMsg, _("%s: Wrong number of output argument(s): %d expected.\n"), pstrName, iRetCount);
         FREE(pstrName);
         throw ast::ScilabError(errorMsg);
     }
index e2ad901..ffca0bb 100644 (file)
@@ -22,8 +22,8 @@ t  = 1;
 // -------------------------------
 // With initial yprime computation
 // The evaluation function purposely lacks the output argument 'ires'
-deff("ydot = f1(t, y)", "ydot = y^2 - y*sin(t) + cos(t)")
-refMsg = msprintf(_("Wrong number of output arguments.\n"));
+deff("ydot = f1(t, y, ydot)", "ydot = y^2 - y*sin(t) + cos(t)")
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "f1", 2);
 assert_checkerror("y = dae(y0, t0, t, f1);", refMsg);
 // The evaluation function purposely lacks the input argument 'ydot'
 deff("[ydot,ires] = f2(t, y)", "ydot = y^2 - y*sin(t) + cos(t)");
@@ -32,7 +32,7 @@ assert_checkerror("y = dae(y0, t0, t, f2);", refMsg);
 // ----------------------------------
 // Without initial yprime computation
 // The evaluation function purposely lacks the output argument 'ires'
-refMsg = msprintf(_("Wrong number of output arguments.\n"));
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "f1", 2);
 assert_checkerror("y = dae([y0; 0], t0, t, f1);", refMsg);
 // The evaluation function purposely lacks the input argument 'ydot'
 refMsg = msprintf(_("Wrong number of input arguments."));
@@ -43,7 +43,7 @@ deff("r = g(t, y)", "r = ones(y)");
 // -------------------------------
 // With initial yprime computation
 // The evaluation function purposely lacks the output argument 'ires'
-refMsg = msprintf(_("Wrong number of output arguments.\n"));
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "f1", 2);
 assert_checkerror("[y, r] = dae(""root"", y0, t0, t, f1, 1, g);", refMsg);
 // The evaluation function purposely lacks the input argument 'ydot'
 refMsg = msprintf(_("Wrong number of input arguments."));
@@ -51,7 +51,7 @@ assert_checkerror("[y, r] = dae(""root"", y0, t0, t, f2, 1, g);", refMsg);
 // ----------------------------------
 // Without initial yprime computation
 // The evaluation function purposely lacks the output argument 'ires'
-refMsg = msprintf(_("Wrong number of output arguments.\n"));
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "f1", 2);
 assert_checkerror("[y, r] = dae(""root"", [y0; 0], t0, t, f1, 1, g);", refMsg);
 // The evaluation function purposely lacks the input argument 'ydot'
 refMsg = msprintf(_("Wrong number of input arguments."));
@@ -61,27 +61,15 @@ assert_checkerror("[y, r] = dae(""root"", [y0; 0], t0, t, f2, 1, g);", refMsg);
 // -------------------------------
 // With initial yprime computation
 // The evaluation function purposely lacks the output argument 'ires'
-refMsg = msprintf(_("Wrong number of output arguments.\n"));
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "f1", 2);
 assert_checkerror("[y, r] = dae(""root2"", y0, t0, t, f1, 1, g);", refMsg);
-DASKR--  AT T (=R1) AND STEPSIZE H (=R2) THE                                    
-DASKR--  INITIAL (Y,YPRIME) COULD NOT BE COMPUTED                               
-      In above message,  R1 =  0.1000000000000D-02   R2 =  0.1000000000000D-02  
 // The evaluation function purposely lacks the input argument 'ydot'
 refMsg = msprintf(_("Wrong number of input arguments."));
 assert_checkerror("[y, r] = dae(""root2"", y0, t0, t, f2, 1, g);", refMsg);
-DASKR--  AT T (=R1) AND STEPSIZE H (=R2) THE                                    
-DASKR--  INITIAL (Y,YPRIME) COULD NOT BE COMPUTED                               
-      In above message,  R1 =  0.1000000000000D-02   R2 =  0.1000000000000D-02  
 // ----------------------------------
 // Without initial yprime computation
 // The evaluation function purposely lacks the output argument 'ires'
-refMsg = msprintf(_("Variable returned by scilab argument function is incorrect.\n"));
+refMsg = msprintf(_("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), "g", 1, 1);
 assert_checkerror("[y, r] = dae(""root2"", [y0; 0], t0, t, f1, 1, g);", refMsg);
-DASKR--  AT T (=R1) AND STEPSIZE H (=R2) THE                                    
-DASKR--  INITIAL (Y,YPRIME) COULD NOT BE COMPUTED                               
-      In above message,  R1 =  0.1000000000000D-02   R2 =  0.1000000000000D-02  
 // The evaluation function purposely lacks the input argument 'ydot'
 assert_checkerror("[y, r] = dae(""root2"", [y0; 0], t0, t, f2, 1, g);", refMsg);
-DASKR--  AT T (=R1) AND STEPSIZE H (=R2) THE                                    
-DASKR--  INITIAL (Y,YPRIME) COULD NOT BE COMPUTED                               
-      In above message,  R1 =  0.1000000000000D-02   R2 =  0.1000000000000D-02  
index a846655..615ee58 100644 (file)
@@ -26,9 +26,9 @@ t  = 1;
 // With initial yprime computation
 
 // The evaluation function purposely lacks the output argument 'ires'
-deff("ydot = f1(t, y)", "ydot = y^2 - y*sin(t) + cos(t)")
+deff("ydot = f1(t, y, ydot)", "ydot = y^2 - y*sin(t) + cos(t)")
 
-refMsg = msprintf(_("Wrong number of output arguments.\n"));
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "f1", 2);
 assert_checkerror("y = dae(y0, t0, t, f1);", refMsg);
 
 // The evaluation function purposely lacks the input argument 'ydot'
@@ -41,7 +41,7 @@ assert_checkerror("y = dae(y0, t0, t, f2);", refMsg);
 // Without initial yprime computation
 
 // The evaluation function purposely lacks the output argument 'ires'
-refMsg = msprintf(_("Wrong number of output arguments.\n"));
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "f1", 2);
 assert_checkerror("y = dae([y0; 0], t0, t, f1);", refMsg);
 
 // The evaluation function purposely lacks the input argument 'ydot'
@@ -58,7 +58,7 @@ deff("r = g(t, y)", "r = ones(y)");
 // With initial yprime computation
 
 // The evaluation function purposely lacks the output argument 'ires'
-refMsg = msprintf(_("Wrong number of output arguments.\n"));
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "f1", 2);
 assert_checkerror("[y, r] = dae(""root"", y0, t0, t, f1, 1, g);", refMsg);
 
 // The evaluation function purposely lacks the input argument 'ydot'
@@ -69,7 +69,7 @@ assert_checkerror("[y, r] = dae(""root"", y0, t0, t, f2, 1, g);", refMsg);
 // Without initial yprime computation
 
 // The evaluation function purposely lacks the output argument 'ires'
-refMsg = msprintf(_("Wrong number of output arguments.\n"));
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "f1", 2);
 assert_checkerror("[y, r] = dae(""root"", [y0; 0], t0, t, f1, 1, g);", refMsg);
 
 // The evaluation function purposely lacks the input argument 'ydot'
@@ -84,7 +84,7 @@ assert_checkerror("[y, r] = dae(""root"", [y0; 0], t0, t, f2, 1, g);", refMsg);
 // With initial yprime computation
 
 // The evaluation function purposely lacks the output argument 'ires'
-refMsg = msprintf(_("Wrong number of output arguments.\n"));
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "f1", 2);
 assert_checkerror("[y, r] = dae(""root2"", y0, t0, t, f1, 1, g);", refMsg);
 
 // The evaluation function purposely lacks the input argument 'ydot'
@@ -95,7 +95,7 @@ assert_checkerror("[y, r] = dae(""root2"", y0, t0, t, f2, 1, g);", refMsg);
 // Without initial yprime computation
 
 // The evaluation function purposely lacks the output argument 'ires'
-refMsg = msprintf(_("Variable returned by scilab argument function is incorrect.\n"));
+refMsg = msprintf(_("%s: Wrong size for output argument #%d: A matrix of size %d expected.\n"), "g", 1, 1);
 assert_checkerror("[y, r] = dae(""root2"", [y0; 0], t0, t, f1, 1, g);", refMsg);
 
 // The evaluation function purposely lacks the input argument 'ydot'
index 8728a4f..571a7a0 100644 (file)
@@ -1,3 +1,9 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2007-2008 - INRIA - Serge STEER <serge.steer@inria.fr>
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
 // <-- Non-regression test for bug 2396 -->
 //
 // <-- Bugzilla URL -->
 //    it.
 //
 //    Matthias
-// Serge Steer - Scilab Project
-// Copyright INRIA
-// 14 may 2007
 a1 = [1 2 3];
 a2 = [1 3 4 5 1 6 7];
 function y=elfind(x)
-       y = (find(a2 == x) ~= []);
+    y = (find(a2 == x) ~= []);
 endfunction
-if execstr('z=feval(a1,elfind)','errcatch')<>98 then bugmes();quit;end
+if execstr("z=feval(a1,elfind)","errcatch")<>999 then bugmes();quit;end
index 7c8d6f5..ca5f6a9 100644 (file)
@@ -11,9 +11,9 @@
 // http://bugzilla.scilab.org/show_bug.cgi?id=2396
 //
 // <-- Short Description -->
-//    Scilab crashes on call to feval. I might have defined a weird function 
-//    to be feval'ed, but scilab should not crash. The steps to reproduce the 
-//    bug cause scilab to hang with the error message below, I have to kill 
+//    Scilab crashes on call to feval. I might have defined a weird function
+//    to be feval'ed, but scilab should not crash. The steps to reproduce the
+//    bug cause scilab to hang with the error message below, I have to kill
 //    it.
 //
 //    Matthias
@@ -22,7 +22,7 @@ a1 = [1 2 3];
 a2 = [1 3 4 5 1 6 7];
 
 function y=elfind(x)
-       y = (find(a2 == x) ~= []);
+    y = (find(a2 == x) ~= []);
 endfunction
 
-if execstr('z=feval(a1,elfind)','errcatch')<>98 then pause,end
+if execstr("z=feval(a1,elfind)","errcatch")<>999 then pause,end