differential_equations: fix dasrt/dassl memleaks
[scilab.git] / scilab / modules / differential_equations / sci_gateway / cpp / sci_dassl.cpp
index 0caf36c..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 "MALLOC.h"
+#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"
 }
 
@@ -69,6 +73,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 bCatch = false;
+
     // *** check the minimal number of input args. ***
     if (in.size() < 4 || in.size() > 9)
     {
@@ -87,7 +95,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     // x0 = [y0, yd0]
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "dassl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -95,13 +103,13 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
 
     if (pDblX0->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "dassl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
     if (pDblX0->getCols() > 2)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A real matrix with %d to %d colomn(s) expected.\n"), "dassl", iPos + 1, 1, 2);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A real matrix with %d to %d column(s) expected.\n"), "dassl", iPos + 1, 1, 2);
         return types::Function::Error;
     }
 
@@ -114,7 +122,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "dassl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -122,7 +130,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
 
     if (pDblT0->isScalar() == false)
     {
-        Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "dassl", iPos + 1);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -130,7 +138,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     iPos++;
     if (in[iPos]->isDouble() == false)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "dassl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
@@ -138,19 +146,19 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
 
     if (pDblT->isComplex())
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "dassl", iPos + 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), "dassl", iPos + 1);
         return types::Function::Error;
     }
 
     // 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)
