gh-120: Fix extension hook registration.

The previous commit's message was incorrect. That commit was actually addressing gh-119.

Author: python-processing-unit

src/extensions.c

@@ -39,6 +39,26 @@ static char* g_cwd_dir = NULL;
 static const char* g_loading_extension_name = NULL;
 static const char* g_loading_scope_name = NULL;
 
+// Registered event handlers and periodic hooks
+typedef struct EventHandler {
+    char* event_name;
+    prefix_event_fn fn;
+    char* owner;
+    struct EventHandler* next;
+} EventHandler;
+
+typedef struct PeriodicHook {
+    int n;
+    prefix_event_fn fn;
+    char* owner;
+    struct PeriodicHook* next;
+} PeriodicHook;
+
+static EventHandler* g_event_handlers = NULL;
+static PeriodicHook* g_periodic_hooks = NULL;
+static prefix_repl_fn g_repl_handler = NULL;
+static char* g_repl_owner = NULL;
+
 static void set_error(char** error_out, const char* msg) {
     if (!error_out) return;
     free(*error_out);
@@ -389,19 +409,41 @@ static int ctx_register_operator(const char* name, prefix_operator_fn fn, int fl
 }
 
 static int ctx_register_periodic_hook(int n, prefix_event_fn fn) {
-    (void)n;
-    (void)fn;
+    if (n <= 0 || !fn) return -1;
+    PeriodicHook* h = calloc(1, sizeof(PeriodicHook));
+    if (!h) return -1;
+    h->n = n;
+    h->fn = fn;
+    h->owner = g_loading_extension_name ? strdup(g_loading_extension_name) : strdup("extension");
+    if (!h->owner) { free(h); return -1; }
+    h->next = g_periodic_hooks;
+    g_periodic_hooks = h;
     return 0;
 }
 
 static int ctx_register_event_handler(const char* event_name, prefix_event_fn fn) {
-    (void)event_name;
-    (void)fn;
+    if (!event_name || !fn) return -1;
+    EventHandler* h = calloc(1, sizeof(EventHandler));
+    if (!h) return -1;
+    h->event_name = strdup(event_name);
+    if (!h->event_name) { free(h); return -1; }
+    h->fn = fn;
+    h->owner = g_loading_extension_name ? strdup(g_loading_extension_name) : strdup("extension");
+    if (!h->owner) { free(h->event_name); free(h); return -1; }
+    h->next = g_event_handlers;
+    g_event_handlers = h;
     return 0;
 }
 
 static int ctx_register_repl_handler(prefix_repl_fn repl_fn) {
-    (void)repl_fn;
+    if (!repl_fn) return -1;
+    g_repl_handler = repl_fn;
+    free(g_repl_owner);
+    g_repl_owner = g_loading_extension_name ? strdup(g_loading_extension_name) : strdup("extension");
+    if (!g_repl_owner) {
+        // keep handler but owner strdup failed; set to NULL
+        g_repl_owner = NULL;
+    }
     return 0;
 }
 
@@ -448,6 +490,35 @@ void extensions_set_runtime_dirs(const char* interpreter_dir, const char* cwd_di
     g_cwd_dir = cwd_dir ? strdup(cwd_dir) : NULL;
 }
 
+int extensions_fire_event(Interpreter* interp, const char* event_name) {
+    if (!event_name) return 0;
+    int invoked = 0;
+    for (EventHandler* h = g_event_handlers; h; h = h->next) {
+        if (h->event_name && strcmp(h->event_name, event_name) == 0) {
+            if (h->fn) h->fn(interp, event_name);
+            invoked++;
+        }
+    }
+    return invoked;
+}
+
+void extensions_run_periodic_hooks(Interpreter* interp) {
+    if (!interp) return;
+    if (!g_periodic_hooks) return;
+    int step_index = interp->trace_next_step_index - 1;
+    if (step_index < 0) return;
+    for (PeriodicHook* p = g_periodic_hooks; p; p = p->next) {
+        if (p->n > 0 && (step_index % p->n) == 0) {
+            if (p->fn) p->fn(interp, "periodic");
+        }
+    }
+}
+
+int extensions_call_repl_handler(void) {
+    if (!g_repl_handler) return -1;
+    return g_repl_handler();
+}
+
 static int extension_register_exposure(LoadedExtension* le,
                                        const char* ext_name,
                                        const char* scope_name,
@@ -647,4 +718,30 @@ void extensions_shutdown(void) {
 
     g_loading_extension_name = NULL;
     g_loading_scope_name = NULL;
+
+    // Free registered event handlers
+    EventHandler* eh = g_event_handlers;
+    while (eh) {
+        EventHandler* en = eh->next;
+        free(eh->event_name);
+        free(eh->owner);
+        free(eh);
+        eh = en;
+    }
+    g_event_handlers = NULL;
+
+    // Free periodic hooks
+    PeriodicHook* ph = g_periodic_hooks;
+    while (ph) {
+        PeriodicHook* pn = ph->next;
+        free(ph->owner);
+        free(ph);
+        ph = pn;
+    }
+    g_periodic_hooks = NULL;
+
+    // Repl handler owner
+    free(g_repl_owner);
+    g_repl_owner = NULL;
+    g_repl_handler = NULL;
 }

src/extensions.h

@@ -2,6 +2,7 @@
 #define EXTENSIONS_H
 
 #include "common.h"
+#include "interpreter.h"
 
 // Configure directories used for extension-path fallback resolution.
 // interpreter_dir should be the directory containing the interpreter executable.
@@ -28,4 +29,17 @@ int extensions_load_named(const char* spec,
 // Unload all loaded extension libraries.
 void extensions_shutdown(void);
 
+// Fire a named event to all registered event handlers. Returns number of
+// handlers invoked (may be 0).
+int extensions_fire_event(Interpreter* interp, const char* event_name);
+
+// Evaluate and invoke any periodic hooks that are due at the interpreter's
+// current rewrite step. Safe to call after a step has been logged.
+void extensions_run_periodic_hooks(Interpreter* interp);
+
+// If a REPL replacement handler has been registered by an extension, call
+// it and return its integer return-code. Returns -1 if no repl handler is
+// registered.
+int extensions_call_repl_handler(void);
+
 #endif // EXTENSIONS_H

src/interpreter.c

@@ -1,6 +1,7 @@
 #include "interpreter.h"
 #include "builtins.h"
 #include "ns_buffer.h"
+#include "extensions.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -1666,7 +1667,10 @@ Value eval_expr(Interpreter* interp, Expr* expr, Env* env) {
             }
 
             LabelMap local_labels = {0};
+            // Notify extensions about call boundaries
+            extensions_fire_event(interp, "before_call");
             ExecResult res = exec_stmt(interp, user_func->body, call_env, &local_labels);
+            extensions_fire_event(interp, "after_call");
 
             // Clean up labels
             for (size_t i = 0; i < local_labels.count; i++) value_free(local_labels.items[i].key);
@@ -2553,6 +2557,11 @@ static ExecResult exec_stmt(Interpreter* interp, Stmt* stmt, Env* env, LabelMap*
     if (!stmt) return make_ok(value_null());
     trace_log_step(interp, stmt, env);
 
+    // Run any periodic hooks that are due for this rewrite step and notify
+    // extensions that a statement is about to execute.
+    extensions_run_periodic_hooks(interp);
+    extensions_fire_event(interp, "before_statement");
+
     // If running in a background thread and a STOP has been requested for
     // this thread, terminate execution cooperatively by returning early.
     if (interpreter_thr_should_stop(interp)) {
@@ -3555,6 +3564,8 @@ static ExecResult exec_stmt_list(Interpreter* interp, StmtList* list, Env* env,
     while (i < list->count) {
         wait_if_paused(interp);
         ExecResult res = exec_stmt(interp, list->items[i], env, labels);
+        // Notify extensions that a statement has completed (regardless of outcome)
+        extensions_fire_event(interp, "after_statement");
 
         if (res.status == EXEC_ERROR || res.status == EXEC_RETURN || 
             res.status == EXEC_BREAK || res.status == EXEC_CONTINUE) {
@@ -3667,12 +3678,16 @@ ExecResult exec_program(Stmt* program, const char* source_path) {
     interpreter_init(&interp, source_path, false, false);
 
     LabelMap labels = {0};
+    extensions_fire_event(&interp, "program_start");
     ExecResult res = exec_stmt_list(&interp, &program->as.block, interp.global_env, &labels);
 
     if (res.status == EXEC_ERROR) {
+        extensions_fire_event(&interp, "on_error");
         char* tb = interpreter_format_traceback(&interp, res.error, res.error_line, res.error_column);
         free(res.error);
         res.error = tb;
+    } else {
+        extensions_fire_event(&interp, "program_end");
     }
 
     // Clean up
@@ -3745,12 +3760,19 @@ ExecResult exec_program_in_env(Interpreter* interp, Stmt* program, Env* env) {
     }
 
     LabelMap labels = {0};
+    // Notify extensions program is starting
+    extensions_fire_event(interp, "program_start");
     ExecResult res = exec_stmt_list(interp, &program->as.block, env, &labels);
 
     if (res.status == EXEC_ERROR) {
+        // Notify extensions about the error
+        extensions_fire_event(interp, "on_error");
         char* tb = interpreter_format_traceback(interp, res.error, res.error_line, res.error_column);
         free(res.error);
         res.error = tb;
+    } else {
+        // Notify extensions program ended normally
+        extensions_fire_event(interp, "program_end");
     }
 
     for (size_t i = 0; i < labels.count; i++) value_free(labels.items[i].key);

src/main.c

@@ -317,7 +317,13 @@ int main(int argc, char** argv) {
     }
 
     if (!path && !source_mode) {
-        int repl_rc = run_repl(verbose_flag, private_flag);
+        int repl_rc = extensions_call_repl_handler();
+        if (repl_rc >= 0) {
+            extensions_shutdown();
+            builtins_reset_dynamic();
+            return repl_rc;
+        }
+        repl_rc = run_repl(verbose_flag, private_flag);
         extensions_shutdown();
         builtins_reset_dynamic();
         return repl_rc;

src/prefix_runtime.def

@@ -144,4 +144,7 @@ EXPORTS
     value_alias
     value_deep_copy
     value_free
-    value_type_name
+    value_type_name
+    extensions_fire_event
+    extensions_run_periodic_hooks
+    extensions_call_repl_handler