rubyduino 0.1.3 → 0.2.1

data/vendor/spinel/lib/sp_crypto.h

@@ -0,0 +1,79 @@
+/* sp_crypto.h -- Compact SHA-256 / HMAC / PBKDF2 / Base64URL / CSPRNG
+ *
+ * Pure C, no spinel-runtime dependency. Intended for spinel programs
+ * that need a small in-tree crypto surface without dragging in
+ * OpenSSL or libsodium. Sibling to sp_bigint.{h,c} in scope: a
+ * vendored, audit-sized C helper that ships with spinel so apps
+ * don't each reinvent it.
+ *
+ * The seven functions below are the canonical surface tep ended up
+ * with after a year of building on the same primitives -- if you
+ * find yourself wanting a different shape, please file an issue
+ * before adding to this list. The point is to keep the surface
+ * small enough to read in one sitting.
+ *
+ * Naming
+ * ------
+ * All exported symbols use the `sp_crypto_` prefix (matches the
+ * `sp_bigint_` convention). State buffers are per-function statics
+ * -- the next call to the same function clobbers the buffer, so
+ * copy on the caller side if the value must outlive the next call.
+ *
+ * Inputs
+ * ------
+ * String inputs are NUL-terminated. Length is taken via strlen()
+ * inside each function. For binary-safe inputs (containing embedded
+ * NULs), use the explicit-length internal API exposed by including
+ * this header in your own .c file -- see sp_crypto.c for the
+ * declarations.
+ *
+ * Thread safety
+ * -------------
+ * NOT thread-safe -- the static return buffers are shared. Spinel
+ * apps that fork (the canonical concurrency model) are fine; apps
+ * that thread need to caller-side serialize.
+ */
+#ifndef SP_CRYPTO_H
+#define SP_CRYPTO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* SHA-1(msg) -> 40-char lowercase hex. Legacy hash, kept for
+ * WebSocket handshake (RFC 6455 §1.3 requires SHA-1). Do NOT
+ * use for new security designs; SHA-256 is the right primitive. */
+const char *sp_crypto_sha1_hex(const char *msg);
+
+/* Sec-WebSocket-Accept = base64(SHA-1(client_key + GUID)) per
+ * RFC 6455 §1.3. Returns a 28-char string ending in `=`. The
+ * only modern use case for SHA-1 in this codebase; sugars the
+ * concat+sha1+base64 dance into one call. */
+const char *sp_crypto_websocket_accept(const char *client_key);
+
+/* HMAC-SHA256(key, msg) -> 64-char lowercase hex. */
+const char *sp_crypto_hmac_sha256_hex(const char *key, const char *msg);
+
+/* HMAC-SHA256(key, msg) -> 43-char unpadded base64url. */
+const char *sp_crypto_hmac_sha256_b64url(const char *key, const char *msg);
+
+/* Base64URL (RFC 4648 §5, no padding) encode/decode. Max input
+ * length ~12 KiB (encode) / ~16 KiB (decode), bump the buffer in
+ * sp_crypto.c if your callers need more. */
+const char *sp_crypto_b64url_encode(const char *src);
+const char *sp_crypto_b64url_decode(const char *src);
+
+/* PBKDF2-HMAC-SHA256(password, salt, iters) -> 43-char unpadded
+ * base64url (32 bytes derived; dkLen > 32 not supported). */
+const char *sp_crypto_pbkdf2_sha256_b64url(const char *password, const char *salt, int iters);
+
+/* CSPRNG: nbytes random bytes (clamped to [1, 64]) as unpadded
+ * base64url. Uses arc4random_buf on BSD/macOS, /dev/urandom on
+ * Linux/POSIX. */
+const char *sp_crypto_random_b64url(int nbytes);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SP_CRYPTO_H */

data/vendor/spinel/lib/sp_fiber.c

