rubyduino 0.1.3 → 0.2.1

data/vendor/spinel/lib/sp_strscan.c

@@ -0,0 +1,320 @@
+/*
+ * sp_strscan.c — StringScanner for Spinel
+ *
+ * Implements the StringScanner methods: scan, check, scan_until,
+ * matched, matched?, pos, eos?, getch, peek, unscan, rest,
+ * terminate, pre_match, post_match, string. Uses spinel's
+ * internal regex engine (re_compile / re_exec — see lib/regexp/)
+ * rather than oniguruma; the existing lib/strscan.c is an
+ * oniguruma-based draft the rest of the build doesn't link.
+ *
+ * Matching semantics: scan / check are anchored at the current
+ * position (re_exec is run with start=pos and the result is
+ * accepted only when caps[0] == pos). scan_until returns text
+ * from pos through the end of the next match anywhere ahead.
+ *
+ * The scanner struct is GC-allocated via the sp_ext_* shim so
+ * the lifetime tracks the main file's heap instead of leaking.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "mruby_shim.h"
+
+/* Forward decl mirrors lib/regexp/re_internal.h's public API. */
+typedef struct mrb_regexp_pattern mrb_regexp_pattern;
+extern int re_exec(const mrb_regexp_pattern *pat, const char *str, int64_t len, int64_t start, int *captures, int captures_size);
+
+/* GC shim provided by sp_runtime.h. */
+extern char *sp_ext_str_alloc(size_t n);
+extern void  sp_ext_str_set_len(char *s, size_t n);
+extern const char *sp_ext_str_empty(void);
+extern size_t sp_ext_str_byte_len(const char *s);
+extern void *sp_ext_gc_alloc(size_t sz, void (*fin)(void *), void (*scan)(void *));
+extern void  sp_ext_mark_string(const char *s);
+extern void  sp_raise_cls(const char *cls, const char *msg);
+
+/* The scanner struct lives in spinel's GC heap. `source` /
+   `matched` are GC-tracked strings; the scan function below
+   marks them so they survive collection. */
+/* Capture slots stored from the last successful scan/check, so
+   StringScanner#[] can return numbered groups. caps holds [start,end)
+   byte offsets into `source`, group 0 first; unmatched groups are -1.
+   ncaps is the number of valid ints (2 per group, group 0 included). */
+#define SP_SS_MAXCAP 20
+typedef struct {
+  const char *source;
+  const char *matched;
+  int64_t     pos;
+  int64_t     last_pos;
+  int         matched_p; /* int (not mrb_bool) — keep the layout
+                            compact; FALSE=0, TRUE=1 */
+  int         ncaps;
+  int         caps[SP_SS_MAXCAP];
+} sp_StringScanner;
+
+static void sp_StringScanner_scan_gc(void *p) {
+  sp_StringScanner *sc = (sp_StringScanner *)p;
+  if (sc->source) sp_ext_mark_string(sc->source);
+  if (sc->matched) sp_ext_mark_string(sc->matched);
+}
+
+sp_StringScanner *sp_StringScanner_new(const char *str) {
+  sp_StringScanner *sc = (sp_StringScanner *)sp_ext_gc_alloc(sizeof(sp_StringScanner), NULL, sp_StringScanner_scan_gc);
+  sc->source = str ? str : sp_ext_str_empty();
+  sc->matched = sp_ext_str_empty();
+  sc->pos = 0;
+  sc->last_pos = 0;
+  sc->matched_p = 0;
+  sc->ncaps = 0;
+  return sc;
+}
+
+/* Clamp re_exec's returned ncap to the stored caps[] size. */
+static int sc_clamp_ncaps(int n) {
+  if (n < 0) return 0;
+  if (n > SP_SS_MAXCAP) return SP_SS_MAXCAP;
+  return n;
+}
+
+/* Anchored match: succeed only when re_exec finds a match
+   starting at exactly `pos`. Returns matched length, or -1. */
+static int64_t sc_match_at_pos(const mrb_regexp_pattern *pat, const char *str, int64_t slen, int64_t pos, int *caps, int *ncap_out) {
+  int n = re_exec(pat, str, slen, pos, caps, SP_SS_MAXCAP);
+  *ncap_out = sc_clamp_ncaps(n);
+  if (n <= 0 || caps[0] != pos) return -1;
+  return caps[1] - caps[0];
+}
+
+/* Forward-search match: returns offset of first match at or
+   after pos, and writes matched length to *mlen. -1 on miss. */
+static int64_t sc_match_forward(const mrb_regexp_pattern *pat, const char *str, int64_t slen, int64_t pos, int64_t *mlen, int *caps, int *ncap_out) {
+  int n = re_exec(pat, str, slen, pos, caps, SP_SS_MAXCAP);
+  *ncap_out = sc_clamp_ncaps(n);
+  if (n <= 0 || caps[0] < 0) return -1;
+  *mlen = caps[1] - caps[0];
+  return caps[0];
+}
+
+static char *sc_substr(const char *src, int64_t start, int64_t len) {
+  char *out = sp_ext_str_alloc((size_t)len);
+  memcpy(out, src + start, (size_t)len);
+  out[len] = 0;
+  sp_ext_str_set_len(out, (size_t)len);
+  return out;
+}
+
+/* Byte length of the UTF-8 character starting at src[pos], clamped so a
+   truncated or invalid lead byte near the end never reads past `len`.
+   Mirrors sp_utf8_advance in sp_runtime.h, which isn't visible from here
+   (this file includes only mruby_shim.h). */
+static int64_t sc_char_len(const char *src, int64_t pos, int64_t len) {
+  unsigned char c = (unsigned char)src[pos];
+  int64_t n = 1;
+  if (c >= 0xF0) n = 4;
+  else if (c >= 0xE0) n = 3;
+  else if (c >= 0xC0) n = 2;
+  int64_t i = 1;
+  while (i < n && pos + i < len && ((unsigned char)src[pos + i] & 0xC0) == 0x80) i++;
+  return i;
+}
+
+const char *sp_StringScanner_scan(sp_StringScanner *sc, mrb_regexp_pattern *pat) {
+  if (!sc || !pat) return NULL;
+  int64_t slen = (int64_t)sp_ext_str_byte_len(sc->source);
+  int64_t mlen = sc_match_at_pos(pat, sc->source, slen, sc->pos, sc->caps, &sc->ncaps);
+  if (mlen < 0) {
+    sc->matched = sp_ext_str_empty();
+    sc->matched_p = 0;
+    sc->ncaps = 0;
+    return NULL;
+  }
+  char *m = sc_substr(sc->source, sc->pos, mlen);
+  sc->last_pos = sc->pos;
+  sc->matched = m;
+  sc->matched_p = 1;
+  sc->pos += mlen;
+  return m;
+}
+
+const char *sp_StringScanner_check(sp_StringScanner *sc, mrb_regexp_pattern *pat) {
+  if (!sc || !pat) return NULL;
+  int64_t slen = (int64_t)sp_ext_str_byte_len(sc->source);
+  int64_t mlen = sc_match_at_pos(pat, sc->source, slen, sc->pos, sc->caps, &sc->ncaps);
+  if (mlen < 0) {
+    sc->matched = sp_ext_str_empty();
+    sc->matched_p = 0;
+    sc->ncaps = 0;
+    return NULL;
+  }
+  char *m = sc_substr(sc->source, sc->pos, mlen);
+  sc->last_pos = sc->pos;
+  sc->matched = m;
+  sc->matched_p = 1;
+  return m;
+}
+
+const char *sp_StringScanner_scan_until(sp_StringScanner *sc, mrb_regexp_pattern *pat) {
+  if (!sc || !pat) return sp_ext_str_empty();
+  int64_t slen = (int64_t)sp_ext_str_byte_len(sc->source);
+  int64_t mlen = 0;
+  int64_t mstart = sc_match_forward(pat, sc->source, slen, sc->pos, &mlen, sc->caps, &sc->ncaps);
+  if (mstart < 0) {
+    sc->matched = sp_ext_str_empty();
+    sc->matched_p = 0;
+    sc->ncaps = 0;
+    return NULL;
+  }
+  int64_t consumed = (mstart + mlen) - sc->pos;
+  char *taken = sc_substr(sc->source, sc->pos, consumed);
+  char *m = sc_substr(sc->source, mstart, mlen);
+  sc->last_pos = sc->pos;
+  sc->matched = m;
+  sc->matched_p = 1;
+  sc->pos = mstart + mlen;
+  return taken;
+}
+
+/* StringScanner#[n] -- the nth capture group of the last scan/check.
+   Group 0 is the whole match. Returns NULL (Ruby nil) when there was
+   no match, the index is out of range, or the group didn't
+   participate. */
+const char *sp_StringScanner_aref(sp_StringScanner *sc, mrb_int n) {
+  if (!sc || !sc->matched_p || n < 0) return NULL;
+  int idx = (int)n;
+  if (2 * idx + 1 >= sc->ncaps) return NULL;
+  int st = sc->caps[2 * idx];
+  int en = sc->caps[2 * idx + 1];
+  if (st < 0 || en < st) return NULL;
+  return sc_substr(sc->source, st, en - st);
+}
+
+const char *sp_StringScanner_matched(sp_StringScanner *sc) {
+  if (!sc || !sc->matched_p) return NULL;
+  return sc->matched ? sc->matched : NULL;
+}
+
+mrb_bool sp_StringScanner_matched_p(sp_StringScanner *sc) {
+  if (!sc) return FALSE;
+  return sc->matched_p ? TRUE : FALSE;
+}
+
+mrb_int sp_StringScanner_pos(sp_StringScanner *sc) {
+  if (!sc) return 0;
+  return (mrb_int)sc->pos;
+}
+
+mrb_int sp_StringScanner_pos_set(sp_StringScanner *sc, mrb_int p) {
+  if (!sc) return 0;
+  sc->pos = (int64_t)p;
+  return p;
+}
+
+mrb_bool sp_StringScanner_eos_p(sp_StringScanner *sc) {
+  if (!sc) return TRUE;
+  int64_t slen = (int64_t)sp_ext_str_byte_len(sc->source);
+  return (sc->pos >= slen) ? TRUE : FALSE;
+}
+
+const char *sp_StringScanner_getch(sp_StringScanner *sc) {
+  if (!sc) return sp_ext_str_empty();
+  int64_t slen = (int64_t)sp_ext_str_byte_len(sc->source);
+  if (sc->pos >= slen) {
+    sc->matched = sp_ext_str_empty();
+    sc->matched_p = 0;
+    return NULL;
+  }
+  int64_t clen = sc_char_len(sc->source, sc->pos, slen);
+  char *c = sc_substr(sc->source, sc->pos, clen);
+  sc->last_pos = sc->pos;
+  sc->matched = c;
+  sc->matched_p = 1;
+  sc->pos += clen;
+  return c;
+}
+
+const char *sp_StringScanner_peek(sp_StringScanner *sc, mrb_int n) {
+  if (!sc) return sp_ext_str_empty();
+  int64_t slen = (int64_t)sp_ext_str_byte_len(sc->source);
+  int64_t avail = slen - sc->pos;
+  int64_t take = n < avail ? n : avail;
+  if (take < 0) take = 0;
+  return sc_substr(sc->source, sc->pos, take);
+}
+
+sp_StringScanner *sp_StringScanner_unscan(sp_StringScanner *sc) {
+  if (!sc) return sc;
+  /* CRuby raises StringScanner::Error when there is no match record to
+     rewind to: a double unscan, or unscan before any successful scan.
+     Guard before mutating state so a failed unscan leaves pos intact. */
+  if (!sc->matched_p) {
+    sp_raise_cls("StringScanner_Error",
+                 "unscan failed: previous match record not exist");
+  }
+  sc->pos = sc->last_pos;
+  sc->matched = sp_ext_str_empty();
+  sc->matched_p = 0;
+  return sc;
+}
+
+const char *sp_StringScanner_rest(sp_StringScanner *sc) {
+  if (!sc) return sp_ext_str_empty();
+  int64_t slen = (int64_t)sp_ext_str_byte_len(sc->source);
+  int64_t rem = slen - sc->pos;
+  if (rem <= 0) return sp_ext_str_empty();
+  return sc_substr(sc->source, sc->pos, rem);
+}
+
+mrb_int sp_StringScanner_rest_size(sp_StringScanner *sc) {
+  if (!sc) return 0;
+  int64_t slen = (int64_t)sp_ext_str_byte_len(sc->source);
+  int64_t rem = slen - sc->pos;
+  return rem < 0 ? 0 : (mrb_int)rem;
+}
+
+mrb_bool sp_StringScanner_rest_p(sp_StringScanner *sc) {
+  if (!sc) return FALSE;
+  int64_t slen = (int64_t)sp_ext_str_byte_len(sc->source);
+  return (sc->pos < slen) ? TRUE : FALSE;
+}
+
+sp_StringScanner *sp_StringScanner_terminate(sp_StringScanner *sc) {
+  if (!sc) return sc;
+  sc->pos = (int64_t)sp_ext_str_byte_len(sc->source);
+  sc->matched = sp_ext_str_empty();
+  sc->matched_p = 0;
+  return sc;
+}
+
+const char *sp_StringScanner_string(sp_StringScanner *sc) {
+  if (!sc) return sp_ext_str_empty();
+  return sc->source ? sc->source : sp_ext_str_empty();
+}
+
+const char *sp_StringScanner_pre_match(sp_StringScanner *sc) {
+  if (!sc || !sc->matched_p) return NULL;
+  if (sc->last_pos <= 0) return sp_ext_str_empty();
+  return sc_substr(sc->source, 0, sc->last_pos);
+}
+
+const char *sp_StringScanner_post_match(sp_StringScanner *sc) {
+  if (!sc || !sc->matched_p) return NULL;
+  int64_t mlen = (int64_t)sp_ext_str_byte_len(sc->matched);
+  int64_t start = sc->last_pos + mlen;
+  int64_t slen = (int64_t)sp_ext_str_byte_len(sc->source);
+  int64_t rem = slen - start;
+  if (rem <= 0) return sp_ext_str_empty();
+  return sc_substr(sc->source, start, rem);
+}
+
+sp_StringScanner *sp_StringScanner_reset(sp_StringScanner *sc) {
+  if (!sc) return sc;
+  sc->pos = 0;
+  sc->last_pos = 0;
+  sc->matched = sp_ext_str_empty();
+  sc->matched_p = 0;
+  return sc;
+}

