rubyduino 0.1.1

data/vendor/spinel/lib/stringio.c

@@ -0,0 +1,286 @@
+/*
+ * stringio.c — StringIO C implementation for Spinel
+ *
+ * Provides sp_StringIO_* functions that the generated C code calls.
+ * In-memory IO object with a growable string buffer.
+ *
+ * Usage: cc -O2 app.c lib/stringio.c -lm -o app
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdarg.h>
+
+typedef struct {
+  char *buf;        /* heap-allocated buffer */
+  int64_t len;      /* current string length */
+  int64_t cap;      /* buffer capacity */
+  int64_t pos;      /* current read/write position */
+  int64_t lineno;   /* line number counter (for gets) */
+  int closed;       /* 1 if closed */
+} sp_StringIO;
+
+/* Internal: ensure buffer has room for `need` more bytes */
+static void sio_grow(sp_StringIO *sio, int64_t need) {
+  int64_t required = sio->pos + need;
+  if (required <= sio->cap) return;
+  int64_t new_cap = sio->cap ? sio->cap : 64;
+  while (new_cap < required) new_cap *= 2;
+  sio->buf = (char *)realloc(sio->buf, new_cap + 1);
+  sio->cap = new_cap;
+}
+
+/* Internal: write bytes at current position, extending buffer as needed */
+static int64_t sio_write(sp_StringIO *sio, const char *data, int64_t data_len) {
+  sio_grow(sio, data_len);
+  /* Fill gap with zeros if pos > len */
+  if (sio->pos > sio->len) {
+    memset(sio->buf + sio->len, 0, sio->pos - sio->len);
+  }
+  memcpy(sio->buf + sio->pos, data, data_len);
+  sio->pos += data_len;
+  if (sio->pos > sio->len) sio->len = sio->pos;
+  sio->buf[sio->len] = '\0';
+  return data_len;
+}
+
+/* Constructor: StringIO.new or StringIO.new("initial") */
+sp_StringIO *sp_StringIO_new(void) {
+  sp_StringIO *sio = (sp_StringIO *)calloc(1, sizeof(sp_StringIO));
+  sio->buf = (char *)calloc(1, 64);
+  sio->cap = 63;
+  return sio;
+}
+
+sp_StringIO *sp_StringIO_new_s(const char *initial) {
+  sp_StringIO *sio = (sp_StringIO *)calloc(1, sizeof(sp_StringIO));
+  int64_t len = (int64_t)strlen(initial);
+  int64_t cap = len < 63 ? 63 : len;
+  sio->buf = (char *)malloc(cap + 1);
+  memcpy(sio->buf, initial, len);
+  sio->buf[len] = '\0';
+  sio->len = len;
+  sio->cap = cap;
+  sio->pos = 0;
+  return sio;
+}
+
+/* string — return the buffer contents as a C string */
+const char *sp_StringIO_string(sp_StringIO *sio) {
+  return sio->buf ? sio->buf : "";
+}
+
+/* pos / tell — current position */
+int64_t sp_StringIO_pos(sp_StringIO *sio) {
+  return sio->pos;
+}
+
+/* pos= — set position */
+int64_t sp_StringIO_set_pos(sp_StringIO *sio, int64_t new_pos) {
+  if (new_pos < 0) new_pos = 0;
+  sio->pos = new_pos;
+  return sio->pos;
+}
+
+/* lineno */
+int64_t sp_StringIO_lineno(sp_StringIO *sio) {
+  return sio->lineno;
+}
+
+/* size / length — string length */
+int64_t sp_StringIO_size(sp_StringIO *sio) {
+  return sio->len;
+}
+
+/* write(str) — write string at current position, return bytes written */
+int64_t sp_StringIO_write(sp_StringIO *sio, const char *str) {
+  return sio_write(sio, str, (int64_t)strlen(str));
+}
+
+/* puts(str) — write string + newline */
+int64_t sp_StringIO_puts(sp_StringIO *sio, const char *str) {
+  int64_t slen = (int64_t)strlen(str);
+  sio_write(sio, str, slen);
+  /* Add newline unless string already ends with one */
+  if (slen == 0 || str[slen - 1] != '\n')
+    sio_write(sio, "\n", 1);
+  return 0;  /* Ruby puts returns nil */
+}
+
+/* puts() with no args — just a newline */
+int64_t sp_StringIO_puts_empty(sp_StringIO *sio) {
+  sio_write(sio, "\n", 1);
+  return 0;
+}
+
+/* print(str) — write string without newline */
+int64_t sp_StringIO_print(sp_StringIO *sio, const char *str) {
+  return sio_write(sio, str, (int64_t)strlen(str));
+}
+
+/* putc(ch) — write a single character (integer or first char of string) */
+int64_t sp_StringIO_putc(sp_StringIO *sio, int64_t ch) {
+  char c = (char)(ch & 0xFF);
+  sio_write(sio, &c, 1);
+  return ch;
+}
+
+/* << operator — append, return self (for chaining) */
+sp_StringIO *sp_StringIO_append(sp_StringIO *sio, const char *str) {
+  sio_write(sio, str, (int64_t)strlen(str));
+  return sio;
+}
+
+/* read() — read from pos to end */
+const char *sp_StringIO_read(sp_StringIO *sio) {
+  if (sio->pos >= sio->len) return "";
+  const char *result = sio->buf + sio->pos;
+  sio->pos = sio->len;
+  return result;
+}
+
+/* read(length) — read up to length bytes */
+const char *sp_StringIO_read_n(sp_StringIO *sio, int64_t length) {
+  if (sio->pos >= sio->len) return NULL;
+  int64_t remaining = sio->len - sio->pos;
+  if (length > remaining) length = remaining;
+  /* Return a temporary substring — caller should copy if needed */
+  static char read_buf[65536];
+  if (length >= (int64_t)sizeof(read_buf)) length = sizeof(read_buf) - 1;
+  memcpy(read_buf, sio->buf + sio->pos, length);
+  read_buf[length] = '\0';
+  sio->pos += length;
+  return read_buf;
+}
+
+/* gets — read one line (up to and including \n), return NULL at EOF */
+const char *sp_StringIO_gets(sp_StringIO *sio) {
+  if (sio->pos >= sio->len) return NULL;
+  const char *start = sio->buf + sio->pos;
+  const char *nl = memchr(start, '\n', sio->len - sio->pos);
+  int64_t line_len;
+  if (nl) {
+    line_len = (nl - start) + 1;
+  }
+  else {
+    line_len = sio->len - sio->pos;
+  }
+  /* Return a temporary buffer */
+  static char gets_buf[65536];
+  if (line_len >= (int64_t)sizeof(gets_buf)) line_len = sizeof(gets_buf) - 1;
+  memcpy(gets_buf, start, line_len);
+  gets_buf[line_len] = '\0';
+  sio->pos += line_len;
+  sio->lineno++;
+  return gets_buf;
+}
+
+/* getc — read one character, return NULL at EOF */
+const char *sp_StringIO_getc(sp_StringIO *sio) {
+  if (sio->pos >= sio->len) return NULL;
+  static char getc_buf[2];
+  getc_buf[0] = sio->buf[sio->pos++];
+  getc_buf[1] = '\0';
+  return getc_buf;
+}
+
+/* getbyte — read one byte as integer, return -1 at EOF */
+int64_t sp_StringIO_getbyte(sp_StringIO *sio) {
+  if (sio->pos >= sio->len) return -1;
+  return (int64_t)(unsigned char)sio->buf[sio->pos++];
+}
+
+/* rewind — reset position and lineno to 0 */
+int64_t sp_StringIO_rewind(sp_StringIO *sio) {
+  sio->pos = 0;
+  sio->lineno = 0;
+  return 0;
+}
+
+/* seek(offset, whence) — set position, whence: 0=SET, 1=CUR, 2=END */
+int64_t sp_StringIO_seek(sp_StringIO *sio, int64_t offset, int64_t whence) {
+  int64_t new_pos;
+  switch (whence) {
+  case 1: new_pos = sio->pos + offset; break;   /* SEEK_CUR */
+  case 2: new_pos = sio->len + offset; break;    /* SEEK_END */
+  default: new_pos = offset; break;               /* SEEK_SET */
+  }
+  if (new_pos < 0) new_pos = 0;
+  sio->pos = new_pos;
+  return 0;
+}
+
+/* eof? — true if at or past end */
+int sp_StringIO_eof_p(sp_StringIO *sio) {
+  return sio->pos >= sio->len;
+}
+
+/* truncate(length) — truncate buffer to given length */
+int64_t sp_StringIO_truncate(sp_StringIO *sio, int64_t length) {
+  if (length < 0) length = 0;
+  if (length < sio->len) {
+    sio->len = length;
+    sio->buf[length] = '\0';
+  }
+  return 0;
+}
+
+/* close — mark as closed */
+int64_t sp_StringIO_close(sp_StringIO *sio) {
+  sio->closed = 1;
+  return 0;
+}
+
+/* closed? */
+int sp_StringIO_closed_p(sp_StringIO *sio) {
+  return sio->closed;
+}
+
+/* flush — no-op for StringIO, return self */
+sp_StringIO *sp_StringIO_flush(sp_StringIO *sio) {
+  return sio;
+}
+
+/* sync — always true */
+int sp_StringIO_sync(sp_StringIO *sio) {
+  (void)sio;
+  return 1;
+}
+
+/* isatty / tty? — always false */
+int sp_StringIO_isatty(sp_StringIO *sio) {
+  (void)sio;
+  return 0;
+}
+
+/* fileno — nil (returns -1 for C) */
+int64_t sp_StringIO_fileno(sp_StringIO *sio) {
+  (void)sio;
+  return -1;
+}
+
+/* printf(fmt, ...) — formatted print to buffer */
+int64_t sp_StringIO_printf(sp_StringIO *sio, const char *fmt, ...) {
+  char tmp[8192];
+  va_list ap;
+  va_start(ap, fmt);
+  int n = vsnprintf(tmp, sizeof(tmp), fmt, ap);
+  va_end(ap);
+  if (n > 0) sio_write(sio, tmp, n);
+  return n;
+}
+
+/* string= — replace buffer contents */
+void sp_StringIO_set_string(sp_StringIO *sio, const char *str) {
+  int64_t len = (int64_t)strlen(str);
+  if (len > sio->cap) {
+    sio->cap = len;
+    sio->buf = (char *)realloc(sio->buf, sio->cap + 1);
+  }
+  memcpy(sio->buf, str, len);
+  sio->buf[len] = '\0';
+  sio->len = len;
+  sio->pos = 0;
+}

