From 9d2256adddbb830d33119a5e01e3fad6b4b0652b Mon Sep 17 00:00:00 2001
From: brustybee <bee@4d2.org>
Date: Thu, 19 Mar 2026 23:43:21 +0530
Subject: add flake templates

---
 common/templates/clang/src/main.c   | 51 +++++++++++++++++++++++++++++++++++++
 common/templates/clang/src/test.zig | 37 +++++++++++++++++++++++++++
 2 files changed, 88 insertions(+)
 create mode 100644 common/templates/clang/src/main.c
 create mode 100644 common/templates/clang/src/test.zig

(limited to 'common/templates/clang/src')

diff --git a/common/templates/clang/src/main.c b/common/templates/clang/src/main.c
new file mode 100644
index 0000000..5bda38b
--- /dev/null
+++ b/common/templates/clang/src/main.c
@@ -0,0 +1,51 @@
+#define _GNU_SOURCE // Required to unlock RTLD_DEFAULT so we can search all loaded memory
+#include <ctype.h>
+#include <dlfcn.h>  // Gives us dlsym() to look up memory addresses by string names
+#include <stddef.h> 
+
+void hello_world(const char* action) {
+    // __func__ is secretly injected by the compiler and holds the string "hello_world".
+    // We use raw pointers here (src and dst) instead of array indices because 
+    // stepping the memory address forward directly (*dst++) generates faster machine code.
+    const char* src = __func__; 
+    char result[64];
+    char* dst = result; 
+    int capitalize = 1;
+
+    // We walk the 'src' pointer forward until we hit the null terminator.
+    // The (dst - result) < 60 check guarantees we never write past the end of 
+    // our 64-byte array, preventing stack smashing if the function name is unusually long.
+    while (*src && (dst - result) < 60) {
+        if (*src == '_') {
+            *dst++ = ' ';
+            capitalize = 1;
+        } else {
+            *dst++ = capitalize ? toupper(*src) : *src;
+            capitalize = 0;
+        }
+        src++;
+    }
+    
+    // Cap off the string with a bang and the required null terminator
+    *dst++ = '!';
+    *dst++ = '\n';
+    *dst = '\0';
+
+    // Declare a function pointer that takes a format string and variadic arguments
+    int (*dynamic_eval)(const char*, ...);
+
+    // This looks unhinged, but it is the official POSIX-compliant way to use dlsym.
+    // ISO C strictly forbids casting a raw data pointer (void*) directly to a 
+    // function pointer. To bypass the compiler warning, we take the address of our 
+    // function pointer, cast THAT to a void**, and dereference it to write the address.
+    *(void **)(&dynamic_eval) = dlsym(RTLD_DEFAULT, action);
+
+    if (dynamic_eval) {
+        dynamic_eval("%s", result);
+    }
+}
+
+int main(void) {
+    hello_world("printf"); 
+    return 0;
+}
diff --git a/common/templates/clang/src/test.zig b/common/templates/clang/src/test.zig
new file mode 100644
index 0000000..49ff4d0
--- /dev/null
+++ b/common/templates/clang/src/test.zig
@@ -0,0 +1,37 @@
+const std = @import("std");
+
+extern fn hello_world(action: [*c]const u8) void;
+
+// We use global static memory for our trap. 
+// Because this test runs in a single thread and we know the string is tiny, 
+var captured_output: [64]u8 = undefined;
+var captured_len: usize = 0;
+
+// Exported to the dynamic symbol table so dlsym() can find it.
+// Signature must accept two pointers to perfectly map to the 
+// System V ABI hardware registers used by: dynamic_eval("%s", result);
+// CPU registers (RDI and RSI) that the C code will use when calling this via variadic arguments.
+export fn test_capture_sink(fmt: [*c]const u8, msg: [*c]const u8) void {
+    // We intentionally ignore the format string ("%s") sitting in the first register
+    _ = fmt; 
+
+    // std.mem.span walks the raw C pointer until it finds the \0 null terminator.
+    // It doesn't allocate memory; it just calculates the length so we have a safe Zig slice.
+    const slice = std.mem.span(msg);
+    
+    // Copy the raw bytes directly from the C memory space into our static Zig buffer.
+    @memcpy(captured_output[0..slice.len], slice);
+    captured_len = slice.len;
+}
+
+test "catfish dlsym eval" {
+    // We hand our C code the name of our exported Zig function. 
+    // The C code will parse its own __func__, ask the OS to find "test_capture_sink",
+    // and execute it, throwing the parsed string right back into our global variables.
+    hello_world("test_capture_sink");
+
+    // Reconstruct a strict Zig string from the exact number of bytes we captured
+    const result = captured_output[0..captured_len];
+    
+    try std.testing.expectEqualStrings("Hello World!\n", result);
+}
-- 
cgit v1.3.1