data/vendor/spinel/lib/sp_system.c

@@ -0,0 +1,173 @@
+/* sp_system.c -- system()/backtick support in libspinel_rt.a.
+ * See sp_system.h.
+ *
+ * Self-contained (libc + OS process API only); does not include
+ * sp_runtime.h, so it carries its own mrb_bool/TRUE/FALSE locally to
+ * avoid the mruby_shim.h mrb_bool conflict (same as sp_core.c). */
+#include "sp_system.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <errno.h>
+#ifdef _WIN32
+#include <process.h>
+#else
+#include <unistd.h>
+#include <sys/wait.h>
+#endif
+
+typedef int mrb_bool;
+#ifndef TRUE
+#define TRUE 1
+#endif
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+int sp_last_status = 0;
+
+#ifdef _WIN32
+/* Quote a single argv element for the Windows command line, following
+   the CommandLineToArgvW backslash/quote rules so spaces and embedded
+   quotes survive the round-trip through _spawnvp's flat command string. */
+static char *sp_win_quote_arg(const char *arg) {
+  const char *p = arg;
+  size_t len = 2;
+  mrb_bool quote = (*p == '\0') ? TRUE : FALSE;
+  while (*p) {
+    if (isspace((unsigned char)*p) || *p == '"') quote = TRUE;
+    if (*p == '"') {
+      len += 2;
+    }
+    else {
+      len += 1;
+    }
+    p++;
+  }
+  if (!quote) {
+    char *copy = (char *)malloc(len - 1);
+    if (copy) memcpy(copy, arg, len - 1);
+    return copy;
+  }
+
+  p = arg;
+  size_t bs = 0;
+  len = 3;
+  while (*p) {
+    if (*p == '\\') {
+      bs++;
+    }
+    else if (*p == '"') {
+      len += bs * 2 + 2;
+      bs = 0;
+    }
+    else {
+      len += bs + 1;
+      bs = 0;
+    }
+    p++;
+  }
+  len += bs * 2;
+
+  char *out = (char *)malloc(len);
+  if (!out) return NULL;
+  char *q = out;
+  *q++ = '"';
+  p = arg;
+  bs = 0;
+  while (*p) {
+    if (*p == '\\') {
+      bs++;
+    }
+    else if (*p == '"') {
+      while (bs > 0) {
+        *q++ = '\\';
+        *q++ = '\\';
+        bs--;
+      }
+      *q++ = '\\';
+      *q++ = '"';
+      bs = 0;
+    }
+    else {
+      while (bs > 0) {
+        *q++ = '\\';
+        bs--;
+      }
+      *q++ = *p;
+      bs = 0;
+    }
+    p++;
+  }
+  while (bs > 0) {
+    *q++ = '\\';
+    *q++ = '\\';
+    bs--;
+  }
+  *q++ = '"';
+  *q = '\0';
+  return out;
+}
+#endif
+
+int sp_system_args(int argc, const char *const *argv) {
+  if (argc <= 0 || argv == NULL || argv[0] == NULL) {
+    sp_last_status = -1;
+    return FALSE;
+  }
+  fflush(NULL);
+#ifdef _WIN32
+  char **quoted_argv = (char **)malloc(sizeof(char *) * (size_t)(argc + 1));
+  if (!quoted_argv) {
+    sp_last_status = -1;
+    return FALSE;
+  }
+  int i = 0;
+  while (i < argc) {
+    if (argv[i] == NULL) {
+      while (i-- > 0) free(quoted_argv[i]);
+      free(quoted_argv);
+      sp_last_status = -1;
+      return FALSE;
+    }
+    quoted_argv[i] = sp_win_quote_arg(argv[i]);
+    if (!quoted_argv[i]) {
+      while (i-- > 0) free(quoted_argv[i]);
+      free(quoted_argv);
+      sp_last_status = -1;
+      return FALSE;
+    }
+    i++;
+  }
+  quoted_argv[argc] = NULL;
+
+  intptr_t rc = _spawnvp(_P_WAIT, argv[0], (const char *const *)quoted_argv);
+  for (i = 0; i < argc; i++) free(quoted_argv[i]);
+  free(quoted_argv);
+  if (rc < 0) {
+    sp_last_status = -1;
+    return FALSE;
+  }
+  sp_last_status = (int)rc << 8;
+  return rc == 0 ? TRUE : FALSE;
+#else
+  pid_t pid = fork();
+  if (pid < 0) {
+    sp_last_status = -1;
+    return FALSE;
+  }
+  if (pid == 0) {
+    execvp(argv[0], (char * const *)argv);
+    _exit(127);
+  }
+  int status = 0;
+  while (waitpid(pid, &status, 0) < 0) {
+    if (errno == EINTR) continue;
+    sp_last_status = -1;
+    return FALSE;
+  }
+  sp_last_status = status;
+  return (WIFEXITED(status) && WEXITSTATUS(status) == 0) ? TRUE : FALSE;
+#endif
+}