@@ -0,0 +1,95 @@
+/* sp_fiber.c -- Fiber runtime bodies (Win32 fibers / POSIX ucontext).
+ * See sp_fiber.h. The collector roots, sp_gc_alloc, and sp_raise_cls live
+ * in the generated TU and are reached by name; fiber-local storage is
+ * self-contained here. */
+#include "sp_fiber.h"
+#include <stdlib.h>
+#include <string.h>
+#ifndef _WIN32
+#include <sys/mman.h>
+#endif
+
+/* ---- Reached by name in the generated TU ---- */
+void *sp_gc_alloc(size_t sz, void (*fin)(void *), void (*scn)(void *));
+void sp_raise_cls(const char *cls, const char *msg);
+
+static inline sp_RbVal sp_box_nil(void) { sp_RbVal r; r.tag = SP_TAG_NIL; r.cls_id = 0; r.v.i = 0; return r; }
+static void sp_raise(const char *msg) { sp_raise_cls("RuntimeError", msg); }
+
+/* Fiber-local variable storage (Fiber#[] / Fiber#[]=). A small sym->RbVal
+   map, GC-allocated so the collector marks its values via the scan hook;
+   self-contained here rather than borrowing the runtime's sym_poly_hash so
+   the runtime sym_poly_hash stays collector-private to the generated TU. */
+typedef struct { sp_sym *keys; sp_RbVal *vals; mrb_int len, cap; } sp_FiberStore;
+static void sp_FiberStore_scan(void *p) { sp_FiberStore *s = (sp_FiberStore *)p; for (mrb_int i = 0; i < s->len; i++) sp_mark_rbval(s->vals[i]); }
+static void sp_FiberStore_fin(void *p) { sp_FiberStore *s = (sp_FiberStore *)p; free(s->keys); free(s->vals); }
+static sp_FiberStore *sp_FiberStore_new(void) {
+  sp_FiberStore *s = (sp_FiberStore *)sp_gc_alloc(sizeof(sp_FiberStore), sp_FiberStore_fin, sp_FiberStore_scan);
+  s->cap = 8; s->len = 0;
+  s->keys = (sp_sym *)malloc(sizeof(sp_sym) * s->cap);
+  s->vals = (sp_RbVal *)malloc(sizeof(sp_RbVal) * s->cap);
+  return s;
+}
+static sp_RbVal sp_FiberStore_get(sp_FiberStore *s, sp_sym k) {
+  for (mrb_int i = 0; i < s->len; i++) if (s->keys[i] == k) return s->vals[i];
+  return sp_box_nil();
+}
+static void sp_FiberStore_set(sp_FiberStore *s, sp_sym k, sp_RbVal v) {
+  for (mrb_int i = 0; i < s->len; i++) if (s->keys[i] == k) { s->vals[i] = v; return; }
+  if (s->len == s->cap) {
+    s->cap *= 2;
+    s->keys = (sp_sym *)realloc(s->keys, sizeof(sp_sym) * s->cap);
+    s->vals = (sp_RbVal *)realloc(s->vals, sizeof(sp_RbVal) * s->cap);
+  }
+  s->keys[s->len] = k; s->vals[s->len] = v; s->len++;
+}
+static sp_FiberStore *sp_FiberStore_dup(sp_FiberStore *o) {
+  sp_FiberStore *s = sp_FiberStore_new();
+  for (mrb_int i = 0; i < o->len; i++) sp_FiberStore_set(s, o->keys[i], o->vals[i]);
+  return s;
+}
+
+static sp_Fiber sp_fiber_root;
+sp_Fiber *sp_fiber_current = &sp_fiber_root;   /* extern: read by the generated TU */
+static sp_Fiber *sp_fiber_list_head = NULL;
+
+#ifdef _WIN32
+static void sp_fiber_save_roots(sp_Fiber*f){if(f->saved_roots_cap<sp_gc_nroots){int nc=sp_gc_nroots>64?sp_gc_nroots*2:64;void***nx=(void***)realloc(f->saved_roots,sizeof(void**)*nc);if(!nx)return;f->saved_roots=nx;f->saved_roots_cap=nc;}if(sp_gc_nroots>0)memcpy(f->saved_roots,sp_gc_roots,sizeof(void**)*sp_gc_nroots);f->saved_nroots=sp_gc_nroots;}
+static void sp_fiber_restore_roots(sp_Fiber*f){if(f->saved_nroots>0)memcpy(sp_gc_roots,f->saved_roots,sizeof(void**)*f->saved_nroots);sp_gc_nroots=f->saved_nroots;}
+static void sp_fiber_list_add(sp_Fiber*f){f->fiber_prev=NULL;f->fiber_next=sp_fiber_list_head;if(sp_fiber_list_head)sp_fiber_list_head->fiber_prev=f;sp_fiber_list_head=f;}
+static void sp_fiber_list_remove(sp_Fiber*f){if(f->fiber_prev)f->fiber_prev->fiber_next=f->fiber_next;else if(sp_fiber_list_head==f)sp_fiber_list_head=f->fiber_next;if(f->fiber_next)f->fiber_next->fiber_prev=f->fiber_prev;f->fiber_prev=NULL;f->fiber_next=NULL;}
+static void sp_mark_fiber_roots(sp_Fiber*f){if(f==sp_fiber_current)return;int i;for(i=0;i<f->saved_nroots;i++){void**e=f->saved_roots[i];if((uintptr_t)e&(uintptr_t)1){sp_gc_mark_root_entry(e);}else{void*obj=*e;if(obj)sp_gc_mark(obj);}}}
+static void sp_mark_suspended_fibers(void){sp_mark_fiber_roots(&sp_fiber_root);sp_Fiber*f=sp_fiber_list_head;while(f){sp_mark_fiber_roots(f);f=f->fiber_next;}}
+static void sp_fiber_install_gc_hook(void){if(!sp_gc_mark_suspended_fibers_hook)sp_gc_mark_suspended_fibers_hook=sp_mark_suspended_fibers;}
+static void sp_Fiber_fin(void*p){sp_Fiber*f=(sp_Fiber*)p;if(f->ctx)DeleteFiber(f->ctx);if(f->saved_roots)free(f->saved_roots);sp_fiber_list_remove(f);}
+static void sp_Fiber_scan(void*p){sp_Fiber*f=(sp_Fiber*)p;if(f->user_data)sp_gc_mark(f->user_data);if(f->storage)sp_gc_mark(f->storage);}
+sp_Fiber*sp_Fiber_new(void(*body)(sp_Fiber*)){sp_Fiber*f=(sp_Fiber*)sp_gc_alloc(sizeof(sp_Fiber),sp_Fiber_fin,sp_Fiber_scan);f->ctx=NULL;f->caller_ctx=NULL;f->stack=NULL;f->state=0;f->transferred=0;f->body=body;f->yielded_value=sp_box_nil();f->resumed_value=sp_box_nil();f->user_data=NULL;f->saved_exc_top=0;f->saved_catch_top=0;f->caller=NULL;f->storage=NULL;f->saved_roots=NULL;f->saved_nroots=0;f->saved_roots_cap=0;f->fiber_next=NULL;f->fiber_prev=NULL;sp_fiber_list_add(f);sp_fiber_install_gc_hook();if(sp_fiber_current&&sp_fiber_current->storage)f->storage=sp_FiberStore_dup((sp_FiberStore*)sp_fiber_current->storage);return f;}
+sp_RbVal sp_Fiber_storage_get(sp_Fiber*f,sp_sym k){if(!f->storage)return sp_box_nil();return sp_FiberStore_get((sp_FiberStore*)f->storage,k);}
+void sp_Fiber_storage_set(sp_Fiber*f,sp_sym k,sp_RbVal v){if(!f->storage)f->storage=sp_FiberStore_new();sp_FiberStore_set((sp_FiberStore*)f->storage,k,v);}
+static VOID CALLBACK sp_fiber_trampoline(LPVOID param){sp_Fiber*f=(sp_Fiber*)param;f->body(f);f->state=3;if(f->transferred){sp_fiber_current=&sp_fiber_root;SwitchToFiber(sp_fiber_root.ctx);}else{SwitchToFiber(f->caller->ctx);}}
+static void sp_fiber_ensure_root(void){if(!sp_fiber_root.ctx){sp_fiber_root.ctx=ConvertThreadToFiber(NULL);if(!sp_fiber_root.ctx)sp_fiber_root.ctx=GetCurrentFiber();}}
+sp_RbVal sp_Fiber_resume(sp_Fiber*f,sp_RbVal val){if(f->state==3){sp_raise_cls("FiberError","attempt to resume a terminated fiber");}sp_fiber_ensure_root();f->resumed_value=val;sp_Fiber*prev=sp_fiber_current;f->caller=prev;sp_fiber_save_roots(prev);sp_fiber_restore_roots(f);sp_fiber_current=f;if(f->state==0){f->state=1;f->ctx=CreateFiber(SP_FIBER_STACK_SIZE,sp_fiber_trampoline,f);if(!f->ctx)sp_raise("failed to create fiber");}else{f->state=1;}SwitchToFiber(f->ctx);sp_fiber_save_roots(f);sp_fiber_restore_roots(prev);sp_fiber_current=prev;return f->yielded_value;}
+sp_RbVal sp_Fiber_yield(sp_RbVal val){sp_Fiber*f=sp_fiber_current;f->yielded_value=val;f->state=2;SwitchToFiber(f->caller->ctx);return f->resumed_value;}
+mrb_bool sp_Fiber_alive(sp_Fiber*f){return f->state!=3;}
+sp_RbVal sp_Fiber_transfer(sp_Fiber*f,sp_RbVal val){sp_fiber_ensure_root();f->resumed_value=val;sp_Fiber*prev=sp_fiber_current;sp_fiber_save_roots(prev);sp_fiber_restore_roots(f);sp_fiber_current=f;if(f->state==0){f->state=1;f->transferred=1;f->caller=prev;f->ctx=CreateFiber(SP_FIBER_STACK_SIZE,sp_fiber_trampoline,f);if(!f->ctx)sp_raise("failed to create fiber");}else{f->state=1;}SwitchToFiber(f->ctx);sp_fiber_save_roots(f);sp_fiber_restore_roots(prev);sp_fiber_current=prev;return prev->resumed_value;}
+#else
+static void sp_fiber_save_roots(sp_Fiber*f){if(f->saved_roots_cap<sp_gc_nroots){int nc=sp_gc_nroots>64?sp_gc_nroots*2:64;void***nx=(void***)realloc(f->saved_roots,sizeof(void**)*nc);if(!nx)return;f->saved_roots=nx;f->saved_roots_cap=nc;}if(sp_gc_nroots>0)memcpy(f->saved_roots,sp_gc_roots,sizeof(void**)*sp_gc_nroots);f->saved_nroots=sp_gc_nroots;}
+static void sp_fiber_restore_roots(sp_Fiber*f){if(f->saved_nroots>0)memcpy(sp_gc_roots,f->saved_roots,sizeof(void**)*f->saved_nroots);sp_gc_nroots=f->saved_nroots;}
+static void sp_fiber_list_add(sp_Fiber*f){f->fiber_prev=NULL;f->fiber_next=sp_fiber_list_head;if(sp_fiber_list_head)sp_fiber_list_head->fiber_prev=f;sp_fiber_list_head=f;}
+static void sp_fiber_list_remove(sp_Fiber*f){if(f->fiber_prev)f->fiber_prev->fiber_next=f->fiber_next;else if(sp_fiber_list_head==f)sp_fiber_list_head=f->fiber_next;if(f->fiber_next)f->fiber_next->fiber_prev=f->fiber_prev;f->fiber_prev=NULL;f->fiber_next=NULL;}
+static void sp_mark_fiber_roots(sp_Fiber*f){if(f==sp_fiber_current)return;int i;for(i=0;i<f->saved_nroots;i++){void**e=f->saved_roots[i];if((uintptr_t)e&(uintptr_t)1){sp_gc_mark_root_entry(e);}else{void*obj=*e;if(obj)sp_gc_mark(obj);}}}
+static void sp_mark_suspended_fibers(void){sp_mark_fiber_roots(&sp_fiber_root);sp_Fiber*f=sp_fiber_list_head;while(f){sp_mark_fiber_roots(f);f=f->fiber_next;}}
+static void sp_fiber_install_gc_hook(void){if(!sp_gc_mark_suspended_fibers_hook)sp_gc_mark_suspended_fibers_hook=sp_mark_suspended_fibers;}
+static void sp_Fiber_fin(void*p){sp_Fiber*f=(sp_Fiber*)p;if(f->stack)munmap(f->stack,SP_FIBER_STACK_SIZE);if(f->saved_roots)free(f->saved_roots);sp_fiber_list_remove(f);}
+static void sp_Fiber_scan(void*p){sp_Fiber*f=(sp_Fiber*)p;if(f->user_data)sp_gc_mark(f->user_data);if(f->storage)sp_gc_mark(f->storage);}
+sp_Fiber*sp_Fiber_new(void(*body)(sp_Fiber*)){sp_Fiber*f=(sp_Fiber*)sp_gc_alloc(sizeof(sp_Fiber),sp_Fiber_fin,sp_Fiber_scan);f->stack=(char*)mmap(NULL,SP_FIBER_STACK_SIZE,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);if(f->stack==MAP_FAILED){f->stack=NULL;sp_raise_cls("FiberError","failed to allocate fiber stack");}f->state=0;f->transferred=0;f->body=body;f->yielded_value=sp_box_nil();f->resumed_value=sp_box_nil();f->user_data=NULL;f->saved_exc_top=0;f->saved_catch_top=0;f->storage=NULL;f->saved_roots=NULL;f->saved_nroots=0;f->saved_roots_cap=0;f->fiber_next=NULL;f->fiber_prev=NULL;sp_fiber_list_add(f);sp_fiber_install_gc_hook();if(sp_fiber_current&&sp_fiber_current->storage)f->storage=sp_FiberStore_dup((sp_FiberStore*)sp_fiber_current->storage);return f;}
+sp_RbVal sp_Fiber_storage_get(sp_Fiber*f,sp_sym k){if(!f->storage)return sp_box_nil();return sp_FiberStore_get((sp_FiberStore*)f->storage,k);}
+void sp_Fiber_storage_set(sp_Fiber*f,sp_sym k,sp_RbVal v){if(!f->storage)f->storage=sp_FiberStore_new();sp_FiberStore_set((sp_FiberStore*)f->storage,k,v);}
+static void sp_fiber_trampoline(void){sp_Fiber*f=sp_fiber_current;f->body(f);f->state=3;if(f->transferred){sp_fiber_current=&sp_fiber_root;setcontext(&sp_fiber_root.ctx);}else{swapcontext(&f->ctx,&f->caller_ctx);}}
+sp_RbVal sp_Fiber_resume(sp_Fiber*f,sp_RbVal val){if(f->state==3){sp_raise_cls("FiberError","attempt to resume a terminated fiber");}f->resumed_value=val;sp_Fiber*prev=sp_fiber_current;sp_fiber_save_roots(prev);sp_fiber_restore_roots(f);sp_fiber_current=f;if(f->state==0){f->state=1;getcontext(&f->ctx);f->ctx.uc_stack.ss_sp=f->stack;f->ctx.uc_stack.ss_size=SP_FIBER_STACK_SIZE;f->ctx.uc_link=&f->caller_ctx;makecontext(&f->ctx,(void(*)(void))sp_fiber_trampoline,0);swapcontext(&f->caller_ctx,&f->ctx);}else{f->state=1;swapcontext(&f->caller_ctx,&f->ctx);}sp_fiber_save_roots(f);sp_fiber_restore_roots(prev);sp_fiber_current=prev;return f->yielded_value;}
+sp_RbVal sp_Fiber_yield(sp_RbVal val){sp_Fiber*f=sp_fiber_current;f->yielded_value=val;f->state=2;swapcontext(&f->ctx,&f->caller_ctx);return f->resumed_value;}
+mrb_bool sp_Fiber_alive(sp_Fiber*f){return f->state!=3;}
+sp_RbVal sp_Fiber_transfer(sp_Fiber*f,sp_RbVal val){f->resumed_value=val;sp_Fiber*prev=sp_fiber_current;sp_fiber_save_roots(prev);sp_fiber_restore_roots(f);sp_fiber_current=f;if(f->state==0){f->state=1;f->transferred=1;getcontext(&f->ctx);f->ctx.uc_stack.ss_sp=f->stack;f->ctx.uc_stack.ss_size=SP_FIBER_STACK_SIZE;f->ctx.uc_link=&prev->ctx;makecontext(&f->ctx,(void(*)(void))sp_fiber_trampoline,0);swapcontext(&prev->ctx,&f->ctx);}else{f->state=1;swapcontext(&prev->ctx,&f->ctx);}sp_fiber_save_roots(f);sp_fiber_restore_roots(prev);sp_fiber_current=prev;return prev->resumed_value;}
+#endif
+
+void sp_mark_fiber_root_storage(void){if(sp_fiber_root.storage)sp_gc_mark(sp_fiber_root.storage);}

