qr_reader-native 0.0.1

data/ext/qr_reader_native/sp_str.h

@@ -0,0 +1,306 @@
+#ifndef SP_STR_H
+#define SP_STR_H
+/* sp_str.h -- cold String transforms compiled once in lib/sp_str.c.
+ *
+ * These are leaf `const char*` operations (case, strip, split-family,
+ * partition, dump/undump, concat, repeat, ...) that depend only on the
+ * shared string heap (sp_alloc.h) and the typed arrays (sp_array.h). The
+ * The UTF-8 decode/advance/encode + length-cache lookup are inline here
+ * (relocated from spinel_rt.h, codegen-neutral). The FNV hash cascade
+ * (#282) and sp_str_eq stay inline in spinel_rt.h (optcarrot-sensitive).
+ *
+ * sp_sprintf / sp_raise_cls are provided by the generated TU and resolved
+ * at the final link (same as lib/sp_core.c). */
+#include "sp_array.h"   /* sp_StrArray, sp_IntArray + sp_alloc.h / sp_gc.h / sp_types.h */
+
+const char *sp_sprintf(const char *fmt, ...) SP_PRINTF_FORMAT(1, 2);  /* defined in the generated TU */
+
+/* ---- hot UTF-8 + length-cache inline core (relocated from spinel_rt.h;
+   each generated TU still inlines these identically). Length-cache state
+   (sp_str_lcache / SP_STR_LCACHE_*) lives in sp_alloc.h / sp_alloc.c. ---- */
+static inline int sp_utf8_char_len(unsigned char c){if(c<0x80)return 1;if(c<0xC0)return 1;if(c<0xE0)return 2;if(c<0xF0)return 3;return 4;}
+static inline int sp_utf8_advance(const char*p){int cn=sp_utf8_char_len((unsigned char)*p);int i=1;while(i<cn&&((unsigned char)p[i]&0xC0)==0x80)i++;return i;}
+static inline int sp_utf8_decode(const char*p,uint32_t*out){unsigned char c=(unsigned char)p[0];if(c<0x80){*out=c;return 1;}if(c<0xC0){*out=c;return 1;}unsigned char c1=(unsigned char)p[1];if((c1&0xC0)!=0x80){*out=c;return 1;}if(c<0xE0){*out=((uint32_t)(c&0x1F)<<6)|(c1&0x3F);return 2;}unsigned char c2=(unsigned char)p[2];if((c2&0xC0)!=0x80){*out=c;return 1;}if(c<0xF0){*out=((uint32_t)(c&0x0F)<<12)|((uint32_t)(c1&0x3F)<<6)|(c2&0x3F);return 3;}unsigned char c3=(unsigned char)p[3];if((c3&0xC0)!=0x80){*out=c;return 1;}*out=((uint32_t)(c&0x07)<<18)|((uint32_t)(c1&0x3F)<<12)|((uint32_t)(c2&0x3F)<<6)|(c3&0x3F);return 4;}
+static inline int sp_utf8_encode(uint32_t cp,char*out){if(cp<0x80){out[0]=(char)cp;return 1;}if(cp<0x800){out[0]=(char)(0xC0|(cp>>6));out[1]=(char)(0x80|(cp&0x3F));return 2;}if(cp<0x10000){out[0]=(char)(0xE0|(cp>>12));out[1]=(char)(0x80|((cp>>6)&0x3F));out[2]=(char)(0x80|(cp&0x3F));return 3;}out[0]=(char)(0xF0|(cp>>18));out[1]=(char)(0x80|((cp>>12)&0x3F));out[2]=(char)(0x80|((cp>>6)&0x3F));out[3]=(char)(0x80|(cp&0x3F));return 4;}
+#define sp_str_lcache_hash sp_str_lcache_slot
+/* 0xf1 is frozen -- an explicitly frozen heap string, and every string literal
+   (frozen string literals are permanent). Its contents can never change, so its
+   character length is the most cacheable of all; leaving it out meant #length,
+   #[] and every character index on a literal rescanned the whole string on each
+   call. 0xfd (the sp_String append buffer) is in as well: its length moves, but
+   every mutation goes through sp_fd_publish, which drops the entry -- without
+   it a scan loop over a built-up string rewalked the whole buffer per index. */
+static inline int sp_str_cacheable(const char *s) {
+  unsigned char m = ((const unsigned char *)s)[-1];
+  return m == 0xfe || m == 0xfc || m == 0xff || m == 0xf1 || m == 0xfd || m == 0xfb || m == 0xfa || m == 0xf8;
+}
+/* Byte-exact comparison of two heap strings. strcmp stops at the first NUL,
+   so two strings that differ only after one compared equal and sorted equal --
+   `\0` is an ordinary byte in a Ruby String, and the representation carries
+   the real length (#3471, #3472). Ordering matches CRuby's: memcmp over the
+   common prefix, then the shorter string first. */
+static inline int sp_str_cmp_bytes(const char *a, const char *b) {
+  size_t la = sp_str_byte_len(a), lb = sp_str_byte_len(b);
+  size_t n = la < lb ? la : lb;
+  int r = n ? memcmp(a, b, n) : 0;
+  if (r) return r < 0 ? -1 : 1;
+  if (la != lb) return la < lb ? -1 : 1;
+  /* identical bytes: CRuby falls back to the encoding index when the two are
+     not comparable, and ASCII-8BIT sorts before UTF-8 (rb_str_cmp). Both
+     ASCII-only stays 0, the way sp_str_eq answers true for it. */
+  { int ba = sp_str_is_binary(a), bb = sp_str_is_binary(b);
+    if (ba == bb) return 0;
+    for (size_t i = 0; i < la; i++)
+      if ((unsigned char)a[i] >= 0x80) return ba ? -1 : 1;
+    return 0; }
+}
+static inline void sp_str_split_push(sp_StrArray*a,const char*p,size_t n){
+  char*r=sp_str_alloc_raw(n+1);
+  memcpy(r,p,n);
+  r[n]=0;
+  /* record the real length: alloc_raw leaves it unset, so a piece holding an
+     embedded NUL would answer strlen and read short */
+  sp_str_set_len(r,n);
+  sp_StrArray_push(a,r);
+}
+
+int sp_utf8_set_has(const uint32_t*cps,size_t n,uint32_t cp);
+uint32_t sp_uc_toupper(uint32_t cp);
+uint32_t sp_uc_tolower(uint32_t cp);
+sp_int sp_str_casecmp(const char*a,const char*b);
+sp_bool sp_str_casecmp_p(const char*a,const char*b);
+sp_bool sp_str_valid_encoding(const char*s);
+const char*sp_str_field(const char*s,const char*sep,sp_int n);
+sp_int sp_str_field_count(const char*s,const char*sep);
+const char*sp_str_concat(const char*a,const char*b);
+const char*sp_str_append_bytes(const char*a,const char*b);
+const char*sp_str_concat3(const char*a,const char*b,const char*c);
+const char*sp_str_concat4(const char*a,const char*b,const char*c,const char*d);
+const char*sp_str_concat_arr(const char *const *parts,int n);
+const char*sp_str_inspect(const char*s);
+sp_bool sp_sym_plain_name_p(const char *p, sp_bool allow_suffix);
+sp_bool sp_sym_simple_p(const char *n);
+const char *sp_sym_inspect_name(const char *name);
+const char *sp_sym_inspect_key(const char *name);
+const char*sp_str_upcase(const char*s);
+const char*sp_str_downcase(const char*s);
+const char*sp_str_swapcase(const char*s);
+const char*sp_str_upcase_ascii(const char*s);
+const char*sp_str_downcase_ascii(const char*s);
+const char*sp_str_swapcase_ascii(const char*s);
+const char*sp_str_capitalize_ascii(const char*s);
+const char*sp_str_dump(const char*s);
+const char*sp_str_delete_prefix(const char*s,const char*p);
+const char*sp_str_substr(const char*s,sp_int start,sp_int len);
+const char *sp_str_append_grow(const char *s, const char *t);
+const char *sp_str_append_grow_n(const char *s, const char *t, size_t lb);   /* the first lb bytes of t */
+const char*sp_str_delete_suffix(const char*s,const char*p);
+const char*sp_str_strip(const char*s);
+const char*sp_str_chomp(const char*s);
+const char *sp_str_chomp_sep(const char *s, const char *sep);
+const char*sp_str_chop(const char*s);
+const char*sp_str_chr(const char*s);
+sp_int sp_str_byte_to_char(const char*s,sp_int byteoff);
+sp_bool sp_str_include(const char*s,const char*sub);
+sp_bool sp_str_start_with(const char*s,const char*p);
+sp_bool sp_str_end_with(const char*s,const char*suf);
+sp_StrArray *sp_str_partition(const char *s, const char *sep);
+sp_StrArray *sp_str_rpartition(const char *s, const char *sep);
+sp_StrArray*sp_str_lines(const char*s);
+sp_StrArray*sp_str_lines_sep(const char*s,const char*sep);
+sp_StrArray*sp_str_lines_sep_chomp(const char*s,const char*sep);
+sp_StrArray*sp_str_lines_chomp(const char*s);
+const char*sp_str_byteslice(const char*s,sp_int start,sp_int len);
+const char*sp_str_byteslice1(const char*s,sp_int i);
+const char*sp_str_byteslice_range(const char*s,sp_int lo,sp_int hi,int excl,int lo_none,int hi_none);
+const char*sp_str_bytesplice(const char*s,sp_int start,sp_int len,const char*val);
+int sp_str_ascii_only(const char*s);
+int sp_str_enc_step(int state, const char *acc, size_t acc_len, const char *part, size_t part_len, int part_bin);
+/* the common step inline: a part in the encoding so far keeps it */
+static inline int sp_str_enc_step_i(int state, const char *acc, size_t acc_len, const char *part, size_t part_len, int part_bin) {
+  if (state == part_bin) return state;
+  return sp_str_enc_step(state, acc, acc_len, part, part_len, part_bin);
+}
+const char*sp_str_format_strarr(const char*fmt,sp_StrArray*a);
+const char*sp_str_sub(const char*s,const char*pat,const char*rep);
+const char*sp_str_remove_first(const char*s,const char*pat);
+const char*sp_str_capitalize(const char*s);
+const char*sp_str_repeat(const char*s,sp_int n);
+sp_IntArray*sp_str_bytes(const char*s);
+const char *sp_str_crypt(const char *s, const char *salt);
+const char*sp_str_lstrip(const char*s);
+const char*sp_str_rstrip(const char*s);
+const char*sp_str_dup(const char*s);
+const char *sp_plain_char(unsigned char c);
+const char *sp_bin_char(unsigned char c);
+const char*sp_str_b(const char*s);
+
+/* ---- utf8-dependent cold transforms (lib/sp_str.c) ---- */
+/* nil-receiver raise: a nullable string carries nil as NULL, and CRuby
+   answers NoMethodError. The bare primitives below stay total over NULL
+   (runtime internals pass legitimately-nil elements); the _m/_p variants
+   carry Ruby receiver semantics at method call sites. */
+SP_NORETURN SP_COLD void sp_nil_recv(const char *meth);
+sp_int sp_str_length_m(const char *s);
+sp_int sp_str_bytesize_m(const char *s);
+sp_bool sp_str_empty_p(const char *s);
+const char *sp_str_plus(const char *a, const char *b);
+const char *sp_str_plus_lit(const char *a, const char *lit, size_t ll);
+sp_int sp_str_count_chars(const char *s, size_t bl);
+sp_int sp_str_length(const char*s);
+sp_int sp_str_ord(const char*s);
+size_t sp_utf8_byte_offset(const char*s,sp_int char_idx);
+uint32_t*sp_utf8_decode_all(const char*s,size_t*out_n);
+uint32_t*sp_utf8_decode_charset(const char*s,size_t*out_n);
+uint32_t*sp_utf8_decode_charset_n(const char*s,size_t bl,size_t*out_n);
+void sp_str_split_into(sp_StrArray*a,const char*s,const char*sep);
+const char*sp_str_undump(const char*s);
+const char*sp_str_succ_impl(const char*s);
+const char*sp_str_succ(const char*s);
+const char*sp_str_succ_n(const char*s,sp_int n);
+sp_StrArray*sp_str_split(const char*s,const char*sep);
+sp_StrArray*sp_str_split_drop_trailing(const char*s,const char*sep);
+sp_StrArray*sp_str_split_limit(const char*s,const char*sep,sp_int n);
+sp_StrArray*sp_str_split_ws(const char*s);
+sp_StrArray*sp_str_split_ws_limit(const char*s,sp_int n);
+sp_StrArray*sp_str_scan(const char*s,const char*pat);
+sp_int sp_str_scan_at(const char*s,const char*pat,sp_int pos);
+const char*sp_str_gsub(const char*s,const char*pat,const char*rep);
+sp_int sp_str_index(const char*s,const char*sub);
+sp_int sp_str_index_from(const char*s,const char*sub,sp_int start);
+sp_int sp_str_rindex(const char*s,const char*sub);
+sp_int sp_str_rindex_from(const char*s,const char*sub,sp_int pos);
+sp_int sp_str_byteindex(const char*s,const char*sub);
+sp_int sp_str_byteindex_from(const char*s,const char*sub,sp_int start);
+sp_int sp_str_byterindex(const char*s,const char*sub);
+sp_int sp_str_byterindex_from(const char*s,const char*sub,sp_int pos);
+const char*sp_str_sub_range(const char*s,sp_int start,sp_int len);
+const char*sp_str_char_at_or_nil(const char*s,sp_int i);
+const char*sp_str_sub_range_len(const char*s,sp_int cl,sp_int start,sp_int len);
+const char*sp_str_sub_range_r(const char*s,sp_int start,sp_int end_,sp_int excl);
+const char*sp_str_sub_range_len_r(const char*s,sp_int cl,sp_int start,sp_int end_,sp_int excl);
+const char*sp_str_reverse(const char*s);
+sp_int sp_str_count(const char*s,const char*chars);
+sp_int sp_str_count_n(const char*s,const char**chars,sp_int n);
+sp_int sp_str_sum_bits(const char*s,sp_int bits);   /* String#sum(bits=16) */
+sp_IntArray*sp_str_codepoints(const char*s);
+sp_IntArray*sp_str_codepoints_all(const char*s);
+sp_StrArray*sp_str_chars(const char*s);
+const char*sp_str_tr(const char*s,const char*from,const char*to);
+const char*sp_str_tr_s(const char*s,const char*from,const char*to);
+const char*sp_str_delete(const char*s,const char*chars);
+const char*sp_str_squeeze(const char*s);
+const char*sp_str_squeeze_chars(const char*s,const char*cs);
+const char*sp_str_delete_n(const char*s,const char**chars,sp_int n);
+const char*sp_str_squeeze_n(const char*s,const char**chars,sp_int n);
+const char *sp_str_scrub(const char *s, const char *repl);
+const char *sp_str_scrub_utf8(const char *s, const char *repl);
+sp_int sp_str_scrub_bad(const char *s, sp_int bl, sp_int from, sp_int *len);
+const char *sp_str_scrub_repl(const char *r);
+const char *sp_str_encode(const char *s, sp_RbVal dst, sp_RbVal src, sp_RbVal invalid, sp_RbVal undef, sp_RbVal replace);
+const char *sp_str_scrub_bang(const char *s, const char *repl);
+const char*sp_str_ljust(const char*s,sp_int w);
+const char*sp_str_rjust(const char*s,sp_int w);
+const char*sp_str_center(const char*s,sp_int w);
+const char*sp_str_ljust2(const char*s,sp_int w,const char*pad);
+const char*sp_str_rjust2(const char*s,sp_int w,const char*pad);
+const char*sp_str_center2(const char*s,sp_int w,const char*pad);
+sp_int sp_str_index_opt(const char *s, const char *sub);
+sp_int sp_str_index_from_opt(const char *s, const char *sub, sp_int start);
+sp_int sp_str_rindex_opt(const char *s, const char *sub);
+
+/* ---- relocated from spinel_rt.h: hash key primitives (sp_str_hash /
+   sp_str_eq / _sp_istr_idx) used by lib/sp_hash.c's StrInt/StrStr/IntStr/
+   IntIntHash accessors. Still static (inline / noinline) -- each including
+   TU (the single generated TU via spinel_rt.h, and sp_hash.c) gets its own
+   private copy, so this is a pure textual relocation with no codegen change. ---- */
+/* NULL-safe string equality. ENV[] returns NULL for unset vars
+   (the dispatch is `sp_str_dup_external(getenv(...))`, which propagates
+   NULL), so emitted strcmp(...) on the result of `ENV["X"] == "1"` would
+   dereference NULL on either side. nil-vs-string equality is false in
+   Ruby; nil == nil is true, so falling back to pointer equality on the
+   NULL path covers both. */
+static inline int sp_str_eq(const char*a,const char*b){
+  if(a==b)return 1;
+  if(!a||!b)return 0;
+  if(strcmp(a,b)!=0)return 0;
+  /* strcmp equality is only prefix equality when a length header records
+     an embedded NUL ("a\0b" vs "a"): confirm byte-exact equality. The
+     miss path above stays a single strcmp. */
+  size_t la=sp_str_byte_len(a);
+  if(la!=sp_str_byte_len(b)||memcmp(a,b,la)!=0)return 0;
+  /* CRuby's rb_str_comparable: equal bytes are equal strings only when the
+     encodings are comparable -- the same encoding, or both operands ASCII
+     only. spinel has two, so the question is the BINARY tag; the ASCII scan
+     runs only when the tags disagree about bytes that already matched, which
+     keeps every ordinary comparison at the two reads above. */
+  if(sp_str_is_binary(a)==sp_str_is_binary(b))return 1;
+  for(size_t i=0;i<la;i++)if((unsigned char)a[i]>=0x80)return 0;
+  return 1;
+}
+/* Compare a spinel string against a PLAIN C string (a stack buffer, a literal
+   with no marker byte). sp_str_eq reads a marker in front of BOTH operands to
+   recover a length that can carry an embedded NUL; handing it unmarked memory
+   reads the byte before the object, and when that byte happens to look like a
+   marker it reads a bogus header and answers a garbage length. The plain side
+   has no embedded NUL by construction, so its length is strlen. */
+static inline sp_bool sp_str_eq_cstr(const char *marked, const char *plain) {
+  if (!marked || !plain) return (sp_bool)(marked == plain);
+  size_t lp = strlen(plain);
+  return (sp_bool)(sp_str_byte_len(marked) == lp && memcmp(marked, plain, lp) == 0);
+}
+
+/* String#valid_encoding? -- walks the buffer and accepts pure ASCII
+   or well-formed UTF-8 (RFC 3629 byte sequences with no overlong
+   forms, no surrogate halves, code points <= U+10FFFF). */
+/* A BINARY string hashes apart from its UTF-8 twin, but only when it holds a
+   byte that makes them incomparable: "abc".b and "abc" are eql? in CRuby and
+   hash together, "caf\xC3\xA9" and "café" are neither. The high-byte question
+   is answered inside the walk the hash already makes, so this costs one
+   register. */
+static inline uint64_t sp_str_hash_bytes(const char*s,int*saw_high){
+  uint64_t h=14695981039346656037ULL;int hi=0;
+  while(*s){unsigned char c=(unsigned char)*s++;hi|=(c>=0x80);h^=c;h*=1099511628211ULL;}
+  *saw_high=hi;return h;
+}
+static inline uint64_t sp_str_hash_compute(const char*s){
+  int hi=0;uint64_t h=sp_str_hash_bytes(s,&hi);
+  if(hi&&sp_str_is_binary(s))h^=0x9e3779b97f4a7c15ULL;
+  return h;
+}
+/* Cold path: compute (and, for a heap/heap-frozen string, cache) the FNV
+   hash. Kept out-of-line so sp_str_hash's inline fast path -- a cached-hash
+   read -- stays tiny and doesn't bloat every call site's code layout. */
+static SP_NOINLINE uint64_t sp_str_hash_miss(const char*s,unsigned char m){
+  if(m==0xfe||m==0xfc||m==0xf1||m==0xfa||m==0xf8){
+    sp_str_hdr*hd=((sp_str_hdr*)(s-1))-1;
+    uint64_t h=sp_str_hash_compute(s);
+    hd->hash=h?h:1;
+    return hd->hash;
+  }
+  return sp_str_hash_compute(s);
+}
+static inline uint64_t sp_str_hash(const char*s){
+  /* nil hashes like any other absent key: a String-keyed lookup with a nil
+     key answers "not present" in Ruby, and reading the tag byte at s[-1]
+     off a NULL faulted instead (#3790). sp_str_eq already answers false
+     against NULL, so the probe walks past every occupied slot. */
+  if(!s)return 14695981039346656037ULL;
+  unsigned char m=((const unsigned char*)s)[-1];
+  if(m==0xfe||m==0xfc||m==0xf1||m==0xfa||m==0xf8){
+    uint64_t cached=(((sp_str_hdr*)(s-1))-1)->hash;
+    if(cached)return cached;
+  }
+  return sp_str_hash_miss(s,m);
+}
+static inline sp_int _sp_istr_idx(sp_int mask,sp_int k){return(sp_int)(((uint64_t)(unsigned long long)k*11400714819323198485ULL)&(uint64_t)mask);}
+
+/* ---- more cold string ops relocated from spinel_rt.h (0 optcarrot
+   uses; deps already visible via sp_str.h's own sp_array.h include). ---- */
+sp_bool sp_str_in_list(const char *m, const char *const *list);
+sp_RbVal sp_str_index_poly(const char *s, const char *sub);
+sp_RbVal sp_str_index_from_poly(const char *s, const char *sub, sp_int start);
+sp_RbVal sp_str_rindex_poly(const char *s, const char *sub);
+sp_PolyArray *sp_str_lines_poly(const char *s);
+
+#endif /* SP_STR_H */

