rubyduino 0.1.3 → 0.2.1

data/vendor/spinel/lib/sp_time.h

@@ -0,0 +1,63 @@
+/* sp_time.h -- Time value type + libc-backed accessors / formatters.
+ *
+ * The bulk of spinel's Time implementation lives in lib/sp_time.c
+ * (compiled into libspinel_rt.a). sp_runtime.h carries only the
+ * GC-aware wrappers (sp_box_time, sp_time_strftime_gc) — the small
+ * sp_str_dup_external trampolines that bind the libspinel_rt format
+ * helpers to the GC string heap.
+ *
+ * The format helpers (strftime / iso8601 / zone / inspect) write into
+ * a caller-provided buffer; the caller is responsible for copying
+ * into the GC string heap. This keeps libspinel_rt zero-dependency on
+ * the runtime's static-inline helpers.
+ *
+ * Signatures use int64_t / double directly rather than mrb_int /
+ * mrb_float because sp_runtime.h and mruby_shim.h disagree on the
+ * mrb_bool typedef (bool vs int) — including either from this header
+ * would tip the conflict at every TU that consumes both.
+ */
+#ifndef SP_TIME_H
+#define SP_TIME_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <time.h>
+
+typedef struct { int64_t tv_sec; int32_t tv_nsec; int8_t is_utc; } sp_Time;
+
+/* Constructors */
+sp_Time sp_time_now(void);
+sp_Time sp_time_at_int(int64_t sec);
+sp_Time sp_time_at_float(double epoch);
+sp_Time sp_time_new(int64_t y, int64_t mo, int64_t d, int64_t h, int64_t mi, int64_t s);
+sp_Time sp_time_new_utc(int64_t y, int64_t mo, int64_t d, int64_t h, int64_t mi, int64_t s);
+sp_Time sp_time_utc(sp_Time t);
+sp_Time sp_time_localtime(sp_Time t);
+
+/* Broken-down resolver: is_utc selects gmtime vs localtime, off is the
+   UTC offset in seconds, zbuf is the timezone abbreviation (8 bytes). */
+void sp_time_vtm(sp_Time t, struct tm *bd, int32_t *off, char *zbuf);
+
+/* Field accessors */
+int64_t sp_time_year(sp_Time t);
+int64_t sp_time_mon(sp_Time t);
+int64_t sp_time_mday(sp_Time t);
+int64_t sp_time_hour(sp_Time t);
+int64_t sp_time_min(sp_Time t);
+int64_t sp_time_sec(sp_Time t);
+int64_t sp_time_wday(sp_Time t);
+int64_t sp_time_yday(sp_Time t);
+int64_t sp_time_isdst(sp_Time t);
+int64_t sp_time_utc_offset(sp_Time t);
+
+/* Time + Numeric / Time - Numeric. secs may be fractional. */
+sp_Time sp_time_add(sp_Time t, double secs);
+
+/* Format helpers: write into `buf` (cap bytes incl NUL), return the
+   number of bytes written excluding NUL. Return 0 on failure. */
+size_t sp_time_strftime_to(sp_Time t, const char *fmt, char *buf, size_t cap);
+size_t sp_time_iso8601_to(sp_Time t, char *buf, size_t cap);
+size_t sp_time_zone_to(sp_Time t, char *buf, size_t cap);
+size_t sp_time_inspect_to(sp_Time t, char *buf, size_t cap);
+
+#endif

data/vendor/spinel/lib/sp_types.h

