differential_equations: fix dasrt/dassl memleaks
[scilab.git] / scilab / modules / differential_equations / sci_gateway / cpp / sci_dassl.cpp
index ffa97b4..04c95a6 100644 (file)
@@ -2,11 +2,14 @@
 * 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
+ * Copyright (C) 2012 - 2016 - Scilab Enterprises
+ *
+ * This file is hereby licensed under the terms of the GNU GPL v2.0,
+ * pursuant to article 5.3.4 of the CeCILL v.2.1.
+ * This file was originally licensed under the terms of the CeCILL v2.1,
+ * and continues to be available under such terms.
+ * For more information, see the COPYING file which you should have received
+ * along with this program.
 *
 */
 /*--------------------------------------------------------------------------*/
 #include "callable.hxx"
 #include "differentialequationfunctions.hxx"
 #include "runvisitor.hxx"
+#include "checkodeerror.hxx"
 
 extern "C"
 {
+#include "sci_malloc.h"
 #include "localization.h"
 #include "Scierror.h"
+#include "sciprint.h"
 #include "scifunctions.h"
 #include "elem_common.h"
-#include "checkodeerror.h"
 #include "xerhlt.h"
 }
 
@@ -49,7 +54,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     int iPos    = 0;
     int one     = 1;
 
-    int info[15]    = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+    int info[15]    = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 
     double tstop    = 0;
     double maxstep  = 0;
@@ -59,7 +64,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
 
     int sizeOfYSize = 1;
     int* YSize      = NULL;    // YSize(1) = size of y0,
-                               // YSize(n) = size of Args(n) in list case.
+    // YSize(n) = size of Args(n) in list case.
 
     // Indicate if the function is given.
     bool bFuncF     = false;
@@ -68,91 +73,95 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     // Indicate if info list is given.
     bool bListInfo  = false;
 
-// *** check the minimal number of input args. ***
-    if(in.size() < 4 || in.size() > 9)
+    // error message catched
+    std::wostringstream os;
+    bool bCatch = false;
+
+    // *** check the minimal number of input args. ***
+    if (in.size() < 4 || in.size() > 9)
     {
-        ScierrorW(77, _W("%ls: Wrong number of input argument(s): %d to %d expected.\n"), L"dassl", 4, 9);
+        Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "dassl", 4, 9);
         return types::Function::Error;
     }
 
-// *** check number of output args ***
-    if(_iRetCount > 2)
+    // *** check number of output args ***
+    if (_iRetCount > 2)
     {
-        ScierrorW(78, _W("%ls: Wrong number of output argument(s): %d to %d expected.\n"), L"dassl", 1, 2);
+        Scierror(78, _("%s: Wrong number of output argument(s): %d to %d expected.\n"), "dassl", 1, 2);
         return types::Function::Error;
     }
 
-// *** check type of input args and get it. ***
+    // *** check type of input args and get it. ***
     // x0 = [y0, yd0]