data/vendor/spinel/lib/sp_fiber.h

@@ -0,0 +1,41 @@
+/* sp_fiber.h -- Fiber runtime surface.
+ *
+ * The sp_Fiber struct (a cooperative coroutine over Win32 fibers or
+ * POSIX ucontext) is shared between the generated translation unit and
+ * lib/sp_fiber.c, which holds the function bodies. `storage` is an opaque pointer to fiber-local variable storage
+ * (defined in lib/sp_fiber.c). */
+#ifndef SP_FIBER_H
+#define SP_FIBER_H
+
+#include "sp_gc.h"   /* sp_RbVal */
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <ucontext.h>
+#endif
+
+
+#define SP_FIBER_STACK_SIZE (64*1024)
+
+#ifdef _WIN32
+typedef struct sp_Fiber{LPVOID ctx;LPVOID caller_ctx;char*stack;int state;int transferred;sp_RbVal yielded_value;sp_RbVal resumed_value;void(*body)(struct sp_Fiber*);void*user_data;int saved_exc_top;int saved_catch_top;struct sp_Fiber*caller;void*storage;void***saved_roots;int saved_nroots;int saved_roots_cap;struct sp_Fiber*fiber_next;struct sp_Fiber*fiber_prev;}sp_Fiber;
+#else
+typedef struct sp_Fiber{ucontext_t ctx;ucontext_t caller_ctx;char*stack;int state;int transferred;sp_RbVal yielded_value;sp_RbVal resumed_value;void(*body)(struct sp_Fiber*);void*user_data;int saved_exc_top;int saved_catch_top;void*storage;void***saved_roots;int saved_nroots;int saved_roots_cap;struct sp_Fiber*fiber_next;struct sp_Fiber*fiber_prev;}sp_Fiber;
+#endif
+
+/* The currently-running fiber; the generated TU reads it directly for
+   `Fiber.current` and as the implicit receiver of Fiber operations. */
+extern sp_Fiber *sp_fiber_current;
+
+/* Public Fiber API (called from the generated TU). */
+sp_Fiber *sp_Fiber_new(void (*body)(sp_Fiber *));
+sp_RbVal sp_Fiber_resume(sp_Fiber *f, sp_RbVal val);
+sp_RbVal sp_Fiber_yield(sp_RbVal val);
+sp_RbVal sp_Fiber_transfer(sp_Fiber *f, sp_RbVal val);
+mrb_bool sp_Fiber_alive(sp_Fiber *f);
+sp_RbVal sp_Fiber_storage_get(sp_Fiber *f, sp_sym k);
+void sp_Fiber_storage_set(sp_Fiber *f, sp_sym k, sp_RbVal v);
+/* Reached from sp_re_mark_globals in the generated TU during a GC pass. */
+void sp_mark_fiber_root_storage(void);
+
+#endif