@@ -0,0 +1,144 @@
+/* sp_types.h -- core value-type definitions split out of sp_runtime.h.
+ *
+ * Holds the primitive typedefs, the small leaf value structs, the GC
+ * header, and the typed array / non-poly hash structs. Both
+ * sp_runtime.h (which includes this near the top) and libspinel_rt.a
+ * sources can include it to see the layouts without pulling in the
+ * header's static/inline function bodies. Pure type/macro definitions
+ * only -- no function definitions, no global state.
+ *
+ * Reorganisation step toward slimming sp_runtime.h; sp_RbVal, the poly
+ * containers, and the conditional Proc/Fiber/etc. types still live in
+ * sp_runtime.h pending a later pass.
+ */
+#ifndef SP_TYPES_H
+#define SP_TYPES_H
+
+#ifdef __APPLE__
+/* getcontext/makecontext/swapcontext are gated behind _XOPEN_SOURCE on Darwin
+   and marked deprecated since 10.6. _DARWIN_C_SOURCE re-enables Darwin
+   extensions (MAP_ANON, etc.) that _XOPEN_SOURCE alone would hide. Define them
+   here -- the lowest shared base header -- so every TU that pulls sp_types.h in
+   sets them before the first system header: the generated TU (via sp_runtime.h)
+   and the standalone libspinel_rt.a units like sp_fiber.c that reach
+   <ucontext.h> through sp_fiber.h -> sp_gc.h -> sp_types.h. Suppress the
+   deprecation warning so -Werror builds pass; Spinel's Fiber implementation
+   knowingly uses these APIs. */
+#define _XOPEN_SOURCE 600
+#define _DARWIN_C_SOURCE
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <float.h>   /* DBL_MAX / DBL_MIN / DBL_EPSILON for Float::* constants */
+
+/* Branch-hint / hot-cold attributes. Static approximation of PGO: marking
+   rare paths (raise, dispatch fallbacks) cold lets the C compiler split
+   them out of the hot path's i-cache footprint. No-op on non-GCC/clang. */
+#if defined(__GNUC__) || defined(__clang__)
+# define SP_LIKELY(x)   __builtin_expect(!!(x), 1)
+# define SP_UNLIKELY(x) __builtin_expect(!!(x), 0)
+# define SP_COLD        __attribute__((cold))
+# define SP_NOINLINE    __attribute__((noinline))
+# define SP_NORETURN    __attribute__((noreturn))
+#else
+# define SP_LIKELY(x)   (x)
+# define SP_UNLIKELY(x) (x)
+# define SP_COLD
+# define SP_NOINLINE
+# define SP_NORETURN
+#endif
+
+/* mrb_int follows pointer width (decided at compile time via intptr_t):
+   int64_t on 64-bit hosts -- PCs, no behavior change -- and int32_t on
+   32-bit embedded targets, where it gives native-word arithmetic, half
+   the memory for every integer/array/hash slot, and a pointer-width
+   sp_RbVal union. The two paths differ only in that the 32-bit build
+   overflows / narrows foreign 64-bit values (e.g. Time#to_i) at
+   INT32 limits; see the overflow-mode handling. */
+#if INTPTR_MAX == INT64_MAX
+#elif INTPTR_MAX == INT32_MAX
+#else
+#error "spinel: unsupported intptr_t width (need 32- or 64-bit)"
+#endif
+typedef intptr_t mrb_int;
+typedef double mrb_float;
+typedef bool mrb_bool;
+
+/* Sentinel value reserved by the int? (scalar-nullable int) type. An
+   int? slot is bit-compatible with mrb_int; SP_INT_NIL marks the
+   "nil" inhabitant. The pattern is INTPTR_MIN -- INT64_MIN on 64-bit
+   (unchanged), INT32_MIN on 32-bit.
+   `sp_int_is_nil(v)` is the canonical predicate; treat any int? value
+   produced by runtime helpers as opaque outside this macro.
+
+   KNOWN LIMITATION (32-bit builds only). The reservation is a single
+   bit pattern, so a *genuine* integer equal to the sentinel is
+   indistinguishable from nil. On 64-bit, INT64_MIN is effectively
+   unreachable in practice (CRuby would have promoted it to Bignum), so
+   this never bites. On 32-bit, INT32_MIN (-2147483648) is an ordinary
+   reachable Integer, so a real -2147483648 flowing into an int? slot
+   reads back as nil -- e.g. `[-2147483648].pop` yields nil instead of
+   the value. This affects ONLY int? (nullable-int) slots; a plain
+   (non-nullable) int holding -2147483648 is fine, since it never
+   consults sp_int_is_nil. The integer-overflow helpers deliberately do
+   NOT reserve this value (checking every add/sub/mul result against it
+   would cost the hot path the embedded build is trying to save). Code that
+   must store -2147483648 nullably on 32-bit should box it (poly) rather
+   than use a flat int? slot. */
+#define SP_INT_NIL ((mrb_int)INTPTR_MIN)
+#define sp_int_is_nil(v) ((v) == SP_INT_NIL)
+
+/* Nullable float (float?) sentinel: a quiet NaN with a reserved payload.
+   NaN != NaN, so nil is detected by bit pattern, not ==. The payload is
+   chosen so the canonical NaN (0x7FF8000000000000) and ordinary
+   arithmetic NaNs don't collide; a real Float element with this exact
+   bit pattern reads back as nil -- the same documented compromise
+   SP_INT_NIL makes for INTPTR_MIN. mrb_float is double (8 bytes). */
+#define SP_FLOAT_NIL_BITS ((uint64_t)0x7FF8000000000001ULL)
+static inline mrb_float sp_float_nil(void) {
+  union { uint64_t u; mrb_float d; } x; x.u = SP_FLOAT_NIL_BITS; return x.d;
+}
+static inline int sp_float_is_nil(mrb_float v) {
+  union { mrb_float d; uint64_t u; } x; x.d = v; return x.u == SP_FLOAT_NIL_BITS;
+}
+
+/* sp_sym is defined per-program in emit_sym_runtime, but poly helpers
+   below need to reference it by forward declaration. */
+typedef mrb_int sp_sym;
+
+#ifndef TRUE
+#define TRUE true
+#endif
+#ifndef FALSE
+#define FALSE false
+#endif
+
+/* ---- Leaf value structs ---- */
+typedef struct{mrb_int first;mrb_int last;mrb_int excl;}sp_Range;
+typedef struct{mrb_int cls_id;}sp_Class;
+typedef struct{mrb_float re;mrb_float im;}sp_Complex;
+typedef struct{mrb_int num;mrb_int den;}sp_Rational;
+typedef struct{const char *name;}sp_Encoding;
+
+/* ---- GC headers ---- */
+typedef struct sp_gc_hdr { struct sp_gc_hdr *next; void (*finalize)(void *); void (*scan)(void *); size_t size; unsigned marked : 1; unsigned frozen : 1; void (*recycle)(struct sp_gc_hdr *); } sp_gc_hdr;
+typedef struct sp_str_hdr { struct sp_str_hdr *next; size_t size; size_t len; } sp_str_hdr;
+
+/* ---- Typed arrays ---- */
+#define SP_STRARR_INLINE 4
+typedef struct{mrb_int*data;mrb_int start;mrb_int len;mrb_int cap;mrb_int frozen;}sp_IntArray;
+typedef struct{mrb_float*data;mrb_int len;mrb_int cap;mrb_int frozen;}sp_FloatArray;
+typedef struct{void**data;mrb_int len;mrb_int cap;void(*scan_elem)(void*);mrb_int frozen;}sp_PtrArray;
+typedef struct{const char**data;mrb_int len;mrb_int cap;mrb_int frozen;const char*inline_data[SP_STRARR_INLINE];}sp_StrArray;
+
+/* ---- Non-poly typed hashes ---- */
+typedef struct{const char**keys;mrb_int*vals;const char**order;mrb_int len;mrb_int cap;mrb_int mask;mrb_int default_v;}sp_StrIntHash;
+typedef struct{const char**keys;const char**vals;const char**order;mrb_int len;mrb_int cap;mrb_int mask;const char*default_v;}sp_StrStrHash;
+typedef struct{mrb_int*keys;const char**vals;mrb_int*order;mrb_bool*used;mrb_int len;mrb_int cap;mrb_int mask;const char*default_v;}sp_IntStrHash;
+typedef struct{mrb_int*keys;mrb_int*vals;mrb_int*order;mrb_bool*used;mrb_int len;mrb_int cap;mrb_int mask;mrb_int default_v;}sp_IntIntHash;
+
+#endif