@@ -162,7 +170,7 @@ 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++)
     {
@@ -173,11 +181,11 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 pDblAtol = in[iPos]->getAs<types::Double>();
                 if (pDblAtol->getSize() != pDblX0->getRows() && pDblAtol->isScalar() == false)
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : A scalar or a matrix of size %d expected.\n"), "dassl", iPos + 1, pDblX0->getRows());
+                    Scierror(267, _("%s: Wrong size for input argument #%d: A scalar or a matrix of size %d expected.\n"), "dassl", iPos + 1, pDblX0->getRows());
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
@@ -186,11 +194,11 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 pDblRtol = in[iPos]->getAs<types::Double>();
                 if (pDblAtol->getSize() != pDblRtol->getSize())
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : Atol and Rtol must have the same size.\n"), "dassl", iPos + 1, pDblX0->getRows());
+                    Scierror(267, _("%s: Wrong size for input argument #%d: Atol and Rtol must have the same size.\n"), "dassl", iPos + 1, pDblX0->getRows());
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
@@ -201,19 +209,19 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 {
                     Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "dassl", iPos + 1);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A function expected.\n"), "dassl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A function expected.\n"), "dassl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -222,21 +230,21 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
             types::Callable* pCall = in[iPos]->getAs<types::Callable>();
             if (bFuncF == false)
             {
-                deFunctionsManager->setFFunction(pCall);
+                deFunctionsManager.setFFunction(pCall);
                 bFuncF = true;
             }
             else if (bFuncJac == false)
             {
-                deFunctionsManager->setJacFunction(pCall);
+                deFunctionsManager.setJacFunction(pCall);
                 bFuncJac = true;
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a list expected.\n"), "dassl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a list expected.\n"), "dassl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -247,21 +255,21 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
 
             if (bFuncF == false)
             {
-                bOK = deFunctionsManager->setFFunction(pStr);
+                bOK = deFunctionsManager.setFFunction(pStr);
                 bFuncF = true;
             }
             else if (bFuncJac == false)
             {
-                bOK = deFunctionsManager->setJacFunction(pStr);
+                bOK = deFunctionsManager.setJacFunction(pStr);
                 bFuncJac = true;
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a list expected.\n"), "dassl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a list expected.\n"), "dassl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
@@ -271,9 +279,9 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 Scierror(50, _("%s: Subroutine not found: %s\n"), "dassl", pst);
                 FREE(pst);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
@@ -283,21 +291,21 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
 
             if (pList->getSize() == 0)
             {
-                Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "dassl", iPos + 1, "(string empty)");
+                Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "dassl", iPos + 1, "(string empty)");
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
             if (bFuncF && bListInfo)
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "dassl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "dassl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
 
@@ -309,13 +317,13 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 if (bFuncF == false)
                 {
                     bFuncF = true;
-                    bOK = deFunctionsManager->setFFunction(pStr);
+                    bOK = deFunctionsManager.setFFunction(pStr);
                     sizeOfpdYData = *YSize;
                 }
                 else if (bFuncJac == false)
                 {
                     bFuncJac = true;
-                    bOK = deFunctionsManager->setJacFunction(pStr);
+                    bOK = deFunctionsManager.setJacFunction(pStr);
                     if (sizeOfpdYData == 0)
                     {
                         sizeOfpdYData = *YSize;
@@ -325,19 +333,19 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 if (bOK == false)
                 {
                     char* pst = wide_string_to_UTF8(pStr->get(0));
-                    Scierror(50, _("%s: Argument #%d : Subroutine not found in list: %s\n"), "dassl", iPos + 1, pst);
+                    Scierror(50, _("%s: Argument #%d: Subroutine not found in list: %s\n"), "dassl", iPos + 1, pst);
                     FREE(pst);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
 
                 int* sizeTemp = YSize;
                 int totalSize = sizeOfpdYData;
 
-                YSize = (int*)malloc((sizeOfYSize + pList->getSize() - 1) * sizeof(int));
+                YSize = (int*)MALLOC((sizeOfYSize + pList->getSize() - 1) * sizeof(int));
                 memcpy(YSize, sizeTemp, sizeOfYSize * sizeof(int));
 
                 std::vector<types::Double*> vpDbl;
@@ -345,11 +353,11 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 {
                     if (pList->get(iter + 1)->isDouble() == false)
                     {
-                        Scierror(999, _("%s: Wrong type for input argument #%d : Argument %d in the list must be a matrix.\n"), "dassl", iPos + 1, iter + 1);
+                        Scierror(999, _("%s: Wrong type for input argument #%d: Argument %d in the list must be a matrix.\n"), "dassl", iPos + 1, iter + 1);
                         DifferentialEquation::removeDifferentialEquationFunctions();
-                        free(pdYdotData);
-                        free(pdYData);
-                        free(YSize);
+                        FREE(pdYdotData);
+                        FREE(pdYData);
+                        FREE(YSize);
                         return types::Function::Error;
                     }
 
@@ -359,7 +367,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                 }
 
                 double* pdYDataTemp = pdYData;
-                pdYData = (double*)malloc(totalSize * sizeof(double));
+                pdYData = (double*)MALLOC(totalSize * sizeof(double));
                 C2F(dcopy)(&sizeOfpdYData, pdYDataTemp, &one, pdYData, &one);
 
                 int position = sizeOfpdYData;
@@ -371,27 +379,27 @@ 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())
             {
                 if (bFuncF == false)
                 {
                     bFuncF = true;
-                    deFunctionsManager->setFFunction(pList->get(0)->getAs<types::Callable>());
+                    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)
                 {
                     bFuncJac = true;
-                    deFunctionsManager->setJacFunction(pList->get(0)->getAs<types::Callable>());
+                    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>());
                     }
                 }
             }
@@ -399,11 +407,11 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
             {
                 if (pList->getSize() != 7)
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : A list of size %d expected.\n"), "dassl", iPos + 1, 7);
+                    Scierror(267, _("%s: Wrong size for input argument #%d: A list of size %d expected.\n"), "dassl", iPos + 1, 7);
                     DifferentialEquation::removeDifferentialEquationFunctions();
-                    free(pdYdotData);
-                    free(pdYData);
-                    free(YSize);
+                    FREE(pdYdotData);
+                    FREE(pdYData);
+                    FREE(YSize);
                     return types::Function::Error;
                 }
 
@@ -413,16 +421,16 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                     {
                         if (i == 1 || i == 5 || i == 6)
                         {
-                            Scierror(999, _("%s: Wrong type for input argument #%d : Element %d in the info list must be a scalar.\n"), "dassl", iPos + 1, i);
+                            Scierror(999, _("%s: Wrong type for input argument #%d: Element %d in the info list must be a scalar.\n"), "dassl", iPos + 1, i);
                         }
                         else
                         {
-                            Scierror(999, _("%s: Wrong type for input argument #%d : Element %d in the info list must be a matrix.\n"), "dassl", iPos + 1, i);
+                            Scierror(999, _("%s: Wrong type for input argument #%d: Element %d in the info list must be a matrix.\n"), "dassl", iPos + 1, i);
                         }
                         DifferentialEquation::removeDifferentialEquationFunctions();
-                        free(pdYdotData);
-                        free(pdYData);
-                        free(YSize);
+                        FREE(pdYdotData);
+                        FREE(pdYData);
+                        FREE(YSize);
                         return types::Function::Error;
                     }
                 }
@@ -442,16 +450,16 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
                     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)
                 {
-                    Scierror(267, _("%s: Wrong size for input argument #%d : Argument %d in te list must be of size %d.\n"), "dassl", iPos + 1, 3, 2);
+                    Scierror(267, _("%s: Wrong size for input argument #%d: Argument %d in 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;
                 }
 
@@ -479,21 +487,21 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
             }
             else
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d : The first argument in the list must be a string, a function or a matrix in case of argument info.\n"), "dassl", iPos + 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: The first argument in the list must be a string, a function or a matrix in case of argument info.\n"), "dassl", iPos + 1);
                 DifferentialEquation::removeDifferentialEquationFunctions();
-                free(pdYdotData);
-                free(pdYData);
-                free(YSize);
+                FREE(pdYdotData);
+                FREE(pdYData);
+                FREE(YSize);
                 return types::Function::Error;
             }
         }
         else
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d : A matrix or a function expected.\n"), "dassl", iPos + 1);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A matrix or a function expected.\n"), "dassl", iPos + 1);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYdotData);
-            free(pdYData);
-            free(YSize);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
             return types::Function::Error;
         }
     }