data/vendor/spinel/lib/sp_gc.c

@@ -0,0 +1,89 @@
+/* sp_gc.c -- the mark/sweep collector's non-inline machinery.
+ * See sp_gc.h. The program root-marking and string-heap sweep are
+ * supplied by the generated TU via sp_gc_mark_globals_hook /
+ * sp_gc_str_sweep_hook. */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#if !defined(__APPLE__) && !defined(_WIN32) && !defined(__FreeBSD__)
+#include <malloc.h>
+#else
+/* Darwin's libc has no malloc_trim; make it a no-op so call sites stay portable. */
+#define malloc_trim(x) ((void)0)
+#endif
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+#include "sp_gc.h"
+
+/* ---- Globals shared with the generated TU (declared extern in sp_gc.h) ---- */
+void **sp_gc_roots[SP_GC_STACK_MAX];
+int sp_gc_nroots = 0;
+sp_gc_hdr *sp_gc_heap = NULL;
+size_t sp_gc_bytes = 0;
+size_t sp_gc_old_bytes = 0;
+int sp_gc_cycle = 0;
+void (*sp_gc_mark_suspended_fibers_hook)(void) = NULL;
+void (*sp_gc_mark_globals_hook)(void) = NULL;
+void (*sp_gc_str_sweep_hook)(void) = NULL;
+
+/* ---- Collector-private globals ---- */
+static int sp_gc_verify = 0;
+static sp_gc_hdr *sp_gc_old_heap = NULL;
+#define SP_GC_MARK_STACK_MAX (1024*64)
+static void **sp_gc_mark_stack = NULL;
+static int sp_gc_mark_top = 0;
+static sp_gc_hdr **sp_gc_vsnap = NULL;
+static size_t sp_gc_vsnap_n = 0, sp_gc_vsnap_cap = 0;
+static size_t sp_gc_max_bytes = 0;
+static int sp_gc_max_bytes_init = 0;
+#define SP_GC_FULL_INTERVAL 8
+
+/* Issue #755: bail out cleanly on OOM rather than returning NULL into a
+   caller that would deref it next. */
+void sp_oom_die(void){fputs("unhandled exception: out of memory\n",stderr);exit(1);}
+
+/* ---- GC verify (SPINEL_GC_VERIFY=1): a sorted snapshot of every
+ * registered header, so the scan-time membership test is O(log n). ---- */
+static int sp_gc_vsnap_cmp(const void *a, const void *b){ uintptr_t x=(uintptr_t)*(sp_gc_hdr*const*)a, y=(uintptr_t)*(sp_gc_hdr*const*)b; return x<y?-1:x>y?1:0; }
+static void sp_gc_vsnap_push(sp_gc_hdr *h){ if(sp_gc_vsnap_n==sp_gc_vsnap_cap){ size_t c=sp_gc_vsnap_cap?sp_gc_vsnap_cap*2:1024; sp_gc_hdr**n=(sp_gc_hdr**)realloc(sp_gc_vsnap,c*sizeof(sp_gc_hdr*)); if(!n)sp_oom_die(); sp_gc_vsnap=n; sp_gc_vsnap_cap=c; } sp_gc_vsnap[sp_gc_vsnap_n++]=h; }
+static void sp_gc_verify_snapshot(void){ sp_gc_vsnap_n=0; for(sp_gc_hdr*p=sp_gc_heap;p;p=p->next)sp_gc_vsnap_push(p); for(sp_gc_hdr*p=sp_gc_old_heap;p;p=p->next)sp_gc_vsnap_push(p); if(sp_gc_vsnap_n>1)qsort(sp_gc_vsnap,sp_gc_vsnap_n,sizeof(sp_gc_hdr*),sp_gc_vsnap_cmp); }
+static int sp_gc_obj_registered(sp_gc_hdr *h){ uintptr_t hv=(uintptr_t)h; size_t lo=0,hi=sp_gc_vsnap_n; while(lo<hi){ size_t m=lo+(hi-lo)/2; uintptr_t x=(uintptr_t)sp_gc_vsnap[m]; if(x==hv)return 1; if(x<hv)lo=m+1; else hi=m; } return 0; }
+static void sp_gc_verify_fail(void *obj, sp_gc_hdr *h){
+  fprintf(stderr,
+    "\n*** SPINEL_GC_VERIFY: collector reached a non-heap/corrupt object ***\n"
+    "  obj    = %p\n  header = %p\n"
+    "  This pointer is on the GC mark path but is not a registered live GC\n"
+    "  allocation -- most likely a raw/aliased pointer (e.g. into a string or\n"
+    "  builder buffer) reachable from a root or a scanned field. Invoking its\n"
+    "  scan hook would jump through a bogus function pointer.\n",
+    obj, (void*)h);
+  fflush(stderr);
+  fprintf(stderr, "  ->scan = %p   ->size = %zu\n\n",
+    (void*)(uintptr_t)h->scan, (size_t)h->size);
+  abort();
+}
+__attribute__((constructor)) static void sp_gc_debug_env(void){
+  const char *v=getenv("SPINEL_GC_VERIFY"); sp_gc_verify=(v&&*v&&*v!='0');
+}
+
+/* Tag byte preceding `obj`: 0xfe heap-unmarked -> 0xfc; 0xfc/0xff/0xfd
+ * skipped; else a real GC object reached through its scan hook. */
+void sp_gc_mark(void*obj){if(!obj)return;unsigned char pm=((unsigned char*)obj)[-1];if(pm==0xfe){((char*)obj)[-1]=(char)0xfc;return;}if(pm==0xfc||pm==0xff||pm==0xfd)return;sp_gc_hdr*h=(sp_gc_hdr*)((char*)obj-sizeof(sp_gc_hdr));if(sp_gc_verify&&!sp_gc_obj_registered(h))sp_gc_verify_fail(obj,h);if(h->marked)return;h->marked=1;if(h->scan){if(sp_gc_mark_stack&&sp_gc_mark_top<SP_GC_MARK_STACK_MAX){sp_gc_mark_stack[sp_gc_mark_top++]=obj;}else{h->scan(obj);}}}
+
+void sp_gc_mark_all(void){if(!sp_gc_mark_stack)sp_gc_mark_stack=(void**)malloc(sizeof(void*)*SP_GC_MARK_STACK_MAX);sp_gc_mark_top=0;if(sp_gc_verify)sp_gc_verify_snapshot();for(int i=0;i<sp_gc_nroots;i++){void**e=sp_gc_roots[i];if((uintptr_t)e&(uintptr_t)1){sp_gc_mark_root_entry(e);}else{void*obj=*e;if(obj)sp_gc_mark(obj);}}if(sp_gc_mark_suspended_fibers_hook)sp_gc_mark_suspended_fibers_hook();if(sp_gc_mark_globals_hook)sp_gc_mark_globals_hook();while(sp_gc_mark_top>0){void*obj=sp_gc_mark_stack[--sp_gc_mark_top];sp_gc_hdr*h=(sp_gc_hdr*)((char*)obj-sizeof(sp_gc_hdr));if(h->scan)h->scan(obj);}}
+
+void sp_gc_collect(void){int full=(sp_gc_cycle%SP_GC_FULL_INTERVAL==0);sp_gc_cycle++;sp_gc_hdr*hh=sp_gc_old_heap;while(hh){hh->marked=0;hh=hh->next;}sp_gc_mark_all();if(full){sp_gc_hdr**pp=&sp_gc_old_heap;sp_gc_old_bytes=0;while(*pp){sp_gc_hdr*h=*pp;if(!h->marked){*pp=h->next;if(h->recycle){h->recycle(h);}else{if(h->finalize)h->finalize((char*)h+sizeof(sp_gc_hdr));free(h);}}else{h->marked=1;sp_gc_old_bytes+=h->size;pp=&h->next;}}}else{hh=sp_gc_old_heap;while(hh){hh->marked=1;hh=hh->next;}}sp_gc_hdr**pp=&sp_gc_heap;sp_gc_bytes=sp_gc_old_bytes;while(*pp){sp_gc_hdr*h=*pp;if(!h->marked){*pp=h->next;if(h->recycle){h->recycle(h);}else{if(h->finalize)h->finalize((char*)h+sizeof(sp_gc_hdr));free(h);}}else{h->marked=1;*pp=h->next;h->next=sp_gc_old_heap;sp_gc_old_heap=h;sp_gc_old_bytes+=h->size;sp_gc_bytes+=h->size;}}if(sp_gc_str_sweep_hook)sp_gc_str_sweep_hook();if(full)malloc_trim(0);}
+
+/* Issue #1302: optional RSS ceiling via SPINEL_MAX_HEAP_MB; checked only
+ * at GC-trigger points against real /proc/self/statm RSS. Default off. */
+void sp_gc_enforce_mem_limit(void){
+  if(!sp_gc_max_bytes_init){const char*e=getenv("SPINEL_MAX_HEAP_MB");long v=(e&&*e)?atol(e):0;sp_gc_max_bytes=(v>0)?(size_t)v*1024*1024:0;sp_gc_max_bytes_init=1;}
+  if(!sp_gc_max_bytes)return;
+#if defined(__linux__)
+  FILE*sf=fopen("/proc/self/statm","r");if(!sf)return;long tot=0,res=0;int n=fscanf(sf,"%ld %ld",&tot,&res);fclose(sf);if(n!=2||res<=0)return;
+  size_t rss=(size_t)res*(size_t)sysconf(_SC_PAGESIZE);
+  if(rss>sp_gc_max_bytes){fprintf(stderr,"unhandled exception: out of memory (RSS %zu MB exceeded SPINEL_MAX_HEAP_MB=%zu MB)\n",rss/(1024*1024),sp_gc_max_bytes/(1024*1024));exit(1);}
+#endif
+}