data/vendor/spinel/lib/stringio.rb

@@ -0,0 +1,5 @@
+# Spinel lib: stringio
+#
+# StringIO is a built-in type in Spinel (SPINEL_TYPE_STRINGIO).
+# This file exists only so that `require "stringio"` resolves successfully.
+# All StringIO methods are compiled directly to sp_StringIO_* C functions.

data/vendor/spinel/lib/strscan.c

@@ -0,0 +1,170 @@
+/*
+ * strscan.c — StringScanner C implementation for Spinel
+ *
+ * Provides sp_StringScanner_* functions that the generated C code calls.
+ * Requires oniguruma: link with -lonig
+ *
+ * Usage: cc -O2 app.c lib/strscan.c -lonig -lm -o app
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <oniguruma.h>
+
+typedef struct {
+    const char *source;  /* original string (not owned) */
+    int64_t source_len;
+    int64_t pos;         /* current scan position */
+    int64_t last_pos;    /* position before last scan (for unscan) */
+    char *matched;       /* last matched string (heap-allocated) */
+    int64_t matched_len;
+} sp_StringScanner;
+
+/* Constructor */
+sp_StringScanner *sp_StringScanner_new(const char *str) {
+    sp_StringScanner *sc = (sp_StringScanner *)calloc(1, sizeof(sp_StringScanner));
+    sc->source = str;
+    sc->source_len = (int64_t)strlen(str);
+    sc->pos = 0;
+    sc->last_pos = 0;
+    sc->matched = NULL;
+    sc->matched_len = 0;
+    return sc;
+}
+
+/* Internal: set matched string */
+static void sc_set_matched(sp_StringScanner *sc, const char *start, int64_t len) {
+    free(sc->matched);
+    sc->matched = (char *)malloc(len + 1);
+    memcpy(sc->matched, start, len);
+    sc->matched[len] = '\0';
+    sc->matched_len = len;
+}
+
+/* scan(pattern) — match at current position, advance if matched */
+const char *sp_StringScanner_scan(sp_StringScanner *sc, regex_t *re) {
+    if (sc->pos >= sc->source_len) return NULL;
+
+    OnigRegion *region = onig_region_new();
+    const OnigUChar *str = (const OnigUChar *)sc->source;
+    const OnigUChar *end = str + sc->source_len;
+    const OnigUChar *start = str + sc->pos;
+
+    /* Match must start at current position */
+    int r = onig_match(re, str, end, start, region, ONIG_OPTION_NONE);
+
+    if (r >= 0) {
+        sc->last_pos = sc->pos;
+        int64_t match_len = (int64_t)r;
+        sc_set_matched(sc, sc->source + sc->pos, match_len);
+        sc->pos += match_len;
+        onig_region_free(region, 1);
+        return sc->matched;
+    }
+
+    onig_region_free(region, 1);
+    free(sc->matched);
+    sc->matched = NULL;
+    sc->matched_len = 0;
+    return NULL;
+}
+
+/* check(pattern) — match at current position, do NOT advance */
+const char *sp_StringScanner_check(sp_StringScanner *sc, regex_t *re) {
+    if (sc->pos >= sc->source_len) return NULL;
+
+    OnigRegion *region = onig_region_new();
+    const OnigUChar *str = (const OnigUChar *)sc->source;
+    const OnigUChar *end = str + sc->source_len;
+    const OnigUChar *start = str + sc->pos;
+
+    int r = onig_match(re, str, end, start, region, ONIG_OPTION_NONE);
+
+    if (r >= 0) {
+        sc_set_matched(sc, sc->source + sc->pos, (int64_t)r);
+        onig_region_free(region, 1);
+        return sc->matched;
+    }
+
+    onig_region_free(region, 1);
+    free(sc->matched);
+    sc->matched = NULL;
+    return NULL;
+}
+
+/* scan_until(pattern) — scan forward until pattern matches, return everything up to end of match */
+const char *sp_StringScanner_scan_until(sp_StringScanner *sc, regex_t *re) {
+    if (sc->pos >= sc->source_len) return NULL;
+
+    OnigRegion *region = onig_region_new();
+    const OnigUChar *str = (const OnigUChar *)sc->source;
+    const OnigUChar *end = str + sc->source_len;
+    const OnigUChar *start = str + sc->pos;
+
+    int r = onig_search(re, str, end, start, end, region, ONIG_OPTION_NONE);
+
+    if (r >= 0) {
+        sc->last_pos = sc->pos;
+        int64_t total_len = region->end[0] - sc->pos;
+        sc_set_matched(sc, sc->source + sc->pos, total_len);
+        sc->pos = region->end[0];
+        onig_region_free(region, 1);
+        return sc->matched;
+    }
+
+    onig_region_free(region, 1);
+    return NULL;
+}
+
+/* matched — return last matched string */
+const char *sp_StringScanner_matched(sp_StringScanner *sc) {
+    return sc->matched ? sc->matched : "";
+}
+
+/* pos — current position */
+int64_t sp_StringScanner_pos(sp_StringScanner *sc) {
+    return sc->pos;
+}
+
+/* eos? — at end of string? */
+int sp_StringScanner_eos_p(sp_StringScanner *sc) {
+    return sc->pos >= sc->source_len;
+}
+
+/* getch — get one character and advance */
+const char *sp_StringScanner_getch(sp_StringScanner *sc) {
+    if (sc->pos >= sc->source_len) return NULL;
+    sc->last_pos = sc->pos;
+    char *ch = (char *)malloc(2);
+    ch[0] = sc->source[sc->pos];
+    ch[1] = '\0';
+    free(sc->matched);
+    sc->matched = ch;
+    sc->matched_len = 1;
+    sc->pos++;
+    return sc->matched;
+}
+
+/* peek(n) — look ahead n characters without advancing */
+const char *sp_StringScanner_peek(sp_StringScanner *sc, int64_t n) {
+    if (sc->pos >= sc->source_len) return "";
+    int64_t remaining = sc->source_len - sc->pos;
+    if (n > remaining) n = remaining;
+    char *buf = (char *)malloc(n + 1);
+    memcpy(buf, sc->source + sc->pos, n);
+    buf[n] = '\0';
+    return buf;
+}
+
+/* unscan — revert to position before last scan */
+sp_StringScanner *sp_StringScanner_unscan(sp_StringScanner *sc) {
+    sc->pos = sc->last_pos;
+    return sc;
+}
+
+/* rest — remaining string from current position */
+const char *sp_StringScanner_rest(sp_StringScanner *sc) {
+    return sc->source + sc->pos;
+}

