error handling in kinsol

src/kinsol/kinsol.c

@@ -214,15 +214,15 @@ void* KINCreate(SUNContext sunctx)
   /* Test inputs */
   if (sunctx == NULL)
   {
-    KINProcessError(NULL, 0, "KIN", "KINCreate", MSG_NULL_SUNCTX);
+    KINProcessError(NULL, 0, __LINE__, __func__, __FILE__, MSG_NULL_SUNCTX);
     return (NULL);
   }
 
   kin_mem = NULL;
   kin_mem = (KINMem)malloc(sizeof(struct KINMemRec));
   if (kin_mem == NULL)
   {
-    KINProcessError(kin_mem, 0, "KINSOL", "KINCreate", MSG_MEM_FAIL);
+    KINProcessError(kin_mem, 0, __LINE__, __func__, __FILE__, MSG_MEM_FAIL);
     return (NULL);
   }
 
@@ -335,7 +335,7 @@ int KINInit(void* kinmem, KINSysFn func, N_Vector tmpl)
 
   if (kinmem == NULL)
   {
-    KINProcessError(NULL, KIN_MEM_NULL, "KINSOL", "KINInit", MSG_NO_MEM);
+    KINProcessError(NULL, KIN_MEM_NULL, __LINE__, __func__, __FILE__, MSG_NO_MEM);
     return (KIN_MEM_NULL);
   }
   kin_mem = (KINMem)kinmem;
@@ -344,7 +344,8 @@ int KINInit(void* kinmem, KINSysFn func, N_Vector tmpl)
 
   if (func == NULL)
   {
-    KINProcessError(kin_mem, KIN_ILL_INPUT, "KINSOL", "KINInit", MSG_FUNC_NULL);
+    KINProcessError(kin_mem, KIN_ILL_INPUT, __LINE__, __func__, __FILE__,
+                    MSG_FUNC_NULL);
     SUNDIALS_MARK_FUNCTION_END(KIN_PROFILER);
     return (KIN_ILL_INPUT);
   }
@@ -354,7 +355,8 @@ int KINInit(void* kinmem, KINSysFn func, N_Vector tmpl)
   nvectorOK = KINCheckNvector(tmpl);
   if (!nvectorOK)
   {
-    KINProcessError(kin_mem, KIN_ILL_INPUT, "KINSOL", "KINInit", MSG_BAD_NVECTOR);
+    KINProcessError(kin_mem, KIN_ILL_INPUT, __LINE__, __func__, __FILE__,
+                    MSG_BAD_NVECTOR);
     SUNDIALS_MARK_FUNCTION_END(KIN_PROFILER);
     return (KIN_ILL_INPUT);
   }