data/vendor/spinel/lib/sp_system.h

@@ -0,0 +1,16 @@
+/* sp_system.h -- system()/backtick support in libspinel_rt.a.
+ *
+ * `sp_last_status` backs Ruby's `$?` (the exit status of the last
+ * `system` / backtick). `sp_system_args` runs argv[0] with the rest as
+ * arguments (the multi-arg `system(...)` form), setting `sp_last_status`
+ * and returning whether the child exited 0. The bool result is declared
+ * as `int` to stay decoupled from the runtime's mrb_bool typedef and the
+ * mruby_shim.h conflict -- same convention as sp_core.h / sp_time.h.
+ */
+#ifndef SP_SYSTEM_H
+#define SP_SYSTEM_H
+
+extern int sp_last_status;
+int sp_system_args(int argc, const char *const *argv);
+
+#endif

data/vendor/spinel/lib/sp_time.c

@@ -0,0 +1,204 @@
+/* sp_time.c -- libc-backed Time implementations.
+ *
+ * Sibling to sp_bigint.c / sp_crypto.c. No spinel-runtime
+ * dependencies; the GC-aware wrappers (sp_box_time, sp_time_*_gc
+ * trampolines) live in sp_runtime.h.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#include "sp_time.h"
+
+sp_Time sp_time_now(void) {
+  struct timespec ts;
+  clock_gettime(CLOCK_REALTIME, &ts);
+  return (sp_Time){ ts.tv_sec, (int32_t)ts.tv_nsec, 0 };
+}
+
+sp_Time sp_time_at_int(int64_t sec) {
+  return (sp_Time){ sec, 0, 0 };
+}
+
+/* POSIX convention: keep tv_nsec in [0, 1e9). For negative epoch with
+   a non-integer fractional part, decrement tv_sec and roll the fraction
+   into the positive nsec range — so Time.at(-0.5).to_i returns -1, not 0. */
+sp_Time sp_time_at_float(double epoch) {
+  int64_t sec = (int64_t)epoch;
+  double frac = epoch - (double)sec;
+  if (frac < 0.0) {
+    sec -= 1;
+    frac += 1.0;
+  }
+  return (sp_Time){ sec, (int32_t)(frac * 1e9), 0 };
+}
+
+/* Time.new(y[,mo[,d[,h[,mi[,s]]]]]) — local construction. mktime
+   interprets the broken-down value in the host local zone and resolves
+   DST itself (tm_isdst=-1). The fixed-offset 7-arg form is a separate
+   issue. */
+sp_Time sp_time_new(int64_t y, int64_t mo, int64_t d,
+                    int64_t h, int64_t mi, int64_t s) {
+  struct tm tm;
+  memset(&tm, 0, sizeof(tm));
+  tm.tm_year = (int)y - 1900;
+  tm.tm_mon  = (int)mo - 1;
+  tm.tm_mday = (int)d;
+  tm.tm_hour = (int)h;
+  tm.tm_min  = (int)mi;
+  tm.tm_sec  = (int)s;
+  tm.tm_isdst = -1;
+  time_t e = mktime(&tm);
+  return (sp_Time){ (int64_t)e, 0, 0 };
+}
+
+/* Time.utc(y, m, d, h, mi, s) — UTC construction. Avoid timegm
+   (not portable; absent on MSVCRT). Compute the epoch via Howard
+   Hinnant's days_from_civil + a manual hour/minute/second add. */
+sp_Time sp_time_new_utc(int64_t y, int64_t mo, int64_t d,
+                        int64_t h, int64_t mi, int64_t s) {
+  int64_t yy = y - (mo <= 2 ? 1 : 0);
+  int64_t era = (yy >= 0 ? yy : yy - 399) / 400;
+  int64_t yoe = yy - era * 400;
+  int64_t doy = (153 * (mo + (mo > 2 ? -3 : 9)) + 2) / 5 + d - 1;
+  int64_t doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+  int64_t days = era * 146097 + doe - 719468;
+  int64_t e = days * 86400 + h * 3600 + mi * 60 + s;
+  return (sp_Time){ e, 0, 1 };
+}
+
+sp_Time sp_time_utc(sp_Time t) {
+  t.is_utc = 1;
+  return t;
+}
+
+sp_Time sp_time_localtime(sp_Time t) {
+  t.is_utc = 0;
+  return t;
+}
+
+/* is_utc selects gmtime vs localtime, off is UTC offset in seconds,
+   zbuf is the timezone abbreviation (8 bytes). mktime(gmtime(s))-s
+   is the portable offset technique (MSVCRT's %z emits the timezone
+   name, not ±HHMM). */
+void sp_time_vtm(sp_Time t, struct tm *bd, int32_t *off, char *zbuf) {
+  time_t s = (time_t)t.tv_sec;
+  if (t.is_utc) {
+    struct tm *g = gmtime(&s);
+    if (g) { *bd = *g; } else { memset(bd, 0, sizeof(*bd)); }
+    if (off) *off = 0;
+    if (zbuf) { zbuf[0]='U'; zbuf[1]='T'; zbuf[2]='C'; zbuf[3]=0; }
+  } else {
+    struct tm *l = localtime(&s);
+    if (l) { *bd = *l; } else { memset(bd, 0, sizeof(*bd)); }
+    if (off) {
+      struct tm gm = *gmtime(&s);
+      gm.tm_isdst = -1;
+      *off = (int32_t)(s - (time_t)mktime(&gm));
+    }
+    if (zbuf) {
+      if (strftime(zbuf, 8, "%Z", bd) == 0) zbuf[0] = 0;
+    }
+  }
+}
+
+int64_t sp_time_year(sp_Time t){struct tm b;sp_time_vtm(t,&b,NULL,NULL);return (int64_t)(b.tm_year+1900);}
+int64_t sp_time_mon(sp_Time t){struct tm b;sp_time_vtm(t,&b,NULL,NULL);return (int64_t)(b.tm_mon+1);}
+int64_t sp_time_mday(sp_Time t){struct tm b;sp_time_vtm(t,&b,NULL,NULL);return (int64_t)b.tm_mday;}
+int64_t sp_time_hour(sp_Time t){struct tm b;sp_time_vtm(t,&b,NULL,NULL);return (int64_t)b.tm_hour;}
+int64_t sp_time_min(sp_Time t){struct tm b;sp_time_vtm(t,&b,NULL,NULL);return (int64_t)b.tm_min;}
+int64_t sp_time_sec(sp_Time t){struct tm b;sp_time_vtm(t,&b,NULL,NULL);return (int64_t)b.tm_sec;}
+int64_t sp_time_wday(sp_Time t){struct tm b;sp_time_vtm(t,&b,NULL,NULL);return (int64_t)b.tm_wday;}
+int64_t sp_time_yday(sp_Time t){struct tm b;sp_time_vtm(t,&b,NULL,NULL);return (int64_t)(b.tm_yday+1);}
+int64_t sp_time_isdst(sp_Time t){struct tm b;sp_time_vtm(t,&b,NULL,NULL);return (int64_t)(b.tm_isdst>0?1:0);}
+int64_t sp_time_utc_offset(sp_Time t){int32_t o;struct tm b;sp_time_vtm(t,&b,&o,NULL);return (int64_t)o;}
+
+/* Time + Numeric / Time - Numeric. secs may be fractional, so split
+   into whole seconds plus a sub-second carry and keep tv_nsec
+   normalized to [0,1e9). is_utc is inherited from the receiver. */
+sp_Time sp_time_add(sp_Time t, double secs) {
+  int64_t whole = (int64_t)secs;
+  double frac = secs - (double)whole;
+  int64_t ns = (int64_t)t.tv_nsec + (int64_t)(frac * 1e9);
+  int64_t carry = ns / 1000000000;
+  ns -= carry * 1000000000;
+  if (ns < 0) { ns += 1000000000; carry -= 1; }
+  return (sp_Time){ t.tv_sec + whole + carry, (int32_t)ns, t.is_utc };
+}
+
+size_t sp_time_strftime_to(sp_Time t, const char *fmt, char *buf, size_t cap) {
+  time_t s = (time_t)t.tv_sec;
+  struct tm *lt = t.is_utc ? gmtime(&s) : localtime(&s);
+  if (lt == NULL) { if (cap > 0) buf[0] = 0; return 0; }
+  size_t n = strftime(buf, cap, fmt, lt);
+  if (n < cap) buf[n] = 0;
+  return n;
+}
+
+/* RFC 3339 / iso8601. Format date+time prefix with strftime, then
+   compute the UTC offset manually via mktime(gmtime(s)) - s (MSVCRT
+   %z renders the timezone name, so we do it ourselves). */
+size_t sp_time_iso8601_to(sp_Time t, char *buf, size_t cap) {
+  time_t s = (time_t)t.tv_sec;
+  if (t.is_utc) {
+    struct tm *gt = gmtime(&s);
+    if (gt == NULL) { if (cap > 0) buf[0] = 0; return 0; }
+    size_t n = strftime(buf, cap, "%Y-%m-%dT%H:%M:%SZ", gt);
+    return n;
+  }
+  struct tm *lt = localtime(&s);
+  if (lt == NULL) { if (cap > 0) buf[0] = 0; return 0; }
+  size_t n = strftime(buf, cap, "%Y-%m-%dT%H:%M:%S", lt);
+  if (n == 0 || n + 6 >= cap) return n;
+  struct tm gm = *gmtime(&s);
+  gm.tm_isdst = -1;
+  time_t gm_as_if_local = mktime(&gm);
+  long offset_sec = (long)(s - gm_as_if_local);
+  char sign = offset_sec >= 0 ? '+' : '-';
+  long abs_off = offset_sec < 0 ? -offset_sec : offset_sec;
+  int oh = (int)(abs_off / 3600);
+  int om = (int)((abs_off / 60) % 60);
+  buf[n++] = sign;
+  buf[n++] = (char)('0' + (oh / 10));
+  buf[n++] = (char)('0' + (oh % 10));
+  buf[n++] = ':';
+  buf[n++] = (char)('0' + (om / 10));
+  buf[n++] = (char)('0' + (om % 10));
+  buf[n] = 0;
+  return n;
+}
+
+size_t sp_time_zone_to(sp_Time t, char *buf, size_t cap) {
+  if (cap < 8) { if (cap > 0) buf[0] = 0; return 0; }
+  struct tm b;
+  sp_time_vtm(t, &b, NULL, buf);
+  return strlen(buf);
+}
+
+/* Scalar Time inspect. CRuby form: local "YYYY-MM-DD HH:MM:SS +0900",
+   UTC "YYYY-MM-DD HH:MM:SS UTC". */
+size_t sp_time_inspect_to(sp_Time t, char *buf, size_t cap) {
+  struct tm b;
+  int32_t off;
+  sp_time_vtm(t, &b, &off, NULL);
+  size_t n = strftime(buf, cap, "%Y-%m-%d %H:%M:%S", &b);
+  if (n == 0) {
+    int w = snprintf(buf, cap, "Time(%lld)", (long long)t.tv_sec);
+    return w > 0 ? (size_t)w : 0;
+  }
+  if (n + 8 >= cap) return n;
+  if (t.is_utc) {
+    buf[n++]=' '; buf[n++]='U'; buf[n++]='T'; buf[n++]='C'; buf[n]=0;
+  } else {
+    char sign = off >= 0 ? '+' : '-';
+    long a = off < 0 ? -(long)off : (long)off;
+    int oh = (int)(a / 3600);
+    int om = (int)((a / 60) % 60);
+    buf[n++]=' '; buf[n++]=sign;
+    buf[n++]=(char)('0'+oh/10); buf[n++]=(char)('0'+oh%10);
+    buf[n++]=(char)('0'+om/10); buf[n++]=(char)('0'+om%10);
+    buf[n]=0;
+  }
+  return n;
+}