data/vendor/spinel/lib/strscan.rb

@@ -0,0 +1,55 @@
+# Spinel lib: strscan
+#
+# StringScanner — sequential string scanning with regexp.
+# Type definitions for Spinel. C implementation in lib/strscan.c.
+#
+# Link with: cc app.c lib/strscan.c -lonig -lm -o app
+
+class StringScanner
+  def initialize(str)
+    @source = str
+    @pos = 0
+    @matched = ""
+    @last_pos = 0
+  end
+
+  def scan(pattern)
+    @matched
+  end
+
+  def check(pattern)
+    @matched
+  end
+
+  def scan_until(pattern)
+    @matched
+  end
+
+  def matched
+    @matched
+  end
+
+  def pos
+    @pos
+  end
+
+  def eos?
+    @pos >= @source.length
+  end
+
+  def getch
+    @matched
+  end
+
+  def peek(n)
+    @matched
+  end
+
+  def unscan
+    self
+  end
+
+  def rest
+    @source
+  end
+end

data/vendor/spinel/spinel

@@ -0,0 +1,191 @@
+#!/bin/sh
+# Spinel AOT Compiler - Ruby to native binary
+#
+# Usage:
+#   spinel app.rb                  - compiles to ./app
+#   spinel app.rb -o myapp         - compiles to ./myapp
+#   spinel app.rb -c               - generate C only (app.c)
+#   spinel app.rb -c -o app.c     - generate C to specific file
+#   spinel app.rb -S               - print C to stdout
+#   spinel -e 'puts 42'            - compile inline source (default name: a)
+#
+# Options:
+#   -o FILE    Output file (binary or C depending on -c)
+#   -c         Generate C source only, don't compile
+#   -S         Print generated C to stdout
+#   -O LEVEL   Optimization level for cc (default: 2)
+#   --cc=CMD   C compiler command (default: cc)
+#   -e STR     Inline Ruby source (repeatable; multiple -e join with \n)
+
+DIR="$(cd "$(dirname "$(readlink -f "$0" 2>/dev/null || realpath "$0" 2>/dev/null || echo "$0")")" && pwd)"
+PARSE_BIN="$DIR/spinel_parse"
+CODEGEN_RB="$DIR/spinel_codegen.rb"
+CODEGEN_BIN="$DIR/spinel_codegen"
+
+# On Windows (MSYS2 / Cygwin / MinGW) the compiled binaries carry a .exe
+# suffix; fall back to that when the unsuffixed path is absent.
+case "$(uname -s 2>/dev/null)" in
+  MINGW*|MSYS*|CYGWIN*)
+    [ ! -x "$PARSE_BIN"   ] && [ -x "$PARSE_BIN.exe"   ] && PARSE_BIN="$PARSE_BIN.exe"
+    [ ! -x "$CODEGEN_BIN" ] && [ -x "$CODEGEN_BIN.exe" ] && CODEGEN_BIN="$CODEGEN_BIN.exe"
+    ;;
+esac
+
+SOURCE=""
+OUTPUT=""
+C_ONLY=0
+STDOUT_MODE=0
+OPT_LEVEL="2"
+CC_CMD="cc"
+EXTRA_FLAGS=""
+C_TMP=""
+EVAL_SCRIPT=""
+EVAL_USED=0
+EVAL_TMP=""
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --source=*) SOURCE="${1#--source=}" ;;
+    --output=*) OUTPUT="${1#--output=}" ;;
+    --cc=*)     CC_CMD="${1#--cc=}" ;;
+    -o)         shift; OUTPUT="$1" ;;
+    -O)         shift; OPT_LEVEL="$1" ;;
+    -e)         shift
+                if [ "$EVAL_USED" -eq 0 ]; then
+                  EVAL_SCRIPT="$1"
+                else
+                  EVAL_SCRIPT="$EVAL_SCRIPT
+$1"
+                fi
+                EVAL_USED=1 ;;
+    -c)         C_ONLY=1 ;;
+    -S)         STDOUT_MODE=1 ;;
+    *.rb)       [ -z "$SOURCE" ] && SOURCE="$1" ;;
+  esac
+  shift
+done
+
+# `-e` mode: write the accumulated inline script to a temp file and
+# treat it as the source. Default output name is `a` since the
+# inline form has no .rb basename to derive from. If both -e and a
+# .rb file were given, -e wins (consistent with `ruby -e ... script.rb`
+# where the .rb file becomes ARGV — Spinel only consumes the source).
+if [ "$EVAL_USED" -eq 1 ]; then
+  EVAL_TMP="$(mktemp /tmp/spinel_eval.XXXXXX).rb"
+  printf '%s\n' "$EVAL_SCRIPT" > "$EVAL_TMP"
+  SOURCE="$EVAL_TMP"
+fi
+
+if [ -z "$SOURCE" ]; then
+  echo "Spinel AOT Compiler" >&2
+  echo "" >&2
+  echo "Usage: spinel app.rb              - compile to ./app" >&2
+  echo "       spinel app.rb -o myapp     - compile to ./myapp" >&2
+  echo "       spinel app.rb -c           - generate app.c only" >&2
+  echo "       spinel app.rb -S           - print C to stdout" >&2
+  echo "       spinel -e 'puts 42'        - compile inline source" >&2
+  echo "" >&2
+  echo "Options:" >&2
+  echo "  -o FILE     Output file" >&2
+  echo "  -c          C source only (don't compile)" >&2
+  echo "  -S          Print C to stdout" >&2
+  echo "  -O LEVEL    Optimization level (default: 2)" >&2
+  echo "  --cc=CMD    C compiler (default: cc)" >&2
+  echo "  -e STR      Inline Ruby source (repeatable; joined with newlines)" >&2
+  exit 1
+fi
+
+if [ ! -f "$SOURCE" ]; then
+  echo "spinel: $SOURCE: No such file" >&2
+  exit 1
+fi
+
+if [ "$EVAL_USED" -eq 1 ]; then
+  BASENAME="a"
+else
+  BASENAME="$(basename "$SOURCE" .rb)"
+fi
+AST_TMP="$(mktemp /tmp/spinel_ast.XXXXXX)"
+trap 'rm -f "$AST_TMP" "$C_TMP" "$EVAL_TMP"' EXIT
+
+# Step 1: Parse. spinel_parse is C-only; build it via `make parse`
+# (or `make all`) before invoking spinel.
+if [ ! -x "$PARSE_BIN" ]; then
+  echo "spinel: parser binary not found at $PARSE_BIN; run 'make parse' or 'make all' first" >&2
+  exit 1
+fi
+"$PARSE_BIN" "$SOURCE" "$AST_TMP"
+if [ $? -ne 0 ]; then
+  echo "spinel: parse failed" >&2
+  exit 1
+fi
+
+# Step 2: Codegen
+if [ $STDOUT_MODE -eq 1 ]; then
+  if [ -x "$CODEGEN_BIN" ]; then
+    "$CODEGEN_BIN" "$AST_TMP"
+  else
+    ruby "$CODEGEN_RB" "$AST_TMP"
+  fi
+  exit $?
+fi
+
+if [ $C_ONLY -eq 1 ]; then
+  C_FILE="${OUTPUT:-$BASENAME.c}"
+else
+  C_TMP="$(mktemp /tmp/spinel_out.XXXXXX.c)"
+  C_FILE="$C_TMP"
+fi
+
+if [ -x "$CODEGEN_BIN" ]; then
+  "$CODEGEN_BIN" "$AST_TMP" "$C_FILE"
+else
+  ruby "$CODEGEN_RB" "$AST_TMP" "$C_FILE"
+fi
+if [ $? -ne 0 ]; then
+  echo "spinel: codegen failed" >&2
+  exit 1
+fi
+
+if [ $C_ONLY -eq 1 ]; then
+  echo "Wrote $C_FILE" >&2
+  exit 0
+fi
+
+# Step 3: Compile C -> binary
+BIN_FILE="${OUTPUT:-$BASENAME}"
+# Runtime library (bigint + regexp)
+SP_RT_LIB="$DIR/lib/libspinel_rt.a"
+INCLUDE_FLAGS="-I$DIR/lib"
+if [ -f "$SP_RT_LIB" ]; then
+  EXTRA_FLAGS="$EXTRA_FLAGS $SP_RT_LIB"
+fi
+# Legacy: optional standalone regexp lib (retained for backward compat)
+RE_LIB="$DIR/lib/regexp/libspre.a"
+if grep -q 're_compile' "$C_FILE" 2>/dev/null && [ ! -f "$SP_RT_LIB" ] && [ -f "$RE_LIB" ]; then
+  EXTRA_FLAGS="$EXTRA_FLAGS $RE_LIB"
+fi
+INCLUDE_FLAGS="$INCLUDE_FLAGS -I$DIR/lib/regexp"
+# Scrape FFI link/cflag markers emitted by the codegen. Each line looks
+# like "/* SPINEL_LINK: -lraylib */" or "/* SPINEL_CFLAGS: -I/foo */"
+# and comes from an ffi_lib / ffi_cflags declaration.
+FFI_LINKS=$(sed -n 's|^/\* SPINEL_LINK: \(.*\) \*/$|\1|p' "$C_FILE" | tr '\n' ' ')
+FFI_CFLAGS=$(sed -n 's|^/\* SPINEL_CFLAGS: \(.*\) \*/$|\1|p' "$C_FILE" | tr '\n' ' ')
+if [ "$(uname -s)" = "Darwin" ]; then
+  GC_FLAG="-Wl,-dead_strip"
+else
+  GC_FLAG="-Wl,--gc-sections"
+fi
+
+# MinGW's default 1MB stack overflows on nontrivial programs; reserve 64MB.
+case "$(uname -s 2>/dev/null)" in
+  MINGW*|MSYS*|CYGWIN*) EXTRA_FLAGS="$EXTRA_FLAGS -Wl,--stack,67108864" ;;
+esac
+
+$CC_CMD -O${OPT_LEVEL} -Wno-all -ffunction-sections -fdata-sections $INCLUDE_FLAGS $FFI_CFLAGS "$C_FILE" -lm $EXTRA_FLAGS $FFI_LINKS $GC_FLAG -o "$BIN_FILE"
+if [ $? -ne 0 ]; then
+  echo "spinel: C compilation failed" >&2
+  exit 1
+fi
+
+echo "$SOURCE -> $BIN_FILE" >&2