data/ext/qr_reader_native/sp_str_crypt.c

@@ -0,0 +1,23 @@
+/* sp_str_crypt.c -- String#crypt, through libc crypt(3).
+ *
+ * An object of its own in libspinel_rt.a, so only a program that calls
+ * String#crypt pulls it in: in sp_str.o every program referenced crypt(),
+ * and the link line's -lcrypt made libcrypt a dependency of hello world
+ * (#6674). src/main.c adds -lcrypt only when the generated C calls
+ * sp_str_crypt. */
+#include <string.h>
+#include <stdlib.h>
+#include "sp_str.h"
+const char *sp_str_crypt(const char *s, const char *salt) {SP_GC_ROOT_STR(s);SP_GC_ROOT_STR(salt);
+  /* the real libc crypt(3) -- DES with a 2-char salt (or the platform's
+     extended schemes), byte-identical to CRuby's String#crypt (#2398).
+     Declared by hand: glibc hides it behind crypt.h/_XOPEN_SOURCE while
+     macOS ships it in unistd.h. */
+  extern char *crypt(const char *key, const char *slt);
+  if (!s) sp_nil_recv("crypt");
+  if (!salt || !salt[0] || !salt[1])
+    sp_raise_cls("ArgumentError", "salt too short (need >=2 bytes)");
+  char *d = crypt(s, salt);
+  if (!d) sp_raise_cls("ArgumentError", "invalid salt");
+  return sp_str_dup_external(d);
+}