data/vendor/spinel/lib/sp_gc.h

@@ -0,0 +1,81 @@
+/* sp_gc.h -- the mark/sweep collector's shared surface.
+ *
+ * Included by both the generated translation unit (via sp_runtime.h) and
+ * lib/sp_gc.c, which holds the collector's non-inline machinery (mark,
+ * sweep, collect, the memory-limit governor, and the SPINEL_GC_VERIFY
+ * support). The hot inline mark helpers stay here so both sides inline
+ * them -- moving the cold collector body to a single compiled unit must
+ * not de-inline the per-object mark path. The collector globals are
+ * declared extern here and defined once in lib/sp_gc.c.
+ */
+#ifndef SP_GC_H
+#define SP_GC_H
+
+#include "sp_types.h"
+
+/* ---- Value tag constants + the boxed value (sp_RbVal) ----
+ * The mark helpers below dispatch on the tag, so the type lives here
+ * rather than in the generated TU. */
+#define SP_TAG_INT 0
+#define SP_TAG_STR 1
+#define SP_TAG_FLT 2
+#define SP_TAG_BOOL 3
+#define SP_TAG_NIL 4
+#define SP_TAG_OBJ 5
+#define SP_TAG_SYM 6
+#define SP_TAG_CLASS 7
+#define SP_TAG_ENCODING 8
+typedef struct { int tag; int cls_id; union { mrb_int i; const char *s; mrb_float f; mrb_bool b; void *p; } v; } sp_RbVal;
+
+/* ---- Collector globals shared with the generated TU ----
+ * Only the globals touched by both the kept hot path (sp_gc_alloc, the
+ * SP_GC_ROOT macros, GC.stat, the fiber root hook) and the moved cold
+ * body are extern; the rest stay static on whichever side owns them. */
+#define SP_GC_STACK_MAX 65536
+#define SP_GC_FULL_INTERVAL 8
+extern void **sp_gc_roots[SP_GC_STACK_MAX];
+extern int sp_gc_nroots;
+extern sp_gc_hdr *sp_gc_heap;
+extern size_t sp_gc_bytes;
+extern size_t sp_gc_old_bytes;
+extern int sp_gc_cycle;
+extern void (*sp_gc_mark_suspended_fibers_hook)(void);
+
+/* ---- Collector entry points (defined in lib/sp_gc.c) ---- */
+void sp_gc_mark(void *obj);
+void sp_gc_mark_all(void);
+void sp_gc_collect(void);
+void sp_gc_enforce_mem_limit(void);
+void sp_oom_die(void);
+
+/* ---- Embedder callbacks supplied by the generated TU ----
+ * The collector cannot own the program's roots or string heap (they are
+ * static state in the generated TU: the regexp match globals, ARGV, the
+ * in-flight exception stack, and the heap-string free list). The TU
+ * installs its mark-roots and string-sweep callbacks here at startup;
+ * sp_gc_mark_all / sp_gc_collect invoke them through these pointers, the
+ * same way fibers register sp_gc_mark_suspended_fibers_hook. */
+extern void (*sp_gc_mark_globals_hook)(void);
+extern void (*sp_gc_str_sweep_hook)(void);
+
+/* ---- Hot inline mark helpers (inlined into both sides) ----
+ * String tag bytes: 0xfe heap-unmarked -> 0xfc marked; others skipped. */
+static inline void sp_mark_string(const char *s) {
+  if (!s) return;
+  if ((unsigned char)s[-1] == 0xfe) {
+    ((char *)s)[-1] = (char)0xfc;
+  }
+}
+static inline void sp_mark_rbval(sp_RbVal v) {
+  if (v.tag == SP_TAG_STR) sp_mark_string(v.v.s);
+  else if (v.tag == SP_TAG_OBJ) sp_gc_mark(v.v.p);
+}
+/* A low-bit-tagged root entry is an sp_RbVal* (see SP_GC_ROOT_RBVAL);
+   an untagged entry is a plain void** to a direct GC pointer. */
+static inline void sp_gc_mark_root_entry(void **e) {
+  uintptr_t u = (uintptr_t)e;
+  if (u & (uintptr_t)1) { sp_mark_rbval(*(sp_RbVal *)(u & ~(uintptr_t)1)); }
+  else { void *o = *e; if (o) sp_gc_mark(o); }
+}
+
+#endif