data/vendor/spinel/lib/stringio.c

@@ -22,13 +22,20 @@ typedef struct {
   int closed;       /* 1 if closed */
 } sp_StringIO;
 
-/* Internal: ensure buffer has room for `need` more bytes */
+/* Internal: ensure buffer has room for `need` more bytes.
+   Issue #818: capture realloc into a temp and only commit on success
+   so an OOM failure doesn't NULL out sio->buf (leaking the old buf
+   and crashing subsequent reads). On failure leave the buffer alone
+   and let the caller's bounds check truncate the write. */
 static void sio_grow(sp_StringIO *sio, int64_t need) {
+  if (!sio) return;
   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);
+  char *nb = (char *)realloc(sio->buf, new_cap + 1);
+  if (!nb) return;
+  sio->buf = nb;
   sio->cap = new_cap;
 }
 
@@ -47,18 +54,26 @@ static int64_t sio_write(sp_StringIO *sio, const char *data, int64_t data_len) {
 }
 
 /* Constructor: StringIO.new or StringIO.new("initial") */
+/* Issue #817: check calloc returns before dereferencing. On OOM, free
+   the partially allocated state and return NULL; callers already null-
+   check sio->buf via the ternary in sp_StringIO_string. */
 sp_StringIO *sp_StringIO_new(void) {
   sp_StringIO *sio = (sp_StringIO *)calloc(1, sizeof(sp_StringIO));
+  if (!sio) return NULL;
   sio->buf = (char *)calloc(1, 64);
+  if (!sio->buf) { free(sio); return NULL; }
   sio->cap = 63;
   return sio;
 }
 
 sp_StringIO *sp_StringIO_new_s(const char *initial) {
+  if (!initial) initial = "";
   sp_StringIO *sio = (sp_StringIO *)calloc(1, sizeof(sp_StringIO));
+  if (!sio) return NULL;
   int64_t len = (int64_t)strlen(initial);
   int64_t cap = len < 63 ? 63 : len;
   sio->buf = (char *)malloc(cap + 1);
+  if (!sio->buf) { free(sio); return NULL; }
   memcpy(sio->buf, initial, len);
   sio->buf[len] = '\0';
   sio->len = len;
@@ -219,10 +234,20 @@ int sp_StringIO_eof_p(sp_StringIO *sio) {
 
 /* truncate(length) — truncate buffer to given length */
 int64_t sp_StringIO_truncate(sp_StringIO *sio, int64_t length) {
+  if (!sio) return 0;
   if (length < 0) length = 0;
   if (length < sio->len) {
     sio->len = length;
     sio->buf[length] = '\0';
+  } else if (length > sio->len) {
+    /* Issue #816: grow the buffer + NUL-fill the gap, matching
+       CRuby's "truncate(N) where N > current length pads with NULs". */
+    sio_grow(sio, length - sio->pos);
+    if (length > sio->len) {
+      memset(sio->buf + sio->len, 0, (size_t)(length - sio->len));
+    }
+    sio->len = length;
+    if (length < sio->cap) sio->buf[length] = '\0';
   }
   return 0;
 }
@@ -274,10 +299,13 @@ int64_t sp_StringIO_printf(sp_StringIO *sio, const char *fmt, ...) {
 
 /* string= — replace buffer contents */
 void sp_StringIO_set_string(sp_StringIO *sio, const char *str) {
+  if (!sio || !str) return;
   int64_t len = (int64_t)strlen(str);
   if (len > sio->cap) {
+    char *nb = (char *)realloc(sio->buf, len + 1);
+    if (!nb) return;
+    sio->buf = nb;
     sio->cap = len;
-    sio->buf = (char *)realloc(sio->buf, sio->cap + 1);
   }
   memcpy(sio->buf, str, len);
   sio->buf[len] = '\0';

data/vendor/spinel/lib/strscan.c

@@ -20,11 +20,21 @@ typedef struct {
     int64_t last_pos;    /* position before last scan (for unscan) */
     char *matched;       /* last matched string (heap-allocated) */
     int64_t matched_len;
+    /* Issue #813: cache the peek buffer so repeated peek() calls
+       don't leak. Reallocated on demand when n grows. */
+    char *peek_buf;
+    int64_t peek_buf_cap;
 } sp_StringScanner;
 
-/* Constructor */
+/* Constructor.
+   Issue #811: NULL str used to segfault at strlen(NULL); treat as
+   the empty string. CRuby raises TypeError -- spinel can't easily
+   raise from a typed-string constructor here, so the safer fallback
+   is empty-string behaviour. */
 sp_StringScanner *sp_StringScanner_new(const char *str) {
+    if (!str) str = "";
     sp_StringScanner *sc = (sp_StringScanner *)calloc(1, sizeof(sp_StringScanner));
+    if (!sc) return NULL;
     sc->source = str;
     sc->source_len = (int64_t)strlen(str);
     sc->pos = 0;
@@ -123,6 +133,12 @@ const char *sp_StringScanner_matched(sp_StringScanner *sc) {
     return sc->matched ? sc->matched : "";
 }
 
+/* Issue #814: matched? -- true when the last scan succeeded. */
+int sp_StringScanner_matched_p(sp_StringScanner *sc) {
+    if (!sc) return 0;
+    return sc->matched != NULL ? 1 : 0;
+}
+
 /* pos — current position */
 int64_t sp_StringScanner_pos(sp_StringScanner *sc) {
     return sc->pos;
@@ -147,15 +163,26 @@ const char *sp_StringScanner_getch(sp_StringScanner *sc) {
     return sc->matched;
 }
 
-/* peek(n) — look ahead n characters without advancing */
+/* peek(n) — look ahead n characters without advancing.
+   Issue #813: reuse the cached peek buffer across calls so a
+   tight peek() loop doesn't leak one heap allocation per call.
+   Grow the cap on demand. */
 const char *sp_StringScanner_peek(sp_StringScanner *sc, int64_t n) {
-    if (sc->pos >= sc->source_len) return "";
+    if (!sc || 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;
+    if (n < 0) n = 0;
+    if (n + 1 > sc->peek_buf_cap) {
+        int64_t nc = sc->peek_buf_cap ? sc->peek_buf_cap : 16;
+        while (nc < n + 1) nc *= 2;
+        char *nb = (char *)realloc(sc->peek_buf, (size_t)nc);
+        if (!nb) return "";
+        sc->peek_buf = nb;
+        sc->peek_buf_cap = nc;
+    }
+    memcpy(sc->peek_buf, sc->source + sc->pos, n);
+    sc->peek_buf[n] = '\0';
+    return sc->peek_buf;
 }
 
 /* unscan — revert to position before last scan */

data/vendor/spinel/lib/strscan.rb

@@ -1,55 +1,8 @@
 # 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
+# StringScanner is a builtin class — methods are intercepted in
+# codegen and dispatched to the sp_StringScanner_* helpers in
+# lib/sp_strscan.c (linked from libspinel_rt.a). This file is
+# intentionally empty so spinel doesn't try to emit a struct
+# for the class. `require "strscan"` still has to find the file
+# (the parser includes it via resolve_plain_requires).

data/vendor/spinel/node_table_loader.rb

@@ -0,0 +1,150 @@
+# Loads Spinel's text AST format into a node table object.
+#
+# The table object supplies the parallel-array storage operations used by
+# Compiler: alloc_node, set_root_id, set_node_type, set_node_content, and
+# set_*_field.
+
+class NodeTableLoader
+  def initialize(table)
+    @table = table
+  end
+
+  def read_text_ast(data)
+    lines = data.split(10.chr)
+ # Pass 1: find max node ID
+    max_id = 0
+    i = 0
+    while i < lines.length
+      line = lines[i]
+      if line.length > 0
+        parts = line.split(" ")
+        if parts.length >= 2
+          if parts.first == "ROOT"
+            @table.set_root_id(parts[1].to_i)
+          end
+ # Issue #878: SOURCE_FILE <escaped-path> appears once near the
+ # top of the AST. Loader stashes the unescaped path on the
+ # table so __dir__ et al. can recover it without scanning
+ # SourceFileNode entries (which only exist if the source
+ # references __FILE__).
+          if parts.first == "SOURCE_FILE"
+            if parts.length >= 2
+              @table.set_source_file_path(unescape_str(parts[1]))
+            end
+          end
+ # Debug multi-file map (FILE <id> <escaped-path>): records which
+ # original file each node's `node_file` id refers to, so codegen can
+ # emit `#line N "file"` across require_relative-inlined sources.
+          if parts.first == "FILE"
+            if parts.length >= 3
+              @table.set_file_entry(parts[1].to_i, unescape_str(parts[2]))
+            end
+          end
+          if parts.first == "N"
+            nid = parts[1].to_i
+            if nid > max_id
+              max_id = nid
+            end
+          end
+        end
+      end
+      i = i + 1
+    end
+ # Allocate all node slots in one bulk presize pass instead of
+ # max_id+1 separate alloc_node calls. The bulk path avoids ~46 * N
+ # Array#push operations (and their amortized realloc events).
+    @table.alloc_nodes(max_id + 1)
+ # Pass 2: populate fields
+    i = 0
+    while i < lines.length
+      line = lines[i]
+      if line.length > 0
+        ast_parse_line(line)
+      end
+      i = i + 1
+    end
+  end
+
+  def ast_parse_line(line)
+    parts = line.split(" ")
+    if parts.length < 3
+      return
+    end
+    tag = parts.first
+    nid = parts[1].to_i
+    if tag == "N"
+      @table.set_node_type(nid, parts[2])
+    elsif tag == "S"
+      field = parts[2]
+      val = ""
+      if parts.length >= 4
+        val = unescape_str(parts[3])
+      end
+      @table.set_string_field(nid, field, val)
+    elsif tag == "I"
+      field = parts[2]
+      ival = 0
+      if parts.length >= 4
+        ival = parts[3].to_i
+      end
+      @table.set_int_field(nid, field, ival)
+    elsif tag == "F"
+      if parts.length >= 4
+        @table.set_node_content(nid, parts[3])
+      end
+    elsif tag == "R"
+      field = parts[2]
+      ref_id = -1
+      if parts.length >= 4
+        ref_id = parts[3].to_i
+      end
+      @table.set_ref_field(nid, field, ref_id)
+    elsif tag == "A"
+      field = parts[2]
+      ids_str = ""
+      if parts.length >= 4
+        ids_str = parts[3]
+      end
+      @table.set_array_field(nid, field, ids_str)
+    end
+    0
+  end
+
+  def unescape_str(s)
+    result = ""
+    i = 0
+    while i < s.length
+      ch = s[i]
+      if ch == "%"
+        if i + 2 < s.length
+          hex = s[i + 1] + s[i + 2]
+          case hex
+          when "0A"
+            result = result + 10.chr
+          when "0D"
+            result = result + 13.chr
+          when "09"
+            result = result + 9.chr
+          when "20"
+            result = result + " "
+          when "25"
+            result = result + "%"
+          when "00"
+ # Issue #722: NUL byte (literal embedded in a Ruby string).
+            result = result + 0.chr
+          else
+            result = result + "%" + hex
+          end
+          i = i + 3
+        else
+          result = result + ch
+          i = i + 1
+        end
+      else
+        result = result + ch
+        i = i + 1
+      end
+    end
+    result
+  end
+end