data/ext/qr_reader_native/sp_string.c

@@ -0,0 +1,92 @@
+/* sp_string.c -- the cold sp_String in-place mutators (see sp_string.h).
+   prepend / insert / replace / dup are off the hot string-building path, so they
+   are compiled once here instead of inline in every generated TU. */
+#include "sp_string.h"
+#include <string.h>
+
+void sp_String_prepend(sp_String*s,const char*t){SP_GC_ROOT(s);SP_GC_ROOT_STR(t);if(!s||!t)return;if(sp_String_is_frozen(s)){sp_raise_frozen_str(s->data);return;}int64_t tl=(int64_t)strlen(t);if(!sp_fd_grow(s,s->len+tl))return;memmove(s->data+tl,s->data,s->len+1);memcpy(s->data,t,tl);s->len+=tl;sp_fd_publish(s);}
+/* String#insert(idx, str): insert at idx; negative idx is relative to len+1. */
+void sp_String_insert(sp_String*s,int64_t idx,const char*t){SP_GC_ROOT(s);SP_GC_ROOT_STR(t);if(!s||!t)return;if(sp_String_is_frozen(s)){sp_raise_frozen_str(s->data);return;}int64_t tl=(int64_t)strlen(t);if(tl==0)return;if(idx<0)idx+=s->len+1;if(idx<0)idx=0;if(idx>s->len)idx=s->len;if(!sp_fd_grow(s,s->len+tl))return;memmove(s->data+idx+tl,s->data+idx,s->len-idx+1);memcpy(s->data+idx,t,tl);s->len+=tl;sp_fd_publish(s);}
+/* String#replace(s): replace entire content. */
+void sp_String_replace(sp_String*s,const char*t){SP_GC_ROOT(s);SP_GC_ROOT_STR(t);if(!s||!t)return;if(sp_String_is_frozen(s)){sp_raise_frozen_str(s->data);return;}int64_t tl=(int64_t)strlen(t);if(!sp_fd_grow(s,tl))return;memcpy(s->data,t,tl);s->data[tl]='\0';s->len=tl;sp_fd_publish(s);}
+sp_String*sp_String_dup(sp_String*s){SP_GC_ROOT(s);return sp_String_new(s->data);}
+/* The first growth past an inline payload (sp_String_new_inline_len) moves
+   it to a malloc'd block, which the object now owns: its bytes are counted
+   and the finalizer that frees them installed, as sp_String_new_len does
+   from the start. The inline room stays part of the object. Rare, and kept
+   out of sp_fd_grow so that one still inlines into every append. */
+int sp_fd_grow_inline(sp_String *s, int64_t need){
+  sp_gc_hdr *h = (sp_gc_hdr *)((char *)s - sizeof(sp_gc_hdr));
+  int64_t new_cap = (need * 2) + 16;
+  sp_str_lcache_drop(s->data);
+  char *raw = (char *)malloc(SP_FD_OVH + new_cap);
+  if (!raw) return 0;
+  char *data = sp_fd_setup(raw);
+  memcpy(data, s->data, (size_t)s->len + 1);
+  s->cap = new_cap; s->data = data; sp_fd_own(s);
+  h->size += s->cap + SP_FD_OVH; sp_gc_bytes_add(s->cap + SP_FD_OVH);
+  if (!h->finalize) { h->finalize = sp_String_fin; sp_slab_set_fin(h); }
+  return 1;
+}
+
+/* A handle made from a chilled String records the symbol whose to_s it holds
+   (sp_String.chilled is its id + 1). */
+void sp_String_chill(sp_String*r,const char*s){
+  if(sp_str_is_chilled(s))r->chilled=(unsigned)(sp_str_chilled_sym(s)+1);
+}
+/* Such a handle is chilled until its first mutation, which makes it plain
+   for good (CRuby's str_modify): sp_fd_publish clears the flag. A path that
+   changes the bytes without publishing is caught here, at +@, by the bytes
+   no longer being the symbol's name. */
+int sp_String_chilled_now(sp_String*h){
+  const char*nm=sp_sym_name_fn?sp_sym_name_fn((sp_sym)(h->chilled-1)):NULL;
+  size_t n=nm?sp_str_byte_len(nm):0;
+  if(nm&&(size_t)h->len==n&&memcmp(h->data,nm,n)==0)return 1;
+  h->chilled=0;
+  return 0;
+}
+/* Symbol#to_s and #id2name: CRuby answers a new chilled String each time
+   (sp_str_is_chilled), so `s = sym.to_s; t = +s` copies and `t << x` leaves
+   s alone. The symbol table's own name is a plain static that a handle would
+   take as an ordinary String, so each symbol gets one chilled copy, built at
+   its first to_s and kept as long as the symbol is: static storage with a
+   header, which the collector neither marks nor sweeps, and the symbol ahead
+   of it (sp_str_chilled_obj). The table is guarded by the heap lock, as the
+   dedup table is. */
+static const char**sp_sym_chilled_tab=NULL;
+static sp_int sp_sym_chilled_cap=0;
+const char*sp_sym_to_s_chilled(sp_sym id){
+  const char*nm=sp_sym_name_fn?sp_sym_name_fn(id):sp_str_empty;
+  if(id<0||!sp_sym_name_fn)return nm;
+  SP_HEAP_LOCK();
+  const char*hit=id<sp_sym_chilled_cap?sp_sym_chilled_tab[id]:NULL;
+  SP_HEAP_UNLOCK();
+  if(hit)return hit;
+  size_t n=sp_str_byte_len(nm);
+  sp_str_chilled_obj*o=(sp_str_chilled_obj*)malloc(sizeof(sp_str_chilled_obj)+n+1);
+  if(!o)return nm;
+  int ascii7=1;
+  for(size_t i=0;i<n;i++)if((unsigned char)nm[i]>=0x80)ascii7=0;
+  o->sym=id;
+  o->h.next=(sp_str_hdr*)&sp_str_chilled_tag;
+  o->h.size=(uint32_t)(n+1)|(ascii7?SP_STR_SIZE_ASCII7:0u)|(sp_str_is_binary(nm)?SP_STR_SIZE_BINARY:0u);
+  o->h.len=(uint32_t)n;o->h.hash=0;
+  o->m=0xfb;memcpy(o->d,nm,n);o->d[n]=0;
+  SP_HEAP_LOCK();
+  if(id>=sp_sym_chilled_cap){
+    sp_int nc=sp_sym_chilled_cap?sp_sym_chilled_cap:64;
+    while(nc<=id)nc*=2;
+    const char**nt=(const char**)realloc((void*)sp_sym_chilled_tab,(size_t)nc*sizeof(const char*));
+    if(nt){
+      memset((void*)(nt+sp_sym_chilled_cap),0,(size_t)(nc-sp_sym_chilled_cap)*sizeof(const char*));
+      sp_sym_chilled_tab=nt;sp_sym_chilled_cap=nc;
+    }
+  }
+  const char*r=o->d;
+  if(id<sp_sym_chilled_cap){
+    if(sp_sym_chilled_tab[id]){free(o);r=sp_sym_chilled_tab[id];}   /* another thread won */
+    else sp_sym_chilled_tab[id]=r;
+  }
+  SP_HEAP_UNLOCK();
+  return r;
+}