-    if(in[iPos]->isDouble() == false)
+    if (in[iPos]->isDouble() == false)
     {
-        ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A matrix expected.\n"), L"dassl", iPos+1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
     pDblX0 = in[iPos]->getAs<types::Double>();
 
-    if(pDblX0->isComplex())
+    if (pDblX0->isComplex())
     {
-        ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A real matrix expected.\n"), L"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)
+    if (pDblX0->getCols() > 2)
     {
-        ScierrorW(999, _W("%ls: Wrong size for input argument #%d : A real matrix with %d to %d colomn(s) expected.\n"), L"dassl", iPos+1, 1, 2);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A real matrix with %d to %d column(s) expected.\n"), "dassl", iPos + 1, 1, 2);
         return types::Function::Error;
     }
 
-    if(pDblX0->getCols() == 1)
+    if (pDblX0->getCols() == 1)
     {
         info[10] = 1;
     }
 
     // t0
     iPos++;
-    if(in[iPos]->isDouble() == false)
+    if (in[iPos]->isDouble() == false)
     {
-        ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A scalar expected.\n"), L"dassl", iPos+1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
     pDblT0 = in[iPos]->getAs<types::Double>();
 
-    if(pDblT0->isScalar() == false)
+    if (pDblT0->isScalar() == false)
     {
-        ScierrorW(999, _W("%ls: Wrong size for input argument #%d : A scalar expected.\n"), L"dassl", iPos+1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
     // t
     iPos++;
-    if(in[iPos]->isDouble() == false)
+    if (in[iPos]->isDouble() == false)
     {
-        ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A matrix expected.\n"), L"dassl", iPos+1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
     pDblT = in[iPos]->getAs<types::Double>();
 
-    if(pDblT->isComplex())
+    if (pDblT->isComplex())
     {
-        ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A real matrix expected.\n"), L"dassl", iPos+1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
     // get next inputs
-    DifferentialEquationFunctions* deFunctionsManager = new DifferentialEquationFunctions(L"dassl");
-    DifferentialEquation::addDifferentialEquationFunctions(deFunctionsManager);
+    DifferentialEquationFunctions deFunctionsManager(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)
+    if (pDblX0->getCols() == 2)
     {
         C2F(dcopy)(YSize, pDblX0->get() + *YSize, &one, pdYdotData, &one);
     }
@@ -161,182 +170,208 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
         memset(pdYdotData, 0x00, *YSize);
     }
 
-    deFunctionsManager->setOdeYRows(pDblX0->getRows());
+    deFunctionsManager.setOdeYRows(pDblX0->getRows());
 
-    for(iPos++; iPos < in.size(); iPos++)
+    for (iPos++; iPos < in.size(); iPos++)
     {
-        if(in[iPos]->isDouble())
+        if (in[iPos]->isDouble())
         {
-            if(pDblAtol == NULL && bFuncF == false)
+            if (pDblAtol == NULL && bFuncF == false)
             {
                 pDblAtol = in[iPos]->getAs<types::Double>();
-                if(pDblAtol->getSize() != pDblX0->getRows() && pDblAtol->isScalar() == false)
+                if (pDblAtol->getSize() != pDblX0->getRows() && pDblAtol->isScalar() == false)
                 {
-                    ScierrorW(267,_W("%ls: Wrong size for input argument #%d : A scalar or a matrix of size %d expected.\n"), L"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;
                 }
             }
-            else if(pDblRtol == NULL && bFuncF == false)
+            else if (pDblRtol == NULL && bFuncF == false)
             {
                 pDblRtol = in[iPos]->getAs<types::Double>();
-                if(pDblAtol->getSize() != pDblRtol->getSize())
+                if (pDblAtol->getSize() != pDblRtol->getSize())
                 {
-                    ScierrorW(267,_W("%ls: Wrong size for input argument #%d : Atol and Rtol must have the same size.\n"), L"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;
                 }
             }
-            else if(pDblHd == NULL && bFuncF == true)
+            else if (pDblHd == NULL && bFuncF == true)
             {
                 pDblHd = in[iPos]->getAs<types::Double>();
-                if(in.size() != iPos+1)
+                if (in.size() != iPos + 1)
                 {
-                    ScierrorW(77, _W("%ls: Wrong number of input argument(s): %d expected.\n"), L"dassl", iPos+1);
+                    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
             {
-                ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A function expected.\n"), L"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;
             }
         }
-        else if(in[iPos]->isCallable())
+        else if (in[iPos]->isCallable())
         {
             types::Callable* pCall = in[iPos]->getAs<types::Callable>();
-            if(bFuncF == false)
+            if (bFuncF == false)
             {
-                deFunctionsManager->setFFunction(pCall);
+                deFunctionsManager.setFFunction(pCall);
                 bFuncF = true;
             }
-            else if(bFuncJac == false)
+            else if (bFuncJac == false)
             {
-                deFunctionsManager->setJacFunction(pCall);
+                deFunctionsManager.setJacFunction(pCall);
                 bFuncJac = true;
             }
             else
             {
-                ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A matrix or a list expected.\n"), L"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;
             }
         }
-        else if(in[iPos]->isString())
+        else if (in[iPos]->isString())
         {
             types::String* pStr = in[iPos]->getAs<types::String>();
             bool bOK = false;
 
-            if(bFuncF == false)
+            if (bFuncF == false)
             {
-                bOK = deFunctionsManager->setFFunction(pStr);
+                bOK = deFunctionsManager.setFFunction(pStr);
                 bFuncF = true;
             }
-            else if(bFuncJac == false)
+            else if (bFuncJac == false)
             {
-                bOK = deFunctionsManager->setJacFunction(pStr);
+                bOK = deFunctionsManager.setJacFunction(pStr);
                 bFuncJac = true;
             }
             else
             {
-                ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A matrix or a list expected.\n"), L"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;
             }
 
-            if(bOK == false)
+            if (bOK == false)
             {
-                ScierrorW(50,_W("%ls: Subroutine not found: %ls\n"), L"dassl", pStr->get(0));
+                char* pst = wide_string_to_UTF8(pStr->get(0));
+                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;
             }
         }
-        else if(in[iPos]->isList())
+        else if (in[iPos]->isList())
         {
             types::List* pList = in[iPos]->getAs<types::List>();
 
-            if(pList->getSize() == 0)
+            if (pList->getSize() == 0)
             {
-                ScierrorW(50,_W("%ls: Argument #%d : Subroutine not found in list: %ls\n"), L"dassl", iPos+1, L"(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)
+            if (bFuncF && bListInfo)
             {
-                ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A matrix expected.\n"), L"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;
             }
 
-            if(pList->get(0)->isString())
+            if (pList->get(0)->isString())
             {
                 types::String* pStr = pList->get(0)->getAs<types::String>();
                 bool bOK = false;
 
-                if(bFuncF == false)
+                if (bFuncF == false)
                 {
                     bFuncF = true;
-                    bOK = deFunctionsManager->setFFunction(pStr);
+                    bOK = deFunctionsManager.setFFunction(pStr);
                     sizeOfpdYData = *YSize;
                 }
-                else if(bFuncJac == false)
+                else if (bFuncJac == false)
                 {
                     bFuncJac = true;
-                    bOK = deFunctionsManager->setJacFunction(pStr);
-                    if(sizeOfpdYData == 0)
+                    bOK = deFunctionsManager.setJacFunction(pStr);
+                    if (sizeOfpdYData == 0)
                     {
                         sizeOfpdYData = *YSize;
                     }
                 }
 
-                if(bOK == false)
+                if (bOK == false)
                 {
-                    ScierrorW(50,_W("%ls: Argument #%d : Subroutine not found in list: %ls\n"), L"dassl", iPos+1, pStr->get(0));
+                    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);
+                    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;
-                for(int iter = 0; iter < pList->getSize() - 1; iter++)
+                for (int iter = 0; iter < pList->getSize() - 1; iter++)
                 {
-                    if(pList->get(iter + 1)->isDouble() == false)
+                    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"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;
                     }
 
-                    vpDbl.push_back(pList->get(iter+1)->getAs<types::Double>());
+                    vpDbl.push_back(pList->get(iter + 1)->getAs<types::Double>());
                     YSize[sizeOfYSize + iter] = vpDbl[iter]->getSize();
                     totalSize += YSize[sizeOfYSize + iter];
                 }
 
                 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;
-                for(int iter = 0; iter < pList->getSize()-1; iter++)
+                for (int iter = 0; iter < pList->getSize() - 1; iter++)
                 {
                     C2F(dcopy)(&YSize[sizeOfYSize + iter], vpDbl[iter]->get(), &one, &pdYData[position], &one);
                     position += vpDbl[iter]->getSize();
@@ -344,60 +379,64 @@ 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())
+            else if (pList->get(0)->isCallable())
             {
-                if(bFuncF == false)
+                if (bFuncF == false)
                 {
                     bFuncF = true;
-                    deFunctionsManager->setFFunction(pList->get(0)->getAs<types::Callable>());
-                    for(int iter = 1; iter < pList->getSize(); iter++)
+                    deFunctionsManager.setFFunction(pList->get(0)->getAs<types::Callable>());
+                    for (int iter = 1; iter < pList->getSize(); iter++)
                     {
-                        deFunctionsManager->setFArgs(pList->get(iter)->getAs<types::InternalType>());
+                        deFunctionsManager.setFArgs(pList->get(iter)->getAs<types::InternalType>());
                     }
                 }
-                else if(bFuncJac == false)
+                else if (bFuncJac == false)
                 {
                     bFuncJac = true;
-                    deFunctionsManager->setJacFunction(pList->get(0)->getAs<types::Callable>());
-                    for(int iter = 1; iter < pList->getSize(); iter++)
+                    deFunctionsManager.setJacFunction(pList->get(0)->getAs<types::Callable>());
+                    for (int iter = 1; iter < pList->getSize(); iter++)
                     {
-                        deFunctionsManager->setJacArgs(pList->get(iter)->getAs<types::InternalType>());
+                        deFunctionsManager.setJacArgs(pList->get(iter)->getAs<types::InternalType>());
                     }
                 }
             }
-            else if(pList->get(0)->isDouble() && bFuncF == true)
+            else if (pList->get(0)->isDouble() && bFuncF == true)
             {
-                if(pList->getSize() != 7)
+                if (pList->getSize() != 7)
                 {
-                    ScierrorW(267,_W("%ls: Wrong size for input argument #%d : A list of size %d expected.\n"), L"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;
                 }
 
-                for(int i = 0; i < 7; i++) // info = list([],0,[],[],[],0,0)
+                for (int i = 0; i < 7; i++) // info = list([],0,[],[],[],0,0)
                 {
-                    if(pList->get(i)->isDouble() == false || (pList->get(i)->getAs<types::Double>()->isScalar() == false && (i == 1 || i == 5 || i == 6)))
+                    if (pList->get(i)->isDouble() == false || (pList->get(i)->getAs<types::Double>()->isScalar() == false && (i == 1 || i == 5 || i == 6)))
                     {
-                        if(i == 1 || i == 5 || i == 6)
+                        if (i == 1 || i == 5 || i == 6)
                         {
-                            ScierrorW(999, _W("%ls: Wrong type for input argument #%d : Element %d in the info list must be a scalar.\n"), L"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
                         {
-                            ScierrorW(999, _W("%ls: Wrong type for input argument #%d : Element %d in the info list must be a matrix.\n"), L"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);
-                        return types::Function::Error;  
+                        FREE(pdYdotData);
+                        FREE(pdYData);
+                        FREE(YSize);
+                        return types::Function::Error;
                     }
                 }
 
                 types::Double* pDblTemp = pList->get(0)->getAs<types::Double>();
-                if(pDblTemp->getSize() != 0)
+                if (pDblTemp->getSize() != 0)
                 {
                     info[3] = 1;
                     tstop = pDblTemp->get(0);
@@ -406,38 +445,40 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 info[2] = (int)pList->get(1)->getAs<types::Double>()->get(0);
 
                 pDblTemp = pList->get(2)->getAs<types::Double>();
-                if(pDblTemp->getSize() == 2)
+                if (pDblTemp->getSize() == 2)
                 {
                     info[5] = 1;
                     ml = (int)pDblTemp->get(0);
                     mu = (int)pDblTemp->get(1);
-                    deFunctionsManager->setMl(ml);
-                    deFunctionsManager->setMu(mu);
+                    deFunctionsManager.setMl(ml);
+                    deFunctionsManager.setMu(mu);
                 }
-                else if(pDblTemp->getSize() != 0)
+                else if (pDblTemp->getSize() != 0)
                 {
-                    ScierrorW(267,_W("%ls: Wrong size for input argument #%d : Argument %d in te list must be of size %d.\n"), L"dassl", iPos+1, 3, 2);
+                    Scierror(267, _("%s: Wrong size for input argument #%d: Argument %d in the 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;
                 }
 
                 pDblTemp = pList->get(3)->getAs<types::Double>();
-                if(pDblTemp->getSize() != 0)
+                if (pDblTemp->getSize() != 0)
                 {
                     info[6] = 1;
                     maxstep = pDblTemp->get(0);
                 }
 
                 pDblTemp = pList->get(4)->getAs<types::Double>();
-                if(pDblTemp->getSize() != 0)
+                if (pDblTemp->getSize() != 0)
                 {
                     info[7] = 1;
                     stepin = pDblTemp->get(0);
                 }
 
                 info[9]  = (int)pList->get(5)->getAs<types::Double>()->get(0);
-                if(pList->get(6)->getAs<types::Double>()->get(0) == 1)
+                if (pList->get(6)->getAs<types::Double>()->get(0) == 1)
                 {
                     info[10] = 1;
                 }
@@ -446,35 +487,41 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                ScierrorW(999, _W("%ls: 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"), L"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
         {
-            ScierrorW(999, _W("%ls: Wrong type for input argument #%d : A matrix or a function expected.\n"), L"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;
         }
     }
 
-    if(bFuncF == false)
+    if (bFuncF == false)
     {
-        ScierrorW(77, _W("%ls: Wrong number of input argument(s): %d expected.\n"), L"dassl", in.size() + 1);
+        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;
     }
 
-    if(bFuncJac == true)
+    if (bFuncJac == true)
     {
         info[4] = 1;
     }
 
-// *** Initialization. ***
+    // *** Initialization. ***
     double t0   = pDblT0->get(0);
     double rpar = 0;
     int ipar    = 0;
@@ -485,11 +532,11 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     double* rtol = NULL;
     double* atol = NULL;
 
-    if(pDblAtol)
+    if (pDblAtol)
     {
-        if(pDblAtol->isScalar())
+        if (pDblAtol->isScalar())
         {
-            atol  = (double*)malloc(sizeof(double));
+            atol  = (double*)MALLOC(sizeof(double));
             *atol = pDblAtol->get(0);
         }
         else
@@ -500,15 +547,15 @@ 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;
     }
 
-    if(pDblRtol)
+    if (pDblRtol)
     {
-        if(pDblRtol->isScalar())
+        if (pDblRtol->isScalar())
         {
-            rtol  = (double*)malloc(sizeof(double));
+            rtol  = (double*)MALLOC(sizeof(double));
             *rtol = pDblRtol->get(0);
         }
         else
@@ -518,19 +565,19 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     }
     else // if rtol is not given atol will be used as a scalar.
     {
-        if(pDblAtol && pDblAtol->isScalar() == false)// info[1] == 1
+        if (pDblAtol && pDblAtol->isScalar() == false) // info[1] == 1
         {
             double dblSrc = 1.e-9;
             int iSize = pDblAtol->getSize();
             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;
         }
     }
@@ -542,38 +589,47 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     int* iwork      = NULL;
     double* rwork   = NULL;
 
-    if(info[5] == 0)
+    if (info[5] == 0)
     {
         rworksize = 40 + (maxord + 4) * pDblX0->getRows() + pDblX0->getRows() * pDblX0->getRows();
     }
-    else if(info[4] == 1)
+    else if (info[4] == 1)
     {
         rworksize = 40 + (maxord + 4) * pDblX0->getRows() + (2 * ml + mu + 1) * pDblX0->getRows();
     }
-    else if(info[4] == 0)
+    else if (info[4] == 0)
     {
         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)
+    if (pDblHd != NULL)
     {
-        if(iworksize + rworksize != pDblHd->getSize())
+        if (iworksize + rworksize != pDblHd->getSize())
         {
-            ScierrorW(77, _W("%ls: Wrong size for input argument(s) %d: %d expected.\n"), L"dassl", in.size(), iworksize + rworksize);
+            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);
-            if(pDblAtol == NULL || pDblAtol->isScalar()) free(atol);
-            if(pDblRtol == NULL || pDblRtol->isScalar()) free(rtol);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
+            FREE(iwork);
+            FREE(rwork);
+            if (pDblAtol == NULL || pDblAtol->isScalar())
+            {
+                FREE(atol);
+            }
+            if (pDblRtol == NULL || pDblRtol->isScalar())
+            {
+                FREE(rtol);
+            }
             return types::Function::Error;
         }
 
         C2F(dcopy)(&rworksize, pDblHd->get(), &one, rwork, &one);
 
-        for(int i = 0; i < iworksize; i++)
+        for (int i = 0; i < iworksize; i++)
         {
             iwork[i] = (int)pDblHd->get(rworksize + i);
         }
@@ -581,33 +637,34 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
         info[0] = 1;
     }
 
-    if(info[3] == 1)
+    if (info[3] == 1)
     {
         rwork[0] = tstop;
     }
 
-    if(info[6] == 1)
+    if (info[6] == 1)
     {
         rwork[1] = maxstep;
     }
 
-    if(info[7] == 1)
+    if (info[7] == 1)
     {
         rwork[2] = stepin;
     }
 
-    if(info[5] == 1)
+    if (info[5] == 1)
     {
         iwork[0] = ml;
         iwork[1] = mu;
     }
 
-// *** Perform operation. ***
+    // *** Perform operation. ***
     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++)
+    for (int i = 0; i < pDblT->getSize(); i++)
     {
         types::Double* pDblOut = new types::Double(rowsOut, 1);
         lpDblOut.push_back(pDblOut);
@@ -616,7 +673,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
         int pos  = 0;
         pDblOut->set(pos, t);
 
-        if(t == t0)
+        if (t == t0)
         {
             pos++;
             C2F(dcopy)(&size, pdYData, &one, pDblOut->get() + pos, &one);
@@ -626,19 +683,53 @@ 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 = checkError(idid, "dassl");
+            if (iret == 1) // error
+            {
+                Scierror(999, _("%s: %s return with state %d.\n"), "dassl", "dassl",  idid);
+            }
+        }
+        catch (ast::InternalError &ie)
+        {
+            os << ie.GetErrorMessage();
+            bCatch = true;
+            iret = 1;
+        }
 
-        if(iret == 1) // error
+        if (iret == 1) // error
         {
-            ScierrorW(999, _W("%ls: dassl return with state %d.\n"), L"dassl", idid);
+            for (types::InternalType* pIT : lpDblOut)
+            {
+                pIT->killMe();
+            }
             lpDblOut.clear();
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYdotData);free(pdYData);free(YSize);
-            free(iwork);free(rwork);
-            if(pDblAtol == NULL || pDblAtol->isScalar()) free(atol);
-            if(pDblRtol == NULL || pDblRtol->isScalar()) free(rtol);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
+            FREE(iwork);
+            FREE(rwork);
+            if (pDblAtol == NULL || pDblAtol->isScalar())
+            {
+                FREE(atol);
+            }
+            if (pDblRtol == NULL || pDblRtol->isScalar())
+            {
+                FREE(rtol);
+            }
+
+            if (bCatch)
+            {
+                wchar_t szError[bsiz];
+                os_swprintf(szError, bsiz, _W("%ls: An error occurred in '%ls' subroutine.\n").c_str(), L"dassl", L"dassl");
+                os << szError;
+                throw ast::InternalError(os.str());
+            }
+
             return types::Function::Error;
         }
 
@@ -647,18 +738,18 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
         pos += size;
         C2F(dcopy)(&size, pdYdotData, &one, pDblOut->get() + pos, &one);
 
-        if(iret == 2) // warning
+        if (iret == 2) // warning
         {
             break;
         }
 
         // iret == 0
-        if(idid == 1)
+        if (idid == 1)
         {
             pDblOut->set(0, t0);
             i--;
         }
-        else if(idid == -2)
+        else if (idid == -2)
         {
             t0 = t;
             i--;
@@ -671,24 +762,25 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
         info[0] = 1;
     }
 
-// *** Return result in Scilab. ***
+    // *** Return result in Scilab. ***
     types::Double* pDblOut = new types::Double(rowsOut, (int)lpDblOut.size());
 
     int sizeOfList = (int)lpDblOut.size();
-    for(int i = 0; i < sizeOfList; i++)
+    for (int i = 0; i < sizeOfList; i++)
     {
         int pos = i * rowsOut;
         C2F(dcopy)(&rowsOut, lpDblOut.front()->get(), &one, pDblOut->get() + pos, &one);
+        lpDblOut.front()->killMe();
         lpDblOut.pop_front();
     }
     out.push_back(pDblOut);
 
-    if(_iRetCount == 2)
+    if (_iRetCount == 2)
     {
         types::Double* pDblHdOut = new types::Double(rworksize + iworksize, 1);
         C2F(dcopy)(&rworksize, rwork, &one, pDblHdOut->get(), &one);
 
-        for(int i = 0; i < iworksize; i++)
+        for (int i = 0; i < iworksize; i++)
         {
             pDblHdOut->set(rworksize + i, (double)iwork[i]);
         }
@@ -696,22 +788,22 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
         out.push_back(pDblHdOut);
     }
 
-// *** free. ***
-    if(pDblAtol == NULL || pDblAtol->isScalar())
+    // *** FREE. ***
+    if (pDblAtol == NULL || pDblAtol->isScalar())
     {
-        free(atol);
+        FREE(atol);
     }
 
-    if(pDblRtol == NULL || pDblRtol->isScalar())
+    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();