@@ -378,7 +380,8 @@ int KINInit(void* kinmem, KINSysFn func, N_Vector tmpl)
   allocOK = KINAllocVectors(kin_mem, tmpl);
   if (!allocOK)
   {
-    KINProcessError(kin_mem, KIN_MEM_FAIL, "KINSOL", "KINInit", MSG_MEM_FAIL);
+    KINProcessError(kin_mem, KIN_MEM_FAIL, __LINE__, __func__, __FILE__,
+                    MSG_MEM_FAIL);
     free(kin_mem);
     kin_mem = NULL;
     SUNDIALS_MARK_FUNCTION_END(KIN_PROFILER);
@@ -495,7 +498,7 @@ int KINSol(void* kinmem, N_Vector u, int strategy_in, N_Vector u_scale,
 
   if (kinmem == NULL)
   {
-    KINProcessError(NULL, KIN_MEM_NULL, "KINSOL", "KINSol", MSG_NO_MEM);
+    KINProcessError(NULL, KIN_MEM_NULL, __LINE__, __func__, __FILE__, MSG_NO_MEM);
     return (KIN_MEM_NULL);
   }
   kin_mem = (KINMem)kinmem;
@@ -504,7 +507,8 @@ int KINSol(void* kinmem, N_Vector u, int strategy_in, N_Vector u_scale,
 
   if (kin_mem->kin_MallocDone == SUNFALSE)
   {
-    KINProcessError(NULL, KIN_NO_MALLOC, "KINSOL", "KINSol", MSG_NO_MALLOC);
+    KINProcessError(NULL, KIN_NO_MALLOC, __LINE__, __func__, __FILE__,
+                    MSG_NO_MALLOC);
     SUNDIALS_MARK_FUNCTION_END(KIN_PROFILER);
     return (KIN_NO_MALLOC);
   }
@@ -523,14 +527,15 @@ int KINSol(void* kinmem, N_Vector u, int strategy_in, N_Vector u_scale,
   {
     if (kin_mem->kin_uu == NULL)
     {
-      KINProcessError(kin_mem, KIN_ILL_INPUT, "KINSOL", "KINSol", MSG_UU_NULL);
+      KINProcessError(kin_mem, KIN_ILL_INPUT, __LINE__, __func__, __FILE__,
+                      MSG_UU_NULL);
       SUNDIALS_MARK_FUNCTION_END(KIN_PROFILER);
       return (KIN_ILL_INPUT);
     }
 
     if (kin_mem->kin_constraintsSet != SUNFALSE)
     {
-      KINProcessError(kin_mem, KIN_ILL_INPUT, "KINSOL", "KINSol",
+      KINProcessError(kin_mem, KIN_ILL_INPUT, __LINE__, __func__, __FILE__,
                       MSG_CONSTRAINTS_NOTOK);
       SUNDIALS_MARK_FUNCTION_END(KIN_PROFILER);
       return (KIN_ILL_INPUT);
@@ -548,12 +553,12 @@ int KINSol(void* kinmem, N_Vector u, int strategy_in, N_Vector u_scale,
     switch (ret)
     {
     case KIN_SYSFUNC_FAIL:
-      KINProcessError(kin_mem, KIN_SYSFUNC_FAIL, "KINSOL", "KINSol",
+      KINProcessError(kin_mem, KIN_SYSFUNC_FAIL, __LINE__, __func__, __FILE__,
                       MSG_SYSFUNC_FAILED);
       break;
     case KIN_MAXITER_REACHED:
-      KINProcessError(kin_mem, KIN_MAXITER_REACHED, "KINSOL", "KINSol",
-                      MSG_MAXITER_REACHED);
+      KINProcessError(kin_mem, KIN_MAXITER_REACHED, __LINE__, __func__,
+                      __FILE__, MSG_MAXITER_REACHED);
       break;
     }
 
@@ -602,7 +607,8 @@ int KINSol(void* kinmem, N_Vector u, int strategy_in, N_Vector u_scale,
       kin_mem->kin_gval = N_VClone(kin_mem->kin_unew);
       if (kin_mem->kin_gval == NULL)
       {
-        KINProcessError(kin_mem, KIN_MEM_FAIL, "KINSOL", "KINSol", MSG_MEM_FAIL);
+        KINProcessError(kin_mem, KIN_MEM_FAIL, __LINE__, __func__, __FILE__,
+                        MSG_MEM_FAIL);
         SUNDIALS_MARK_FUNCTION_END(KIN_PROFILER);
         return (KIN_MEM_FAIL);
       }
@@ -725,40 +731,40 @@ int KINSol(void* kinmem, N_Vector u, int strategy_in, N_Vector u_scale,
   switch (ret)
   {
   case KIN_SYSFUNC_FAIL:
-    KINProcessError(kin_mem, KIN_SYSFUNC_FAIL, "KINSOL", "KINSol",
+    KINProcessError(kin_mem, KIN_SYSFUNC_FAIL, __LINE__, __func__, __FILE__,
                     MSG_SYSFUNC_FAILED);
     break;
   case KIN_REPTD_SYSFUNC_ERR:
-    KINProcessError(kin_mem, KIN_REPTD_SYSFUNC_ERR, "KINSOL", "KINSol",
-                    MSG_SYSFUNC_REPTD);
+    KINProcessError(kin_mem, KIN_REPTD_SYSFUNC_ERR, __LINE__, __func__,
+                    __FILE__, MSG_SYSFUNC_REPTD);
     break;
   case KIN_LSETUP_FAIL:
-    KINProcessError(kin_mem, KIN_LSETUP_FAIL, "KINSOL", "KINSol",
+    KINProcessError(kin_mem, KIN_LSETUP_FAIL, __LINE__, __func__, __FILE__,
                     MSG_LSETUP_FAILED);
     break;
   case KIN_LSOLVE_FAIL:
-    KINProcessError(kin_mem, KIN_LSOLVE_FAIL, "KINSOL", "KINSol",
+    KINProcessError(kin_mem, KIN_LSOLVE_FAIL, __LINE__, __func__, __FILE__,
                     MSG_LSOLVE_FAILED);
     break;
   case KIN_LINSOLV_NO_RECOVERY:
-    KINProcessError(kin_mem, KIN_LINSOLV_NO_RECOVERY, "KINSOL", "KINSol",
-                    MSG_LINSOLV_NO_RECOVERY);
+    KINProcessError(kin_mem, KIN_LINSOLV_NO_RECOVERY, __LINE__, __func__,
+                    __FILE__, MSG_LINSOLV_NO_RECOVERY);
     break;
   case KIN_LINESEARCH_NONCONV:
-    KINProcessError(kin_mem, KIN_LINESEARCH_NONCONV, "KINSOL", "KINSol",
-                    MSG_LINESEARCH_NONCONV);
+    KINProcessError(kin_mem, KIN_LINESEARCH_NONCONV, __LINE__, __func__,
+                    __FILE__, MSG_LINESEARCH_NONCONV);
     break;
   case KIN_LINESEARCH_BCFAIL:
-    KINProcessError(kin_mem, KIN_LINESEARCH_BCFAIL, "KINSOL", "KINSol",
-                    MSG_LINESEARCH_BCFAIL);
+    KINProcessError(kin_mem, KIN_LINESEARCH_BCFAIL, __LINE__, __func__,
+                    __FILE__, MSG_LINESEARCH_BCFAIL);
     break;
   case KIN_MAXITER_REACHED:
-    KINProcessError(kin_mem, KIN_MAXITER_REACHED, "KINSOL", "KINSol",
+    KINProcessError(kin_mem, KIN_MAXITER_REACHED, __LINE__, __func__, __FILE__,
                     MSG_MAXITER_REACHED);
     break;
   case KIN_MXNEWT_5X_EXCEEDED:
-    KINProcessError(kin_mem, KIN_MXNEWT_5X_EXCEEDED, "KINSOL", "KINSol",
-                    MSG_MXNEWT_5X_EXCEEDED);
+    KINProcessError(kin_mem, KIN_MXNEWT_5X_EXCEEDED, __LINE__, __func__,
+                    __FILE__, MSG_MXNEWT_5X_EXCEEDED);
     break;
   }
 
@@ -928,7 +934,7 @@ static sunbooleantype KINAllocVectors(KINMem kin_mem, N_Vector tmpl)
         (kin_mem->kin_m_aa * kin_mem->kin_m_aa) * sizeof(sunrealtype));
       if (kin_mem->kin_R_aa == NULL)
       {
-        KINProcessError(kin_mem, 0, "KINSOL", "KINAllocVectors", MSG_MEM_FAIL);
+        KINProcessError(kin_mem, 0, __LINE__, __func__, __FILE__, MSG_MEM_FAIL);
         N_VDestroy(kin_mem->kin_unew);
         N_VDestroy(kin_mem->kin_fval);
         N_VDestroy(kin_mem->kin_pp);
@@ -946,7 +952,7 @@ static sunbooleantype KINAllocVectors(KINMem kin_mem, N_Vector tmpl)
         (sunrealtype*)malloc(kin_mem->kin_m_aa * sizeof(sunrealtype));
       if (kin_mem->kin_gamma_aa == NULL)
       {
-        KINProcessError(kin_mem, 0, "KINSOL", "KINAllocVectors", MSG_MEM_FAIL);
+        KINProcessError(kin_mem, 0, __LINE__, __func__, __FILE__, MSG_MEM_FAIL);
         N_VDestroy(kin_mem->kin_unew);
         N_VDestroy(kin_mem->kin_fval);
         N_VDestroy(kin_mem->kin_pp);
@@ -965,7 +971,7 @@ static sunbooleantype KINAllocVectors(KINMem kin_mem, N_Vector tmpl)
         (long int*)malloc(kin_mem->kin_m_aa * sizeof(long int));
       if (kin_mem->kin_ipt_map == NULL)
       {
-        KINProcessError(kin_mem, 0, "KINSOL", "KINAllocVectors", MSG_MEM_FAIL);
+        KINProcessError(kin_mem, 0, __LINE__, __func__, __FILE__, MSG_MEM_FAIL);
         N_VDestroy(kin_mem->kin_unew);
         N_VDestroy(kin_mem->kin_fval);
         N_VDestroy(kin_mem->kin_pp);
@@ -985,7 +991,7 @@ static sunbooleantype KINAllocVectors(KINMem kin_mem, N_Vector tmpl)
         (sunrealtype*)malloc(2 * (kin_mem->kin_m_aa + 1) * sizeof(sunrealtype));
       if (kin_mem->kin_cv == NULL)
       {
-        KINProcessError(kin_mem, 0, "KINSOL", "KINAllocVectors", MSG_MEM_FAIL);
+        KINProcessError(kin_mem, 0, __LINE__, __func__, __FILE__, MSG_MEM_FAIL);
         N_VDestroy(kin_mem->kin_unew);
         N_VDestroy(kin_mem->kin_fval);
         N_VDestroy(kin_mem->kin_pp);
@@ -1006,7 +1012,7 @@ static sunbooleantype KINAllocVectors(KINMem kin_mem, N_Vector tmpl)
         (N_Vector*)malloc(2 * (kin_mem->kin_m_aa + 1) * sizeof(N_Vector));
       if (kin_mem->kin_Xv == NULL)
       {
-        KINProcessError(kin_mem, 0, "KINSOL", "KINAllocVectors", MSG_MEM_FAIL);
+        KINProcessError(kin_mem, 0, __LINE__, __func__, __FILE__, MSG_MEM_FAIL);
         N_VDestroy(kin_mem->kin_unew);
         N_VDestroy(kin_mem->kin_fval);
         N_VDestroy(kin_mem->kin_pp);
@@ -1214,7 +1220,7 @@ static sunbooleantype KINAllocVectors(KINMem kin_mem, N_Vector tmpl)
             ((kin_mem->kin_m_aa * kin_mem->kin_m_aa)) * sizeof(sunrealtype));
           if (kin_mem->kin_T_aa == NULL)
           {
-            KINProcessError(kin_mem, 0, "KINSOL", "KINAllocVectors",
+            KINProcessError(kin_mem, 0, __LINE__, __func__, __FILE__,
                             MSG_MEM_FAIL);
             N_VDestroy(kin_mem->kin_unew);
             N_VDestroy(kin_mem->kin_fval);
@@ -1437,7 +1443,8 @@ static int KINSolInit(KINMem kin_mem)
 
   if (kin_mem->kin_uu == NULL)
   {
-    KINProcessError(kin_mem, KIN_ILL_INPUT, "KINSOL", "KINSolInit", MSG_UU_NULL);
+    KINProcessError(kin_mem, KIN_ILL_INPUT, __LINE__, __func__, __FILE__,
+                    MSG_UU_NULL);
     return (KIN_ILL_INPUT);
   }
 
@@ -1448,35 +1455,35 @@ static int KINSolInit(KINMem kin_mem)
       (kin_mem->kin_globalstrategy != KIN_PICARD) &&
       (kin_mem->kin_globalstrategy != KIN_FP))
   {
-    KINProcessError(kin_mem, KIN_ILL_INPUT, "KINSOL", "KINSolInit",
+    KINProcessError(kin_mem, KIN_ILL_INPUT, __LINE__, __func__, __FILE__,
                     MSG_BAD_GLSTRAT);
     return (KIN_ILL_INPUT);
   }
 
   if (kin_mem->kin_uscale == NULL)
   {
-    KINProcessError(kin_mem, KIN_ILL_INPUT, "KINSOL", "KINSolInit",
+    KINProcessError(kin_mem, KIN_ILL_INPUT, __LINE__, __func__, __FILE__,
                     MSG_BAD_USCALE);
     return (KIN_ILL_INPUT);
   }
 
   if (N_VMin(kin_mem->kin_uscale) <= ZERO)
   {
-    KINProcessError(kin_mem, KIN_ILL_INPUT, "KINSOL", "KINSolInit",
+    KINProcessError(kin_mem, KIN_ILL_INPUT, __LINE__, __func__, __FILE__,
                     MSG_USCALE_NONPOSITIVE);
     return (KIN_ILL_INPUT);
   }
 
   if (kin_mem->kin_fscale == NULL)
   {
-    KINProcessError(kin_mem, KIN_ILL_INPUT, "KINSOL", "KINSolInit",
+    KINProcessError(kin_mem, KIN_ILL_INPUT, __LINE__, __func__, __FILE__,
                     MSG_BAD_FSCALE);
     return (KIN_ILL_INPUT);
   }
 
   if (N_VMin(kin_mem->kin_fscale) <= ZERO)
   {
-    KINProcessError(kin_mem, KIN_ILL_INPUT, "KINSOL", "KINSolInit",
+    KINProcessError(kin_mem, KIN_ILL_INPUT, __LINE__, __func__, __FILE__,
                     MSG_FSCALE_NONPOSITIVE);
     return (KIN_ILL_INPUT);
   }
@@ -1485,7 +1492,7 @@ static int KINSolInit(KINMem kin_mem)
       ((kin_mem->kin_globalstrategy == KIN_PICARD) ||
        (kin_mem->kin_globalstrategy == KIN_FP)))
   {
-    KINProcessError(kin_mem, KIN_ILL_INPUT, "KINSOL", "KINSolInit",
+    KINProcessError(kin_mem, KIN_ILL_INPUT, __LINE__, __func__, __FILE__,
                     MSG_CONSTRAINTS_NOTOK);
     return (KIN_ILL_INPUT);
   }
@@ -1502,7 +1509,7 @@ static int KINSolInit(KINMem kin_mem)
     if ((kin_mem->kin_constraints->ops->nvconstrmask == NULL) ||
         (kin_mem->kin_constraints->ops->nvminquotient == NULL))
     {
-      KINProcessError(kin_mem, KIN_ILL_INPUT, "KINSOL", "KINSolInit",
+      KINProcessError(kin_mem, KIN_ILL_INPUT, __LINE__, __func__, __FILE__,
                       MSG_BAD_NVECTOR);
       return (KIN_ILL_INPUT);
     }
@@ -1515,7 +1522,7 @@ static int KINSolInit(KINMem kin_mem)
     if (!N_VConstrMask(kin_mem->kin_constraints, kin_mem->kin_uu,
                        kin_mem->kin_vtemp1))
     {
-      KINProcessError(kin_mem, KIN_ILL_INPUT, "KINSOL", "KINSolInit",
+      KINProcessError(kin_mem, KIN_ILL_INPUT, __LINE__, __func__, __FILE__,
                       MSG_INITIAL_CNSTRNT);
       return (KIN_ILL_INPUT);
     }
@@ -1576,14 +1583,14 @@ static int KINSolInit(KINMem kin_mem)
 
   if (retval < 0)
   {
-    KINProcessError(kin_mem, KIN_SYSFUNC_FAIL, "KINSOL", "KINSolInit",
+    KINProcessError(kin_mem, KIN_SYSFUNC_FAIL, __LINE__, __func__, __FILE__,
                     MSG_SYSFUNC_FAILED);
     return (KIN_SYSFUNC_FAIL);
   }
   else if (retval > 0)
   {
-    KINProcessError(kin_mem, KIN_FIRST_SYSFUNC_ERR, "KINSOL", "KINSolInit",
-                    MSG_SYSFUNC_FIRST);
+    KINProcessError(kin_mem, KIN_FIRST_SYSFUNC_ERR, __LINE__, __func__,
+                    __FILE__, MSG_SYSFUNC_FIRST);
     return (KIN_FIRST_SYSFUNC_ERR);
   }
 
@@ -1605,7 +1612,7 @@ static int KINSolInit(KINMem kin_mem)
     retval = kin_mem->kin_linit(kin_mem);
     if (retval != 0)
     {
-      KINProcessError(kin_mem, KIN_LINIT_FAIL, "KINSOL", "KINSolInit",
+      KINProcessError(kin_mem, KIN_LINIT_FAIL, __LINE__, __func__, __FILE__,
                       MSG_LINIT_FAIL);
       return (KIN_LINIT_FAIL);
     }
@@ -2562,44 +2569,36 @@ void KINPrintInfo(KINMem kin_mem, int info_code, const char* module,
  * =================================================================
  */
 
-/*
- * KINProcessError
- *
- * KINProcessError is a high level error handling function.
- * - If cv_mem==NULL it prints the error message to stderr.
- * - Otherwise, it sets up and calls the error handling function
- *   pointed to by cv_ehfun.
- */
-
-void KINProcessError(KINMem kin_mem, int error_code, const char* module,
-                     const char* fname, const char* msgfmt, ...)
+void KINProcessError(KINMem kin_mem, int error_code, int line, const char* func,
+                     const char* file, const char* msgfmt, ...)
 {
-  va_list ap;
-  char msg[256];
-
   /* Initialize the argument pointer variable
-     (msgfmt is the last required argument to KINProcessError) */
-
+     (msgfmt is the last required argument to cvProcessError) */
+  va_list ap;
   va_start(ap, msgfmt);
 
   /* Compose the message */
-
-  vsprintf(msg, msgfmt, ap);
+  size_t msglen = vsnprintf(NULL, 0, msgfmt, ap) + 1;
+  char* msg     = (char*)malloc(msglen);
+  vsnprintf(msg, msglen, msgfmt, ap);
 
   if (kin_mem == NULL)
   { /* We write to stderr */
+
 #ifndef NO_FPRINTF_OUTPUT
-    fprintf(stderr, "\n[%s ERROR]  %s\n  ", module, fname);
+    fprintf(stderr, "\n[KINSOL ERROR]  %s at %s:%d\n  ", func, __FILE__, line);
     fprintf(stderr, "%s\n\n", msg);
 #endif
   }
   else
-  { /* We can call ehfun */
-    kin_mem->kin_ehfun(error_code, module, fname, msg, kin_mem->kin_eh_data);
+  {
+    /* Call the SUNDIALS main error handler */
+    SUNHandleErrWithMsg(line, func, file, msg, error_code, kin_mem->kin_sunctx);
   }
 
   /* Finalize argument processing */
   va_end(ap);
+  free(msg);
 
   return;
 }