@@ -502,9 +510,9 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     {
         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "dassl", in.size() + 1);
         DifferentialEquation::removeDifferentialEquationFunctions();
-        free(pdYdotData);
-        free(pdYData);
-        free(YSize);
+        FREE(pdYdotData);
+        FREE(pdYData);
+        FREE(YSize);
         return types::Function::Error;
     }
 
@@ -528,7 +536,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     {
         if (pDblAtol->isScalar())
         {
-            atol  = (double*)malloc(sizeof(double));
+            atol  = (double*)MALLOC(sizeof(double));
             *atol = pDblAtol->get(0);
         }
         else
@@ -539,7 +547,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     }
     else
     {
-        atol  = (double*)malloc(sizeof(double));
+        atol  = (double*)MALLOC(sizeof(double));
         *atol = 1.e-7;
     }
 
@@ -547,7 +555,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     {
         if (pDblRtol->isScalar())
         {
-            rtol  = (double*)malloc(sizeof(double));
+            rtol  = (double*)MALLOC(sizeof(double));
             *rtol = pDblRtol->get(0);
         }
         else
@@ -564,12 +572,12 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
             int iOne = 1;
             int iZero = 0;
 
-            rtol = (double*)malloc(iSize * sizeof(double));
+            rtol = (double*)MALLOC(iSize * sizeof(double));
             C2F(dcopy)(&iSize, &dblSrc, &iZero, rtol, &iOne);
         }
         else
         {
-            rtol    = (double*)malloc(sizeof(double));
+            rtol    = (double*)MALLOC(sizeof(double));
             *rtol   = 1.e-9;
         }
     }
@@ -594,8 +602,8 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
         rworksize = 40 + (maxord + 4) * pDblX0->getRows() + (2 * ml + mu + 1) * pDblX0->getRows() + 2 * (pDblX0->getRows() / (ml + mu + 1) + 1);
     }
 
-    iwork = (int*)malloc(iworksize * sizeof(int));
-    rwork = (double*)malloc(rworksize * sizeof(double));
+    iwork = (int*)MALLOC(iworksize * sizeof(int));
+    rwork = (double*)MALLOC(rworksize * sizeof(double));
 
     if (pDblHd != NULL)
     {
@@ -603,18 +611,18 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
         {
             Scierror(77, _("%s: Wrong size for input argument(s) %d: %d expected.\n"), "dassl", in.size(), iworksize + rworksize);
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYdotData);
-            free(pdYData);
-            free(YSize);
-            free(iwork);
-            free(rwork);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
+            FREE(iwork);
+            FREE(rwork);
             if (pDblAtol == NULL || pDblAtol->isScalar())
             {
-                free(atol);
+                FREE(atol);
             }
             if (pDblRtol == NULL || pDblRtol->isScalar())
             {
-                free(rtol);
+                FREE(rtol);
             }
             return types::Function::Error;
         }
@@ -654,6 +662,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     std::list<types::Double*> lpDblOut;
     int size = pDblX0->getRows();
     int rowsOut = 1 + pDblX0->getRows() * 2;
+    int iret = 0;
 
     for (int i = 0; i < pDblT->getSize(); i++)
     {
@@ -674,28 +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
         {
-            Scierror(999, _("%s: dassl return with state %d.\n"), "dassl", idid);
+            for (types::InternalType* pIT : lpDblOut)
+            {
+                pIT->killMe();
+            }
             lpDblOut.clear();
             DifferentialEquation::removeDifferentialEquationFunctions();
-            free(pdYdotData);
-            free(pdYData);
-            free(YSize);
-            free(iwork);
-            free(rwork);
+            FREE(pdYdotData);
+            FREE(pdYData);
+            FREE(YSize);
+            FREE(iwork);
+            FREE(rwork);
             if (pDblAtol == NULL || pDblAtol->isScalar())
             {
-                free(atol);
+                FREE(atol);
             }
             if (pDblRtol == NULL || pDblRtol->isScalar())
             {
-                free(rtol);
+                FREE(rtol);
+            }
+
+            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;
         }
 
@@ -736,6 +770,7 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
     {
         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);
@@ -753,22 +788,22 @@ types::Function::ReturnValue sci_dassl(types::typed_list &in, int _iRetCount, ty
         out.push_back(pDblHdOut);
     }
 
-    // *** free. ***
+    // *** FREE. ***
     if (pDblAtol == NULL || pDblAtol->isScalar())
     {
-        free(atol);
+        FREE(atol);
     }
 
     if (pDblRtol == NULL || pDblRtol->isScalar())
     {
-        free(rtol);
+        FREE(rtol);
     }
 
-    free(pdYData);
-    free(pdYdotData);
-    free(YSize);
-    free(rwork);
-    free(iwork);
+    FREE(pdYData);
+    FREE(pdYdotData);
+    FREE(YSize);
+    FREE(rwork);
+    FREE(iwork);
 
     DifferentialEquation::removeDifferentialEquationFunctions();