Allow registering global handlers for GAP_TRY/GAP_CATCH.

Makefile.rules

@@ -1090,7 +1090,7 @@ testbugfix: all
 check: all
 	$(TESTGAP) $(top_srcdir)/tst/testinstall.g
 
-LIBGAPTESTS := $(addprefix tst/testlibgap/,basic api wscreate wsload)
+LIBGAPTESTS := $(addprefix tst/testlibgap/,basic api wscreate wsload trycatch)
 
 # run a test in tst/testlibgap
 tst/testlibgap/%: build/obj/tst/testlibgap/%.c.lo build/obj/tst/testlibgap/common.c.lo libgap.la

src/sysjmp.c

@@ -28,10 +28,9 @@ enum { signalSyLongjmpFuncsLen = 16 };
 
 static voidfunc signalSyLongjmpFuncs[signalSyLongjmpFuncsLen];
 
-Int RegisterSyLongjmpObserver(voidfunc func)
+int RegisterSyLongjmpObserver(voidfunc func)
 {
-    Int i;
-    for (i = 0; i < signalSyLongjmpFuncsLen; ++i) {
+    for (int i = 0; i < signalSyLongjmpFuncsLen; ++i) {
         if (signalSyLongjmpFuncs[i] == func) {
             return 1;
         }
@@ -43,10 +42,33 @@ Int RegisterSyLongjmpObserver(voidfunc func)
     return 0;
 }
 
+enum { tryCatchFuncsLen = 16 };
+
+static TryCatchHandler tryCatchFuncs[tryCatchFuncsLen];
+
+int RegisterTryCatchHandler(TryCatchHandler func)
+{
+    for (int i = 0; i < tryCatchFuncsLen; ++i) {
+        if (tryCatchFuncs[i] == func) {
+            return 1;
+        }
+        if (tryCatchFuncs[i] == 0) {
+            tryCatchFuncs[i] = func;
+            return 1;
+        }
+    }
+    return 0;
+}
+
+void InvokeTryCatchHandler(TryCatchMode mode)
+{
+    for (int i = 0; i < tryCatchFuncsLen && tryCatchFuncs[i]; ++i)
+        (tryCatchFuncs[i])(mode);
+}
+
 void GAP_THROW(void)
 {
-    Int i;
-    for (i = 0; i < signalSyLongjmpFuncsLen && signalSyLongjmpFuncs[i]; ++i)
+    for (int i = 0; i < signalSyLongjmpFuncsLen && signalSyLongjmpFuncs[i]; ++i)
         (signalSyLongjmpFuncs[i])();
     longjmp(STATE(ReadJmpError), 1);
 }

src/sysjmp.h

@@ -25,6 +25,6 @@
 **  This function is idempotent -- if a function is passed multiple times
 **  it is still only registered once.
 */
-Int RegisterSyLongjmpObserver(voidfunc);
+int RegisterSyLongjmpObserver(voidfunc);
 
 #endif    // GAP_SYSJMP_H

src/trycatch.h

@@ -15,9 +15,37 @@
 
 #include "funcs.h"    // for SetRecursionDepth
 #include "gapstate.h"
+#include "system.h"    // for NORETURN
 
 #include <string.h>    // for memcpy
 
+/****************************************************************************
+**
+*T  TryCatchMode
+*T  TryCatchHandler
+*F  RegisterTryCatchHandler()
+*F  InvokeTryCatchHandler()
+**
+**  The function RegisterTryCatchObserver() allows the installation of
+**  global exception handlers that are being called whenever GAP_TRY or
+**  CALL_WITH_CATCH() code is executed. It returns 1 if installing the
+**  handler was successful, 0 otherwise. Installation can only fail if one
+**  attempts to install more handlers than the allotted maximum (currently
+**  16).
+**
+**  The mode parameter of the handler function signals whether it has been
+**  called at the beginning of the section, at the end of the section
+**  without an error being raised, or at the end of a section with an error
+**  being raised, respectively. The function InvokeTryCatchObserver() is
+**  used to invoke those handlers as needed.
+*/
+typedef enum { TryEnter = 0, TryLeave = 1, TryCatch = 2 } TryCatchMode;
+
+typedef void (*TryCatchHandler)(TryCatchMode mode);
+
+int  RegisterTryCatchHandler(TryCatchHandler func);
+void InvokeTryCatchHandler(TryCatchMode mode);
+
 
 /****************************************************************************
 **
@@ -60,12 +88,14 @@
     jmp_buf      gap__jmp_buf;                                               \
     volatile Int gap__recursionDepth = GetRecursionDepth();                  \
     memcpy(gap__jmp_buf, STATE(ReadJmpError), sizeof(jmp_buf));              \
+    InvokeTryCatchHandler(TryEnter);                                         \
     if (!setjmp(STATE(ReadJmpError)))                                        \
         for (gap__i = 1; gap__i; gap__i = 0,                                 \
+            InvokeTryCatchHandler(TryLeave),                                 \
             gap_restore_trycatch(gap__jmp_buf, gap__recursionDepth))
 
 #define GAP_CATCH                                                            \
-    else for (gap__j = 1,                                                    \
+    else for (gap__j = 1, InvokeTryCatchHandler(TryCatch),                   \
               gap_restore_trycatch(gap__jmp_buf, gap__recursionDepth);       \
               gap__j; gap__j = 0)
 

tst/testlibgap/trycatch.c

@@ -0,0 +1,42 @@
+/*
+ * Small program to test libgap linkability and basic working
+ */
+#include "trycatch.h"
+#include "common.h"
+
+static int level = 0;
+
+static void handle_trycatch(TryCatchMode mode)
+{
+    switch (mode) {
+    case TryEnter:
+        level++;
+        if (level == 1)
+            printf("Entering GAP_TRY section\n");
+        break;
+    case TryLeave:
+        if (level == 1)
+            printf("Leaving GAP_TRY section\n");
+        level--;
+        break;
+    case TryCatch:
+        if (level == 1)
+            printf("Caught error in GAP_TRY section\n");
+        level--;
+        break;
+    }
+}
+
+int main(int argc, char ** argv)
+{
+    printf("# Initializing GAP...\n");
+    GAP_Initialize(argc, argv, 0, 0, 1);
+    RegisterTryCatchHandler(handle_trycatch);
+    test_eval("OnBreak := false;;");
+    // Necessary to redirect error printing to stdout.
+    test_eval("MakeReadWriteGVar(\"ERROR_OUTPUT\");");
+    test_eval("ERROR_OUTPUT := MakeImmutable(\"*stdout*\");;");
+    test_eval("Display(CALL_WITH_CATCH(function() return 314; end, []));;");
+    test_eval("Display(CALL_WITH_CATCH(function() return [][1]; end, []));;");
+    return 0;
+}

tst/testlibgap/trycatch.expect

@@ -0,0 +1,18 @@
+# Initializing GAP...
+gap> OnBreak := false;;
+
+gap> MakeReadWriteGVar("ERROR_OUTPUT");
+
+gap> ERROR_OUTPUT := MakeImmutable("*stdout*");;
+
+gap> Display(CALL_WITH_CATCH(function() return 314; end, []));;
+Entering GAP_TRY section
+Leaving GAP_TRY section
+[ true, 314 ]
+
+gap> Display(CALL_WITH_CATCH(function() return [][1]; end, []));;
+Entering GAP_TRY section
+Error, List Element: <list>[1] must have an assigned value
+Caught error in GAP_TRY section
+[ false, 0 ]
+