data/vendor/spinel/lib/sp_io.c

@@ -0,0 +1,98 @@
+/* sp_io.c -- File / IO handle ops in libspinel_rt.a.
+ *
+ * The allocation-free handle ops (open / pipe / fdopen / write / close /
+ * closed? / puts / print / flush / eof?). The string-returning readers
+ * (gets / read / read_n / path) stay inline in sp_runtime.h since they
+ * allocate via the hot static sp_str_alloc, whose per-TU sp_str_heap
+ * can't be shared across translation units.
+ *
+ * Self-contained: includes sp_io.h (the sp_File layout) + sp_gc.h
+ * (sp_mark_string), but not sp_runtime.h, so it avoids the mruby_shim.h
+ * mrb_bool conflict (same convention as sp_gc.c / sp_fiber.c). */
+#include "sp_io.h"
+#include "sp_gc.h"   /* sp_mark_string */
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+#include <io.h>      /* _pipe */
+#include <fcntl.h>   /* _O_BINARY */
+#else
+#include <unistd.h>  /* pipe */
+#endif
+
+/* Provided by the generated TU / libspinel_rt.a. */
+extern void *sp_gc_alloc(size_t sz, void (*fin)(void *), void (*scn)(void *));
+extern void sp_raise_cls(const char *cls, const char *msg);
+
+static void sp_File_fin(void *p) { sp_File *f = (sp_File *)p; if (f->fp) { fclose(f->fp); f->fp = NULL; } }
+static void sp_File_scan(void *p) { sp_File *f = (sp_File *)p; if (f->path) sp_mark_string(f->path); if (f->mode) sp_mark_string(f->mode); }
+
+sp_File *sp_File_open(const char *path, const char *mode) {
+  sp_File *f = (sp_File *)sp_gc_alloc(sizeof(sp_File), sp_File_fin, sp_File_scan);
+  f->fp = fopen(path ? path : "", mode ? mode : "r");
+  if (!f->fp) { sp_raise_cls("Errno::ENOENT", "No such file or directory"); return NULL; }
+  f->path = path;
+  f->mode = mode;
+  return f;
+}
+
+/* pipe(2) portability: MinGW exposes _pipe(fds, size, mode) via <io.h>,
+   not the POSIX pipe(int[2]). Returns 0 on success, -1 on error. */
+int sp_io_make_pipe(int fds[2]) {
+#ifdef _WIN32
+  return _pipe(fds, 65536, _O_BINARY);
+#else
+  return pipe(fds);
+#endif
+}
+
+/* IO.pipe end: wrap a raw pipe fd in a GC-managed sp_File so the
+   sp_File_* I/O ops work on it. Same finalizer/scan as sp_File_open. */
+sp_File *sp_io_fdopen(int fd, const char *mode) {
+  sp_File *f = (sp_File *)sp_gc_alloc(sizeof(sp_File), sp_File_fin, sp_File_scan);
+  f->fp = fdopen(fd, mode ? mode : "r");
+  if (!f->fp) { sp_raise_cls("IOError", "fdopen failed"); return NULL; }
+  f->path = NULL;
+  f->mode = mode;
+  return f;
+}
+
+mrb_int sp_File_write(sp_File *f, const char *s) {
+  if (!f || !f->fp || !s) return 0;
+  size_t n = strlen(s);
+  return (mrb_int)fwrite(s, 1, n, f->fp);
+}
+
+mrb_int sp_File_close(sp_File *f) {
+  if (f && f->fp) { fclose(f->fp); f->fp = NULL; }
+  return 0;
+}
+
+mrb_bool sp_File_closed_p(sp_File *f) {
+  return !f || !f->fp;
+}
+
+void sp_File_puts(sp_File *f, const char *s) {
+  if (!f || !f->fp || !s) return;
+  size_t n = strlen(s);
+  fputs(s, f->fp);
+  if (n == 0 || s[n - 1] != '\n') fputc('\n', f->fp);
+}
+
+void sp_File_print(sp_File *f, const char *s) {
+  if (!f || !f->fp || !s) return;
+  fputs(s, f->fp);
+}
+
+mrb_int sp_File_flush(sp_File *f) {
+  if (f && f->fp) fflush(f->fp);
+  return 0;
+}
+
+mrb_bool sp_File_eof_p(sp_File *f) {
+  if (!f || !f->fp) return TRUE;
+  int c = fgetc(f->fp);
+  if (c == EOF) return TRUE;
+  ungetc(c, f->fp);
+  return FALSE;
+}

data/vendor/spinel/lib/sp_io.h

@@ -0,0 +1,31 @@
+/* sp_io.h -- File / IO handle surface.
+ *
+ * sp_File is a stdio FILE* plus its (GC-managed) path/mode strings,
+ * shared between the generated translation unit and lib/sp_io.c, which
+ * holds the allocation-free handle ops. The string-returning readers
+ * (sp_File_gets / _read / _read_n / _path) stay inline in sp_runtime.h
+ * because they allocate via the hot static sp_str_alloc; moving them
+ * would split the per-TU string heap. */
+#ifndef SP_IO_H
+#define SP_IO_H
+
+#include <stdio.h>
+#include "sp_types.h"   /* mrb_int, mrb_bool */
+
+typedef struct { FILE *fp; const char *path; const char *mode; } sp_File;
+
+/* File.open(path, mode) -> GC-managed handle (block form is codegen-only). */
+sp_File *sp_File_open(const char *path, const char *mode);
+/* pipe(2) portability shim: POSIX pipe / MinGW _pipe. 0 ok, -1 error. */
+int sp_io_make_pipe(int fds[2]);
+/* IO.pipe end: wrap a raw pipe fd in a GC-managed sp_File. */
+sp_File *sp_io_fdopen(int fd, const char *mode);
+mrb_int sp_File_write(sp_File *f, const char *s);
+mrb_int sp_File_close(sp_File *f);
+mrb_bool sp_File_closed_p(sp_File *f);
+void sp_File_puts(sp_File *f, const char *s);
+void sp_File_print(sp_File *f, const char *s);
+mrb_int sp_File_flush(sp_File *f);
+mrb_bool sp_File_eof_p(sp_File *f);
+
+#endif