qr_reader-native 0.0.1

data/ext/qr_reader_native/sp_hash.c

@@ -0,0 +1,131 @@
+/* sp_hash.c -- cold CRUD ops for the 4 non-poly-valued typed hashes (see
+ * sp_hash.h). None of these types are hot in optcarrot, so the whole
+ * surface -- not just materializers -- lives here rather than in
+ * spinel_rt.h. sp_gc_alloc / sp_mark_string / sp_str_hash / sp_str_eq /
+ * sp_inspect_container are lib-visible. */
+#include "sp_hash.h"
+
+void sp_StrIntHash_fin(void*p){sp_StrIntHash*h=(sp_StrIntHash*)p;sp_pl_free(h->keys);sp_pl_free(h->vals);sp_pl_free(h->order);}
+void sp_StrIntHash_scan(void*p){sp_StrIntHash*h=(sp_StrIntHash*)p;for(sp_int i=0;i<h->cap;i++){if(h->keys[i])sp_mark_string(h->keys[i]);}}
+/* default_v is SP_INT_NIL for a hash with no explicit default ({} / {k=>v}),
+   so a missing-key `[]` read surfaces Ruby nil (#801). Hash.new(N) sets it to
+   N via _new_with_default. Proven-present internal reads use _get on present
+   keys, so this only governs the miss path. */
+sp_StrIntHash*sp_StrIntHash_new(void){sp_StrIntHash*h=(sp_StrIntHash*)sp_gc_alloc(sizeof(sp_StrIntHash),sp_StrIntHash_fin,sp_StrIntHash_scan);h->cap=16;h->mask=15;h->keys=(const char**)sp_pl_zalloc((size_t)h->cap*sizeof(const char*));h->vals=(sp_int*)sp_pl_zalloc((size_t)h->cap*sizeof(sp_int));h->order=(const char**)sp_pl_alloc(sizeof(const char*)*h->cap);h->len=0;h->default_v=SP_INT_NIL;return h;}
+sp_StrIntHash*sp_StrIntHash_new_with_default(sp_int d){sp_StrIntHash*h=sp_StrIntHash_new();h->default_v=d;return h;}
+void sp_StrIntHash_grow(sp_StrIntHash*h){SP_GC_ROOT(h); sp_gc_wb((void*)h);sp_int oc=h->cap;const char**ok=h->keys;sp_int*ov=h->vals;h->cap*=2;h->mask=h->cap-1;h->keys=(const char**)sp_pl_zalloc((size_t)h->cap*sizeof(const char*));h->vals=(sp_int*)sp_pl_zalloc((size_t)h->cap*sizeof(sp_int));h->order=(const char**)sp_pl_realloc(h->order,sizeof(const char*)*h->cap);h->len=0;for(sp_int i=0;i<oc;i++){if(ok[i]){sp_int idx=(sp_int)(sp_str_hash(ok[i])&h->mask);while(h->keys[idx])idx=(idx+1)&h->mask;h->keys[idx]=ok[i];h->vals[idx]=ov[i];h->len++;}}sp_pl_free(ok);sp_pl_free(ov);}
+sp_int sp_StrIntHash_get(sp_StrIntHash*h,const char*k){SP_GC_ROOT(h);SP_GC_ROOT_STR(k);if(!h)return 0;sp_int idx=(sp_int)(sp_str_hash(k)&h->mask);while(h->keys[idx]){if(sp_str_eq(h->keys[idx],k))return h->vals[idx];idx=(idx+1)&h->mask;}return h->default_v;}
+/* Issue #801: maybe-missing public `[]` read. Returns default_v on a miss,
+   which is SP_INT_NIL (Ruby nil at the value level) for a no-default hash and
+   the explicit default for Hash.new(N). Proven-present reads keep using _get. */
+sp_int sp_StrIntHash_get_opt(sp_StrIntHash*h,const char*k){SP_GC_ROOT(h);SP_GC_ROOT_STR(k);if(!h)return SP_INT_NIL;sp_int idx=(sp_int)(sp_str_hash(k)&h->mask);while(h->keys[idx]){if(sp_str_eq(h->keys[idx],k))return h->vals[idx];idx=(idx+1)&h->mask;}return h->default_v;}
+void sp_StrIntHash_set(sp_StrIntHash*h,const char*k,sp_int v){SP_GC_ROOT(h);SP_GC_ROOT_STR(k); if(!k){sp_raise_cls("TypeError","no implicit conversion of nil into String");return;} sp_gc_wb((void*)h);if(h->len*2>=h->cap)sp_StrIntHash_grow(h);sp_int idx=(sp_int)(sp_str_hash(k)&h->mask);while(h->keys[idx]){if(sp_str_eq(h->keys[idx],k)){h->vals[idx]=v;return;}idx=(idx+1)&h->mask;}k=sp_hash_key_str(k);sp_gc_wb((void*)h);h->keys[idx]=k;h->vals[idx]=v;h->order[h->len]=k;h->len++;}
+sp_bool sp_StrIntHash_has_key(sp_StrIntHash*h,const char*k){SP_GC_ROOT(h);SP_GC_ROOT_STR(k);sp_int idx=(sp_int)(sp_str_hash(k)&h->mask);while(h->keys[idx]){if(sp_str_eq(h->keys[idx],k))return TRUE;idx=(idx+1)&h->mask;}return FALSE;}
+/* h.fetch(k, d) in one probe: the value, or d when k is absent (the
+   hash's own default does not apply to fetch) */
+sp_int sp_StrIntHash_fetch_or(sp_StrIntHash*h,const char*k,sp_int d){SP_GC_ROOT(h);SP_GC_ROOT_STR(k);if(!h)return d;sp_int idx=(sp_int)(sp_str_hash(k)&h->mask);while(h->keys[idx]){if(sp_str_eq(h->keys[idx],k))return h->vals[idx];idx=(idx+1)&h->mask;}return d;}
+/* Hash#value? -- scan values in insertion order. Issue #738. */
+sp_bool sp_StrIntHash_has_value(sp_StrIntHash*h,sp_int v){if(!h)return FALSE;for(sp_int i=0;i<h->len;i++)if(sp_StrIntHash_get(h,h->order[i])==v)return TRUE;return FALSE;}
+sp_int sp_StrIntHash_length(sp_StrIntHash*h){return h->len;}
+void sp_StrIntHash_delete(sp_StrIntHash*h,const char*k){SP_GC_ROOT(h);SP_GC_ROOT_STR(k); sp_gc_wb((void*)h);sp_int idx=(sp_int)(sp_str_hash(k)&h->mask);while(h->keys[idx]){if(sp_str_eq(h->keys[idx],k)){h->keys[idx]=NULL;h->vals[idx]=0;h->len--;sp_int j=(idx+1)&h->mask;while(h->keys[j]){sp_int nj=(sp_int)(sp_str_hash(h->keys[j])&h->mask);if((j>idx&&(nj<=idx||nj>j))||(j<idx&&nj<=idx&&nj>j)){h->keys[idx]=h->keys[j];h->vals[idx]=h->vals[j];h->keys[j]=NULL;h->vals[j]=0;idx=j;}j=(j+1)&h->mask;}{sp_int oi=0;while(oi<=h->len){if(strcmp(h->order[oi],k)==0){while(oi<h->len){h->order[oi]=h->order[oi+1];oi++;}break;}oi++;}}return;}idx=(idx+1)&h->mask;}}
+sp_StrArray*sp_StrIntHash_keys(sp_StrIntHash*h){SP_GC_ROOT(h);sp_StrArray*a=sp_StrArray_new();SP_GC_ROOT(a);for(sp_int i=0;i<h->len;i++)sp_StrArray_push(a,h->order[i]);return a;}
+sp_IntArray*sp_StrIntHash_values(sp_StrIntHash*h){SP_GC_ROOT(h);sp_IntArray*a=sp_IntArray_new();SP_GC_ROOT(a);for(sp_int i=0;i<h->len;i++)sp_IntArray_push_nilable(a,sp_StrIntHash_get(h,h->order[i]));return a;}  /* a nil value is the sentinel */
+sp_StrIntHash*sp_StrIntHash_merge(sp_StrIntHash*a,sp_StrIntHash*b){SP_GC_ROOT(a);SP_GC_ROOT(b);sp_StrIntHash*r=sp_StrIntHash_new();r->default_v=a->default_v;for(sp_int i=0;i<a->len;i++)sp_StrIntHash_set(r,a->order[i],sp_StrIntHash_get(a,a->order[i]));for(sp_int i=0;i<b->len;i++)sp_StrIntHash_set(r,b->order[i],sp_StrIntHash_get(b,b->order[i]));return r;}
+void sp_StrIntHash_update(sp_StrIntHash*a,sp_StrIntHash*b){SP_GC_ROOT(a);SP_GC_ROOT(b);for(sp_int i=0;i<b->len;i++)sp_StrIntHash_set(a,b->order[i],sp_StrIntHash_get(b,b->order[i]));}
+sp_StrIntHash*sp_StrIntHash_dup(sp_StrIntHash*h){SP_GC_ROOT(h);sp_StrIntHash*r=sp_StrIntHash_new();r->default_v=h->default_v;for(sp_int i=0;i<h->len;i++)sp_StrIntHash_set(r,h->order[i],sp_StrIntHash_get(h,h->order[i]));return r;}
+sp_StrIntHash*sp_StrIntHash_replace(sp_StrIntHash*h,sp_StrIntHash*o){SP_GC_ROOT(h);SP_GC_ROOT(o); sp_gc_wb((void*)h);if(!h)return h;for(sp_int i=0;i<h->cap;i++)h->keys[i]=NULL;h->len=0;if(o)for(sp_int i=0;i<o->len;i++)sp_StrIntHash_set(h,o->order[i],sp_StrIntHash_get(o,o->order[i]));return h;}
+void sp_StrIntHash_clear(sp_StrIntHash*h){ sp_gc_wb((void*)h);if(!h)return;for(sp_int i=0;i<h->cap;i++)h->keys[i]=NULL;h->len=0;}
+sp_bool sp_StrIntHash_eq(sp_StrIntHash*a,sp_StrIntHash*b){SP_GC_ROOT(a);SP_GC_ROOT(b);if(!a||!b)return a==b;if(a->len!=b->len)return FALSE;for(sp_int i=0;i<a->len;i++){const char*k=a->order[i];if(!sp_StrIntHash_has_key(b,k))return FALSE;if(sp_StrIntHash_get(a,k)!=sp_StrIntHash_get(b,k))return FALSE;}return TRUE;}
+void sp_StrStrHash_fin(void*p){sp_StrStrHash*h=(sp_StrStrHash*)p;sp_pl_free(h->keys);sp_pl_free(h->vals);sp_pl_free(h->order);}
+void sp_StrStrHash_scan(void*p){sp_StrStrHash*h=(sp_StrStrHash*)p;for(sp_int i=0;i<h->cap;i++){if(h->keys[i]){sp_mark_string(h->keys[i]);sp_mark_string(h->vals[i]);}}if(h->default_v)sp_mark_string(h->default_v);}
+sp_StrStrHash*sp_StrStrHash_new(void){sp_StrStrHash*h=(sp_StrStrHash*)sp_gc_alloc(sizeof(sp_StrStrHash),sp_StrStrHash_fin,sp_StrStrHash_scan);h->cap=16;h->mask=15;h->keys=(const char**)sp_pl_zalloc((size_t)h->cap*sizeof(const char*));h->vals=(const char**)sp_pl_zalloc((size_t)h->cap*sizeof(const char*));h->order=(const char**)sp_pl_alloc(sizeof(const char*)*h->cap);h->len=0;h->default_v=NULL;return h;}
+sp_StrStrHash*sp_StrStrHash_new_with_default(const char*d){SP_GC_ROOT_STR(d);sp_StrStrHash*h=sp_StrStrHash_new();h->default_v=d;return h;}
+void sp_StrStrHash_grow(sp_StrStrHash*h){SP_GC_ROOT(h); sp_gc_wb((void*)h);sp_int oc=h->cap;const char**ok=h->keys;const char**ov=h->vals;h->cap*=2;h->mask=h->cap-1;h->keys=(const char**)sp_pl_zalloc((size_t)h->cap*sizeof(const char*));h->vals=(const char**)sp_pl_zalloc((size_t)h->cap*sizeof(const char*));h->order=(const char**)sp_pl_realloc(h->order,sizeof(const char*)*h->cap);h->len=0;for(sp_int i=0;i<oc;i++){if(ok[i]){sp_int idx=(sp_int)(sp_str_hash(ok[i])&h->mask);while(h->keys[idx])idx=(idx+1)&h->mask;h->keys[idx]=ok[i];h->vals[idx]=ov[i];h->len++;}}sp_pl_free(ok);sp_pl_free(ov);}
+const char*sp_StrStrHash_get(sp_StrStrHash*h,const char*k){SP_GC_ROOT(h);SP_GC_ROOT_STR(k);if(!h)return NULL;sp_int idx=(sp_int)(sp_str_hash(k)&h->mask);while(h->keys[idx]){if(sp_str_eq(h->keys[idx],k))return h->vals[idx];idx=(idx+1)&h->mask;}return h->default_v;}
+void sp_StrStrHash_set(sp_StrStrHash*h,const char*k,const char*v){SP_GC_ROOT(h);SP_GC_ROOT_STR(k);SP_GC_ROOT_STR(v); if(!k){sp_raise_cls("TypeError","no implicit conversion of nil into String");return;} sp_gc_wb((void*)h);if(h->len*2>=h->cap)sp_StrStrHash_grow(h);sp_int idx=(sp_int)(sp_str_hash(k)&h->mask);while(h->keys[idx]){if(sp_str_eq(h->keys[idx],k)){h->vals[idx]=v;return;}idx=(idx+1)&h->mask;}k=sp_hash_key_str(k);sp_gc_wb((void*)h);h->keys[idx]=k;h->vals[idx]=v;h->order[h->len]=k;h->len++;}
+sp_bool sp_StrStrHash_has_key(sp_StrStrHash*h,const char*k){SP_GC_ROOT(h);SP_GC_ROOT_STR(k);sp_int idx=(sp_int)(sp_str_hash(k)&h->mask);while(h->keys[idx]){if(sp_str_eq(h->keys[idx],k))return TRUE;idx=(idx+1)&h->mask;}return FALSE;}
+sp_bool sp_StrStrHash_has_value(sp_StrStrHash*h,const char*v){if(!h||!v)return FALSE;for(sp_int i=0;i<h->len;i++){const char*x=sp_StrStrHash_get(h,h->order[i]);if(x&&strcmp(x,v)==0)return TRUE;}return FALSE;}
+sp_int sp_StrStrHash_length(sp_StrStrHash*h){return h->len;}
+void sp_StrStrHash_delete(sp_StrStrHash*h,const char*k){SP_GC_ROOT(h);SP_GC_ROOT_STR(k); sp_gc_wb((void*)h);sp_int idx=(sp_int)(sp_str_hash(k)&h->mask);while(h->keys[idx]){if(sp_str_eq(h->keys[idx],k)){h->keys[idx]=NULL;h->vals[idx]=NULL;h->len--;sp_int j=(idx+1)&h->mask;while(h->keys[j]){sp_int nj=(sp_int)(sp_str_hash(h->keys[j])&h->mask);if((j>idx&&(nj<=idx||nj>j))||(j<idx&&nj<=idx&&nj>j)){h->keys[idx]=h->keys[j];h->vals[idx]=h->vals[j];h->keys[j]=NULL;h->vals[j]=NULL;idx=j;}j=(j+1)&h->mask;}{sp_int oi=0;while(oi<=h->len){if(strcmp(h->order[oi],k)==0){while(oi<h->len){h->order[oi]=h->order[oi+1];oi++;}break;}oi++;}}return;}idx=(idx+1)&h->mask;}}
+sp_StrArray*sp_StrStrHash_keys(sp_StrStrHash*h){SP_GC_ROOT(h);sp_StrArray*a=sp_StrArray_new();SP_GC_ROOT(a);for(sp_int i=0;i<h->len;i++)sp_StrArray_push(a,h->order[i]);return a;}
+sp_StrArray*sp_StrStrHash_values(sp_StrStrHash*h){SP_GC_ROOT(h);sp_StrArray*a=sp_StrArray_new();SP_GC_ROOT(a);for(sp_int i=0;i<h->len;i++)sp_StrArray_push(a,sp_StrStrHash_get(h,h->order[i]));return a;}
+sp_StrStrHash*sp_StrStrHash_invert(sp_StrStrHash*h){SP_GC_ROOT(h);sp_StrStrHash*r=sp_StrStrHash_new();for(sp_int i=0;i<h->len;i++){const char*k=h->order[i];sp_StrStrHash_set(r,sp_StrStrHash_get(h,k),k);}return r;}
+void sp_StrStrHash_update(sp_StrStrHash*a,sp_StrStrHash*b){SP_GC_ROOT(a);SP_GC_ROOT(b);for(sp_int i=0;i<b->len;i++)sp_StrStrHash_set(a,b->order[i],sp_StrStrHash_get(b,b->order[i]));}
+sp_StrStrHash*sp_StrStrHash_dup(sp_StrStrHash*h){SP_GC_ROOT(h);sp_StrStrHash*r=sp_StrStrHash_new();r->default_v=h->default_v;for(sp_int i=0;i<h->len;i++)sp_StrStrHash_set(r,h->order[i],sp_StrStrHash_get(h,h->order[i]));return r;}
+sp_StrStrHash*sp_StrStrHash_merge(sp_StrStrHash*a,sp_StrStrHash*b){SP_GC_ROOT(a);SP_GC_ROOT(b);sp_StrStrHash*r=sp_StrStrHash_new();if(a){r->default_v=a->default_v;for(sp_int i=0;i<a->len;i++)sp_StrStrHash_set(r,a->order[i],sp_StrStrHash_get(a,a->order[i]));}if(b){for(sp_int i=0;i<b->len;i++)sp_StrStrHash_set(r,b->order[i],sp_StrStrHash_get(b,b->order[i]));}return r;}
+sp_StrStrHash*sp_StrStrHash_replace(sp_StrStrHash*h,sp_StrStrHash*o){SP_GC_ROOT(h);SP_GC_ROOT(o); sp_gc_wb((void*)h);if(!h)return h;for(sp_int i=0;i<h->cap;i++)h->keys[i]=NULL;h->len=0;if(o)for(sp_int i=0;i<o->len;i++)sp_StrStrHash_set(h,o->order[i],sp_StrStrHash_get(o,o->order[i]));return h;}
+void sp_StrStrHash_clear(sp_StrStrHash*h){ sp_gc_wb((void*)h);if(!h)return;for(sp_int i=0;i<h->cap;i++)h->keys[i]=NULL;h->len=0;}
+sp_bool sp_StrStrHash_eq(sp_StrStrHash*a,sp_StrStrHash*b){SP_GC_ROOT(a);SP_GC_ROOT(b);if(!a||!b)return a==b;if(a->len!=b->len)return FALSE;for(sp_int i=0;i<a->len;i++){const char*k=a->order[i];if(!sp_StrStrHash_has_key(b,k))return FALSE;if(!sp_str_eq(sp_StrStrHash_get(a,k),sp_StrStrHash_get(b,k)))return FALSE;}return TRUE;}
+void sp_IntStrHash_fin(void*p){sp_IntStrHash*h=(sp_IntStrHash*)p;sp_pl_free(h->keys);sp_pl_free(h->vals);sp_pl_free(h->order);sp_pl_free(h->used);}
+void sp_IntStrHash_scan(void*p){sp_IntStrHash*h=(sp_IntStrHash*)p;for(sp_int i=0;i<h->cap;i++)if(h->used[i])sp_mark_string(h->vals[i]);if(h->default_v)sp_mark_string(h->default_v);}
+sp_IntStrHash*sp_IntStrHash_new(void){sp_IntStrHash*h=(sp_IntStrHash*)sp_gc_alloc(sizeof(sp_IntStrHash),sp_IntStrHash_fin,sp_IntStrHash_scan);h->cap=16;h->mask=15;h->keys=(sp_int*)sp_pl_zalloc((size_t)h->cap*sizeof(sp_int));h->vals=(const char**)sp_pl_zalloc((size_t)h->cap*sizeof(const char*));h->order=(sp_int*)sp_pl_alloc(sizeof(sp_int)*(size_t)h->cap);h->used=(sp_bool*)sp_pl_zalloc((size_t)h->cap*sizeof(sp_bool));h->len=0;h->default_v=NULL;return h;}
+sp_IntStrHash*sp_IntStrHash_new_with_default(const char*d){SP_GC_ROOT_STR(d);sp_IntStrHash*h=sp_IntStrHash_new();h->default_v=d;return h;}
+void sp_IntStrHash_grow(sp_IntStrHash*h){ sp_gc_wb((void*)h);sp_int oc=h->cap,ol=h->len;sp_int*ok=h->keys;const char**ov=h->vals;sp_bool*ou=h->used;sp_int*oo=h->order;h->cap*=2;h->mask=h->cap-1;h->keys=(sp_int*)sp_pl_zalloc((size_t)h->cap*sizeof(sp_int));h->vals=(const char**)sp_pl_zalloc((size_t)h->cap*sizeof(const char*));h->order=(sp_int*)sp_pl_alloc(sizeof(sp_int)*(size_t)h->cap);h->used=(sp_bool*)sp_pl_zalloc((size_t)h->cap*sizeof(sp_bool));h->len=ol;for(sp_int i=0;i<oc;i++){if(!ou[i])continue;sp_int k=ok[i];const char*v=ov[i];sp_int di=_sp_istr_idx(h->mask,k);while(h->used[di])di=(di+1)&h->mask;h->used[di]=TRUE;h->keys[di]=k;h->vals[di]=v;}for(sp_int i=0;i<ol;i++)h->order[i]=oo[i];sp_pl_free(ok);sp_pl_free(ov);sp_pl_free(ou);sp_pl_free(oo);}
+void sp_IntStrHash_set(sp_IntStrHash*h,sp_int k,const char*v){SP_GC_ROOT(h);SP_GC_ROOT_STR(v); sp_gc_wb((void*)h);if(h->len*2>=h->cap)sp_IntStrHash_grow(h);sp_int idx=_sp_istr_idx(h->mask,k);while(h->used[idx]){if(h->keys[idx]==k){h->vals[idx]=v;return;}idx=(idx+1)&h->mask;}h->used[idx]=TRUE;h->keys[idx]=k;h->vals[idx]=v;h->order[h->len++]=k;}
+const char*sp_IntStrHash_get(sp_IntStrHash*h,sp_int k){if(!h)return NULL;sp_int idx=_sp_istr_idx(h->mask,k);while(h->used[idx]){if(h->keys[idx]==k)return h->vals[idx];idx=(idx+1)&h->mask;}return h->default_v;}
+sp_IntStrHash*sp_IntStrHash_merge(sp_IntStrHash*a,sp_IntStrHash*b){SP_GC_ROOT(a);SP_GC_ROOT(b);sp_IntStrHash*r=sp_IntStrHash_new();if(a){r->default_v=a->default_v;for(sp_int i=0;i<a->len;i++)sp_IntStrHash_set(r,a->order[i],sp_IntStrHash_get(a,a->order[i]));}if(b){for(sp_int i=0;i<b->len;i++)sp_IntStrHash_set(r,b->order[i],sp_IntStrHash_get(b,b->order[i]));}return r;}
+void sp_IntStrHash_update(sp_IntStrHash*a,sp_IntStrHash*b){if(!a||!b||a==b)return;SP_GC_ROOT(a);SP_GC_ROOT(b);for(sp_int i=0;i<b->len;i++)sp_IntStrHash_set(a,b->order[i],sp_IntStrHash_get(b,b->order[i]));}
+sp_bool sp_IntStrHash_has_key(sp_IntStrHash*h,sp_int k){sp_int idx=_sp_istr_idx(h->mask,k);while(h->used[idx]){if(h->keys[idx]==k)return TRUE;idx=(idx+1)&h->mask;}return FALSE;}
+sp_bool sp_IntStrHash_has_value(sp_IntStrHash*h,const char*v){if(!h||!v)return FALSE;for(sp_int i=0;i<h->len;i++){const char*x=sp_IntStrHash_get(h,h->order[i]);if(x&&strcmp(x,v)==0)return TRUE;}return FALSE;}
+sp_int sp_IntStrHash_length(sp_IntStrHash*h){return h->len;}
+sp_IntArray*sp_IntStrHash_keys(sp_IntStrHash*h){SP_GC_ROOT(h);sp_IntArray*a=sp_IntArray_new();SP_GC_ROOT(a);for(sp_int i=0;i<h->len;i++)sp_IntArray_push_nilable(a,h->order[i]);return a;}  /* so is a nil key */
+sp_StrArray*sp_IntStrHash_values(sp_IntStrHash*h){SP_GC_ROOT(h);sp_StrArray*a=sp_StrArray_new();SP_GC_ROOT(a);for(sp_int i=0;i<h->len;i++)sp_StrArray_push(a,sp_IntStrHash_get(h,h->order[i]));return a;}
+sp_IntStrHash*sp_IntStrHash_dup(sp_IntStrHash*h){SP_GC_ROOT(h);sp_IntStrHash*r=sp_IntStrHash_new();r->default_v=h->default_v;for(sp_int i=0;i<h->len;i++)sp_IntStrHash_set(r,h->order[i],sp_IntStrHash_get(h,h->order[i]));return r;}
+sp_IntStrHash*sp_IntStrHash_replace(sp_IntStrHash*h,sp_IntStrHash*o){SP_GC_ROOT(h);SP_GC_ROOT(o);if(!h)return h;for(sp_int i=0;i<h->cap;i++)h->used[i]=0;h->len=0;if(o)for(sp_int i=0;i<o->len;i++)sp_IntStrHash_set(h,o->order[i],sp_IntStrHash_get(o,o->order[i]));return h;}
+sp_bool sp_IntStrHash_eq(sp_IntStrHash*a,sp_IntStrHash*b){SP_GC_ROOT(a);SP_GC_ROOT(b);if(!a||!b)return a==b;if(a->len!=b->len)return FALSE;for(sp_int i=0;i<a->len;i++){sp_int k=a->order[i];if(!sp_IntStrHash_has_key(b,k))return FALSE;if(!sp_str_eq(sp_IntStrHash_get(a,k),sp_IntStrHash_get(b,k)))return FALSE;}return TRUE;}
+/* Int → Int typed hash. Mirrors sp_IntStrHash's open-addressing
+   layout (used[] bitmap so 0/-1 keys are distinguishable from
+   empty), with int-valued slots (#865). */
+void sp_IntIntHash_fin(void*p){sp_IntIntHash*h=(sp_IntIntHash*)p;sp_pl_free(h->keys);sp_pl_free(h->vals);sp_pl_free(h->order);sp_pl_free(h->used);}
+/* default_v is SP_INT_NIL for a hash with no explicit default, so a
+   missing-key `[]` read surfaces Ruby nil (#801). Hash.new(N) sets it via
+   _new_with_default. */
+sp_IntIntHash*sp_IntIntHash_new(void){sp_IntIntHash*h=(sp_IntIntHash*)sp_gc_alloc(sizeof(sp_IntIntHash),sp_IntIntHash_fin,NULL);h->cap=16;h->mask=15;h->keys=(sp_int*)sp_pl_zalloc((size_t)h->cap*sizeof(sp_int));h->vals=(sp_int*)sp_pl_zalloc((size_t)h->cap*sizeof(sp_int));h->order=(sp_int*)sp_pl_alloc(sizeof(sp_int)*(size_t)h->cap);h->used=(sp_bool*)sp_pl_zalloc((size_t)h->cap*sizeof(sp_bool));h->len=0;h->default_v=SP_INT_NIL;return h;}
+sp_IntIntHash*sp_IntIntHash_new_with_default(sp_int d){sp_IntIntHash*h=sp_IntIntHash_new();h->default_v=d;return h;}
+void sp_IntIntHash_grow(sp_IntIntHash*h){sp_int oc=h->cap,ol=h->len;sp_int*ok=h->keys;sp_int*ov=h->vals;sp_bool*ou=h->used;sp_int*oo=h->order;h->cap*=2;h->mask=h->cap-1;h->keys=(sp_int*)sp_pl_zalloc((size_t)h->cap*sizeof(sp_int));h->vals=(sp_int*)sp_pl_zalloc((size_t)h->cap*sizeof(sp_int));h->order=(sp_int*)sp_pl_alloc(sizeof(sp_int)*(size_t)h->cap);h->used=(sp_bool*)sp_pl_zalloc((size_t)h->cap*sizeof(sp_bool));h->len=ol;for(sp_int i=0;i<oc;i++){if(!ou[i])continue;sp_int k=ok[i];sp_int v=ov[i];sp_int di=_sp_istr_idx(h->mask,k);while(h->used[di])di=(di+1)&h->mask;h->used[di]=TRUE;h->keys[di]=k;h->vals[di]=v;}for(sp_int i=0;i<ol;i++)h->order[i]=oo[i];sp_pl_free(ok);sp_pl_free(ov);sp_pl_free(ou);sp_pl_free(oo);}
+void sp_IntIntHash_set(sp_IntIntHash*h,sp_int k,sp_int v){SP_GC_ROOT(h);if(h->len*2>=h->cap)sp_IntIntHash_grow(h);sp_int idx=_sp_istr_idx(h->mask,k);while(h->used[idx]){if(h->keys[idx]==k){h->vals[idx]=v;return;}idx=(idx+1)&h->mask;}h->used[idx]=TRUE;h->keys[idx]=k;h->vals[idx]=v;h->order[h->len++]=k;}
+sp_int sp_IntIntHash_get(sp_IntIntHash*h,sp_int k){if(!h)return 0;sp_int idx=_sp_istr_idx(h->mask,k);while(h->used[idx]){if(h->keys[idx]==k)return h->vals[idx];idx=(idx+1)&h->mask;}return h->default_v;}
+sp_IntIntHash*sp_IntIntHash_merge(sp_IntIntHash*a,sp_IntIntHash*b){SP_GC_ROOT(a);SP_GC_ROOT(b);sp_IntIntHash*r=sp_IntIntHash_new();if(a){r->default_v=a->default_v;for(sp_int i=0;i<a->len;i++)sp_IntIntHash_set(r,a->order[i],sp_IntIntHash_get(a,a->order[i]));}if(b){for(sp_int i=0;i<b->len;i++)sp_IntIntHash_set(r,b->order[i],sp_IntIntHash_get(b,b->order[i]));}return r;}
+void sp_IntIntHash_update(sp_IntIntHash*a,sp_IntIntHash*b){if(!a||!b||a==b)return;SP_GC_ROOT(a);SP_GC_ROOT(b);for(sp_int i=0;i<b->len;i++)sp_IntIntHash_set(a,b->order[i],sp_IntIntHash_get(b,b->order[i]));}
+/* Integer-keyed hash delete: backward-shift the probe cluster so open-addressing
+   lookups stay correct, then drop the key from the insertion-order array. */
+void sp_IntIntHash_delete(sp_IntIntHash*h,sp_int k){if(!h)return;sp_int idx=_sp_istr_idx(h->mask,k);while(h->used[idx]){if(h->keys[idx]==k){h->used[idx]=0;h->len--;sp_int j=(idx+1)&h->mask;while(h->used[j]){sp_int nj=_sp_istr_idx(h->mask,h->keys[j]);if((j>idx&&(nj<=idx||nj>j))||(j<idx&&nj<=idx&&nj>j)){h->keys[idx]=h->keys[j];h->vals[idx]=h->vals[j];h->used[idx]=1;h->used[j]=0;idx=j;}j=(j+1)&h->mask;}{sp_int oi=0;while(oi<=h->len){if(h->order[oi]==k){while(oi<h->len){h->order[oi]=h->order[oi+1];oi++;}break;}oi++;}}return;}idx=(idx+1)&h->mask;}}
+void sp_IntStrHash_delete(sp_IntStrHash*h,sp_int k){ sp_gc_wb((void*)h);if(!h)return;sp_int idx=_sp_istr_idx(h->mask,k);while(h->used[idx]){if(h->keys[idx]==k){h->used[idx]=0;h->len--;sp_int j=(idx+1)&h->mask;while(h->used[j]){sp_int nj=_sp_istr_idx(h->mask,h->keys[j]);if((j>idx&&(nj<=idx||nj>j))||(j<idx&&nj<=idx&&nj>j)){h->keys[idx]=h->keys[j];h->vals[idx]=h->vals[j];h->used[idx]=1;h->used[j]=0;idx=j;}j=(j+1)&h->mask;}{sp_int oi=0;while(oi<=h->len){if(h->order[oi]==k){while(oi<h->len){h->order[oi]=h->order[oi+1];oi++;}break;}oi++;}}return;}idx=(idx+1)&h->mask;}}
+/* Issue #801: maybe-missing public `[]` read. Returns default_v on a miss
+   (SP_INT_NIL for a no-default hash = Ruby nil; the explicit default for
+   Hash.new(N)). Proven-present reads keep using _get. */
+sp_int sp_IntIntHash_get_opt(sp_IntIntHash*h,sp_int k){if(!h)return SP_INT_NIL;sp_int idx=_sp_istr_idx(h->mask,k);while(h->used[idx]){if(h->keys[idx]==k)return h->vals[idx];idx=(idx+1)&h->mask;}return h->default_v;}
+sp_bool sp_IntIntHash_has_key(sp_IntIntHash*h,sp_int k){sp_int idx=_sp_istr_idx(h->mask,k);while(h->used[idx]){if(h->keys[idx]==k)return TRUE;idx=(idx+1)&h->mask;}return FALSE;}
+sp_int sp_IntIntHash_fetch_or(sp_IntIntHash*h,sp_int k,sp_int d){if(!h)return d;sp_int idx=_sp_istr_idx(h->mask,k);while(h->used[idx]){if(h->keys[idx]==k)return h->vals[idx];idx=(idx+1)&h->mask;}return d;}
+sp_int sp_IntIntHash_length(sp_IntIntHash*h){return h?h->len:0;}
+sp_IntArray*sp_IntIntHash_keys(sp_IntIntHash*h){SP_GC_ROOT(h);sp_IntArray*a=sp_IntArray_new();SP_GC_ROOT(a);if(h)for(sp_int i=0;i<h->len;i++)sp_IntArray_push_nilable(a,h->order[i]);return a;}
+sp_IntArray*sp_IntIntHash_values(sp_IntIntHash*h){SP_GC_ROOT(h);sp_IntArray*a=sp_IntArray_new();SP_GC_ROOT(a);if(h)for(sp_int i=0;i<h->len;i++)sp_IntArray_push_nilable(a,sp_IntIntHash_get(h,h->order[i]));return a;}
+sp_bool sp_IntIntHash_has_value(sp_IntIntHash*h,sp_int v){if(!h)return FALSE;for(sp_int i=0;i<h->len;i++)if(sp_IntIntHash_get(h,h->order[i])==v)return TRUE;return FALSE;}
+sp_bool sp_IntIntHash_eq(sp_IntIntHash*a,sp_IntIntHash*b){SP_GC_ROOT(a);SP_GC_ROOT(b);if(!a||!b)return a==b;if(a->len!=b->len)return FALSE;for(sp_int i=0;i<a->len;i++){sp_int k=a->order[i];if(!sp_IntIntHash_has_key(b,k))return FALSE;if(sp_IntIntHash_get(a,k)!=sp_IntIntHash_get(b,k))return FALSE;}return TRUE;}
+sp_IntIntHash*sp_IntIntHash_dup(sp_IntIntHash*h){SP_GC_ROOT(h);sp_IntIntHash*r=sp_IntIntHash_new();r->default_v=h->default_v;for(sp_int i=0;i<h->len;i++)sp_IntIntHash_set(r,h->order[i],sp_IntIntHash_get(h,h->order[i]));return r;}
+sp_IntIntHash*sp_IntIntHash_replace(sp_IntIntHash*h,sp_IntIntHash*o){SP_GC_ROOT(h);SP_GC_ROOT(o);if(!h)return h;for(sp_int i=0;i<h->cap;i++)h->used[i]=0;h->len=0;if(o)for(sp_int i=0;i<o->len;i++)sp_IntIntHash_set(h,o->order[i],sp_IntIntHash_get(o,o->order[i]));return h;}
+void sp_IntIntHash_clear(sp_IntIntHash*h){if(!h)return;for(sp_int i=0;i<h->cap;i++)h->used[i]=0;h->len=0;}
+/* Issue #851: Hash#inspect for typed-hash variants beyond
+   sym_int_hash. Renders Ruby's `{"k" => v, ...}` (string keys),
+   `{42 => "v", ...}` (int keys), or `{:k => v, ...}` (sym keys but
+   non-int value, since the bare `k: v` shorthand only applies
+   when values are inspectable as one-liners -- match CRuby). */
+const char*sp_StrIntHash_inspect(sp_StrIntHash*h){SP_GC_ROOT(h);return h?sp_inspect_container(sp_box_obj(h,SP_BUILTIN_STR_INT_HASH)):SPL("nil");}
+/* Hash#to_proc lookup fn -- cap is the hash, args[0] the string key. */
+sp_int sp_StrIntHash_proc_fn(void *cap, sp_int argc, sp_int *args) { if (argc < 1) return 0; return sp_StrIntHash_get((sp_StrIntHash *)cap, (const char *)(uintptr_t)args[0]); }
+const char*sp_StrStrHash_inspect(sp_StrStrHash*h){SP_GC_ROOT(h);return h?sp_inspect_container(sp_box_obj(h,SP_BUILTIN_STR_STR_HASH)):SPL("nil");}
+const char*sp_IntStrHash_inspect(sp_IntStrHash*h){SP_GC_ROOT(h);return h?sp_inspect_container(sp_box_obj(h,SP_BUILTIN_INT_STR_HASH)):SPL("nil");}
+/* A key or a value can be the nil sentinel: a nullable Integer stored there
+   (`{i => 1}` for an `i` that missed its array, or `h[k] = i`) keeps the int
+   variant, and the slot holds nil as SP_INT_NIL. It renders as the nil it
+   stands for, as sp_poly_inspect renders a boxed one and the other typed
+   variants' walk (sp_inspect_container) already does. */
+static const char*sp_int_inspect_or_nil(sp_int v){return v==SP_INT_NIL?SPL("nil"):sp_int_to_s(v);}
+const char*sp_IntIntHash_inspect(sp_IntIntHash*h){SP_GC_ROOT(h);if(!h)return SPL("nil");sp_String*s=sp_String_new("{");SP_GC_ROOT(s);if(h){for(sp_int i=0;i<h->len;i++){if(i>0)sp_String_append(s,", ");sp_String_append(s,sp_int_inspect_or_nil(h->order[i]));sp_String_append(s," => ");sp_String_append(s,sp_int_inspect_or_nil(sp_IntIntHash_get(h,h->order[i])));}}sp_String_append(s,"}");return sp_str_dup(s->data);}
+
+/* Issue #738: Hash#to_a as poly_array of [key, value] poly_array pairs. */
+sp_PolyArray*sp_StrIntHash_to_a(sp_StrIntHash*h){SP_GC_ROOT(h);sp_PolyArray*r=sp_PolyArray_new();if(!h)return r;for(sp_int i=0;i<h->len;i++){sp_PolyArray*p=sp_PolyArray_new();sp_PolyArray_push(p,sp_box_str(h->order[i]));sp_PolyArray_push(p,sp_box_int(sp_StrIntHash_get(h,h->order[i])));sp_PolyArray_push(r,sp_box_poly_array(p));}return r;}
+sp_PolyArray*sp_StrStrHash_to_a(sp_StrStrHash*h){SP_GC_ROOT(h);sp_PolyArray*r=sp_PolyArray_new();if(!h)return r;for(sp_int i=0;i<h->len;i++){sp_PolyArray*p=sp_PolyArray_new();sp_PolyArray_push(p,sp_box_str(h->order[i]));sp_PolyArray_push(p,sp_box_str(sp_StrStrHash_get(h,h->order[i])));sp_PolyArray_push(r,sp_box_poly_array(p));}return r;}
+sp_PolyArray*sp_IntStrHash_to_a(sp_IntStrHash*h){SP_GC_ROOT(h);sp_PolyArray*r=sp_PolyArray_new();if(!h)return r;for(sp_int i=0;i<h->len;i++){sp_PolyArray*p=sp_PolyArray_new();sp_PolyArray_push(p,sp_box_int(h->order[i]));sp_PolyArray_push(p,sp_box_str(sp_IntStrHash_get(h,h->order[i])));sp_PolyArray_push(r,sp_box_poly_array(p));}return r;}
+
+void sp_IntStrHash_clear(sp_IntStrHash*h){if(!h)return;for(sp_int i=0;i<h->cap;i++)h->used[i]=0;h->len=0;}

data/ext/qr_reader_native/sp_hash.h

@@ -0,0 +1,131 @@
+#ifndef SP_HASH_H
+#define SP_HASH_H
+/* sp_hash.h -- cold CRUD-op surface for the 4 non-poly-valued typed hashes
+ * (sp_StrIntHash / sp_StrStrHash / sp_IntStrHash / sp_IntIntHash).
+ *
+ * The struct layouts already live in sp_types.h (shared). None of these
+ * four hash types appear in optcarrot's hot loop (0 uses for 3 of them,
+ * 4 non-hot uses for IntStrHash -- unlike SymPolyHash/PolyPolyHash, which
+ * stay in spinel_rt.h because optcarrot calls their accessors hundreds of
+ * times per frame), so the full CRUD surface -- not just the cold
+ * materializers -- compiles once into libspinel_rt.a (lib/sp_hash.c)
+ * instead of into every generated TU.
+ *
+ * inspect/to_a/invert functions that bridge to a poly-valued hash
+ * (sp_StrPolyHash/sp_PolyPolyHash) or sp_PolyArray stay in spinel_rt.h --
+ * moving those would require exposing the poly cluster across the archive
+ * boundary, which is excluded (de-inlining poly accessors regresses
+ * optcarrot fps ~15%, per project_sp_runtime_lib_eviction).
+ */
+#include "sp_types.h"   /* sp_StrIntHash / sp_StrStrHash / sp_IntStrHash / sp_IntIntHash */
+#include "sp_gc.h"      /* sp_gc_alloc, SP_GC_ROOT, sp_mark_string */
+#include "sp_array.h"   /* sp_StrArray / sp_IntArray new/push (keys/values) */
+#include "sp_str.h"     /* sp_str_hash / sp_str_eq / _sp_istr_idx */
+#include "sp_inspect.h" /* sp_inspect_container for the #inspect wrappers */
+#include "sp_string.h"  /* sp_String builder for sp_IntIntHash_inspect */
+#include "sp_re.h"      /* mrb_regexp_pattern for sp_re_gsub_str_str_hash/sub_str_str_hash */
+
+void sp_StrIntHash_fin(void*p);
+void sp_StrIntHash_scan(void*p);
+sp_StrIntHash*sp_StrIntHash_new(void);
+sp_StrIntHash*sp_StrIntHash_new_with_default(sp_int d);
+void sp_StrIntHash_grow(sp_StrIntHash*h);
+sp_int sp_StrIntHash_get(sp_StrIntHash*h,const char*k);
+sp_int sp_StrIntHash_get_opt(sp_StrIntHash*h,const char*k);
+sp_int sp_StrIntHash_fetch_or(sp_StrIntHash*h,const char*k,sp_int d);
+void sp_StrIntHash_set(sp_StrIntHash*h,const char*k,sp_int v);
+sp_bool sp_StrIntHash_has_key(sp_StrIntHash*h,const char*k);
+sp_bool sp_StrIntHash_has_value(sp_StrIntHash*h,sp_int v);
+sp_int sp_StrIntHash_length(sp_StrIntHash*h);
+void sp_StrIntHash_delete(sp_StrIntHash*h,const char*k);
+sp_StrArray*sp_StrIntHash_keys(sp_StrIntHash*h);
+sp_IntArray*sp_StrIntHash_values(sp_StrIntHash*h);
+sp_StrIntHash*sp_StrIntHash_merge(sp_StrIntHash*a,sp_StrIntHash*b);
+void sp_StrIntHash_update(sp_StrIntHash*a,sp_StrIntHash*b);
+sp_StrIntHash*sp_StrIntHash_dup(sp_StrIntHash*h);
+sp_StrIntHash*sp_StrIntHash_replace(sp_StrIntHash*h,sp_StrIntHash*o);
+void sp_StrIntHash_clear(sp_StrIntHash*h);
+sp_bool sp_StrIntHash_eq(sp_StrIntHash*a,sp_StrIntHash*b);
+void sp_StrStrHash_fin(void*p);
+void sp_StrStrHash_scan(void*p);
+sp_StrStrHash*sp_StrStrHash_new(void);
+sp_StrStrHash*sp_StrStrHash_new_with_default(const char*d);
+void sp_StrStrHash_grow(sp_StrStrHash*h);
+const char*sp_StrStrHash_get(sp_StrStrHash*h,const char*k);
+void sp_StrStrHash_set(sp_StrStrHash*h,const char*k,const char*v);
+sp_bool sp_StrStrHash_has_key(sp_StrStrHash*h,const char*k);
+sp_bool sp_StrStrHash_has_value(sp_StrStrHash*h,const char*v);
+sp_int sp_StrStrHash_length(sp_StrStrHash*h);
+void sp_StrStrHash_delete(sp_StrStrHash*h,const char*k);
+sp_StrArray*sp_StrStrHash_keys(sp_StrStrHash*h);
+sp_StrArray*sp_StrStrHash_values(sp_StrStrHash*h);
+sp_StrStrHash*sp_StrStrHash_invert(sp_StrStrHash*h);
+void sp_StrStrHash_update(sp_StrStrHash*a,sp_StrStrHash*b);
+sp_StrStrHash*sp_StrStrHash_dup(sp_StrStrHash*h);
+sp_StrStrHash*sp_StrStrHash_merge(sp_StrStrHash*a,sp_StrStrHash*b);
+sp_StrStrHash*sp_StrStrHash_replace(sp_StrStrHash*h,sp_StrStrHash*o);
+void sp_StrStrHash_clear(sp_StrStrHash*h);
+sp_bool sp_StrStrHash_eq(sp_StrStrHash*a,sp_StrStrHash*b);
+void sp_IntStrHash_fin(void*p);
+void sp_IntStrHash_scan(void*p);
+sp_IntStrHash*sp_IntStrHash_new(void);
+sp_IntStrHash*sp_IntStrHash_new_with_default(const char*d);
+void sp_IntStrHash_grow(sp_IntStrHash*h);
+void sp_IntStrHash_set(sp_IntStrHash*h,sp_int k,const char*v);
+const char*sp_IntStrHash_get(sp_IntStrHash*h,sp_int k);
+sp_IntStrHash*sp_IntStrHash_merge(sp_IntStrHash*a,sp_IntStrHash*b);
+void sp_IntStrHash_update(sp_IntStrHash*a,sp_IntStrHash*b);
+sp_bool sp_IntStrHash_has_key(sp_IntStrHash*h,sp_int k);
+sp_bool sp_IntStrHash_has_value(sp_IntStrHash*h,const char*v);
+sp_int sp_IntStrHash_length(sp_IntStrHash*h);
+sp_IntArray*sp_IntStrHash_keys(sp_IntStrHash*h);
+sp_StrArray*sp_IntStrHash_values(sp_IntStrHash*h);
+sp_IntStrHash*sp_IntStrHash_dup(sp_IntStrHash*h);
+sp_IntStrHash*sp_IntStrHash_replace(sp_IntStrHash*h,sp_IntStrHash*o);
+sp_bool sp_IntStrHash_eq(sp_IntStrHash*a,sp_IntStrHash*b);
+void sp_IntIntHash_fin(void*p);
+sp_IntIntHash*sp_IntIntHash_new(void);
+sp_IntIntHash*sp_IntIntHash_new_with_default(sp_int d);
+void sp_IntIntHash_grow(sp_IntIntHash*h);
+void sp_IntIntHash_set(sp_IntIntHash*h,sp_int k,sp_int v);
+sp_int sp_IntIntHash_get(sp_IntIntHash*h,sp_int k);
+sp_IntIntHash*sp_IntIntHash_merge(sp_IntIntHash*a,sp_IntIntHash*b);
+void sp_IntIntHash_update(sp_IntIntHash*a,sp_IntIntHash*b);
+void sp_IntIntHash_delete(sp_IntIntHash*h,sp_int k);
+void sp_IntStrHash_delete(sp_IntStrHash*h,sp_int k);
+sp_int sp_IntIntHash_get_opt(sp_IntIntHash*h,sp_int k);
+sp_int sp_IntIntHash_fetch_or(sp_IntIntHash*h,sp_int k,sp_int d);
+sp_bool sp_IntIntHash_has_key(sp_IntIntHash*h,sp_int k);
+sp_int sp_IntIntHash_length(sp_IntIntHash*h);
+sp_IntArray*sp_IntIntHash_keys(sp_IntIntHash*h);
+sp_IntArray*sp_IntIntHash_values(sp_IntIntHash*h);
+sp_bool sp_IntIntHash_has_value(sp_IntIntHash*h,sp_int v);
+sp_bool sp_IntIntHash_eq(sp_IntIntHash*a,sp_IntIntHash*b);
+sp_IntIntHash*sp_IntIntHash_dup(sp_IntIntHash*h);
+sp_IntIntHash*sp_IntIntHash_replace(sp_IntIntHash*h,sp_IntIntHash*o);
+void sp_IntIntHash_clear(sp_IntIntHash*h);
+const char*sp_StrIntHash_inspect(sp_StrIntHash*h);
+sp_int sp_StrIntHash_proc_fn(void *cap, sp_int argc, sp_int *args);
+const char*sp_StrStrHash_inspect(sp_StrStrHash*h);
+const char*sp_IntStrHash_inspect(sp_IntStrHash*h);
+const char*sp_IntIntHash_inspect(sp_IntIntHash*h);
+
+sp_PolyArray*sp_StrIntHash_to_a(sp_StrIntHash*h);
+sp_PolyArray*sp_StrStrHash_to_a(sp_StrStrHash*h);
+sp_PolyArray*sp_IntStrHash_to_a(sp_IntStrHash*h);
+
+/* ---- sp_str_sub_str_str_hash relocated from spinel_rt.h (0 optcarrot uses). ---- */
+const char *sp_str_sub_str_str_hash(const char *str, const char *pat, sp_StrStrHash *h);
+const char *sp_str_gsub_str_str_hash(const char *str, const char *pat, sp_StrStrHash *h);
+
+/* ---- Regexp#gsub/#sub with a replacement Hash: relocated from
+   spinel_rt.h (0 optcarrot uses). Needs mrb_regexp_pattern/re_exec
+   (sp_re.h, included by lib/sp_cold.c already). ---- */
+const char *sp_re_gsub_str_str_hash(mrb_regexp_pattern *pat, const char *str, sp_StrStrHash *h);
+const char *sp_re_sub_str_str_hash(mrb_regexp_pattern *pat, const char *str, sp_StrStrHash *h);
+
+/* ---- sp_IntStrHash_clear: missed in the original CRUD batch
+   (present for the other 3 hash types, overlooked for this one). ---- */
+void sp_IntStrHash_clear(sp_IntStrHash*h);
+
+#endif

data/ext/qr_reader_native/sp_inspect.c

@@ -0,0 +1,215 @@
+/* sp_inspect.c -- generic container #inspect (see sp_inspect.h).
+
+   Walks a boxed array / hash via the hooks the generated TU installs
+   (sp_json_kind/len/aref/hpair classify and iterate; sp_poly_inspect_fn recurses
+   into elements/keys/values; sp_sym_name_fn renders a symbol key shorthand). No
+   typed-container accessors are touched, so this stays clear of the hot hash
+   probe path. The result is built with the shared sp_String builder. */
+#include "sp_inspect.h"
+#include "sp_string.h"   /* sp_String, sp_alloc.h, SP_GC_ROOT via sp_gc.h */
+#include "sp_str.h"      /* sp_sym_inspect_key for the symbol hash-key short form */
+#include "sp_array.h"    /* sp_PtrArray_to_poly / sp_PtrArray_inspect for sp_PtrArray_inspect_k */
+#include <stdlib.h>   /* realloc for the growing path below */
+
+/* The walk guard's per-worker path (see sp_inspect.h). It lives here because
+   this archive unit is the one every side of the runtime already links for
+   #inspect, and the guard has to be one set of frames shared by the generated
+   translation unit, the archive and the carried packages -- a per-TU copy would
+   let a walk that crosses the boundary forget where it had been. */
+SP_TLS sp_poly_recur_frame *sp_poly_recur_stack = NULL;
+SP_TLS int sp_poly_recur_top = 0;
+SP_TLS int sp_poly_recur_cap = 0;
+SP_TLS unsigned sp_poly_recur_hash_cycles = 0;
+/* Make room for at least `want` frames, doubling from 64. Off the hot path:
+   a walk deep enough to reach the end of the buffer has already paid far more
+   in its own recursion than this call costs. */
+#define SP_POLY_RECUR_FIRST_CAP 64   /* frames; 1.5 KB, more than any real walk */
+SP_COLD void sp_poly_recur_grow(int want) {
+  int cap = sp_poly_recur_cap ? sp_poly_recur_cap : SP_POLY_RECUR_FIRST_CAP;
+  while (cap < want) cap *= 2;
+  sp_poly_recur_frame *f = (sp_poly_recur_frame *)
+      realloc(sp_poly_recur_stack, sizeof(sp_poly_recur_frame) * (size_t)cap);
+  if (!f) sp_oom_die();
+  sp_poly_recur_stack = f;
+  sp_poly_recur_cap = cap;
+}
+
+/* ---- the deep-walk index (SP_POLY_RECUR_SCAN, sp_inspect.h) ----
+   Open addressing over the frames themselves: a slot names a frame by index
+   and repeats its key, and is live only while that frame is still on the path
+   with that key. A pop lowers sp_poly_recur_top and sp_poly_recur_ixtop and
+   leaves the slots to go stale on their own; a lookup checks the frame, an
+   insert may take a stale slot, and once the slots in use (live or stale) pass
+   half the table it is rebuilt from the live frames at a quarter load. Nothing
+   here runs until a walk is deeper than the scan budget. */
+typedef struct { const void *a, *b; int kind, frame; } sp_poly_recur_slot;
+static SP_TLS sp_poly_recur_slot *sp_poly_recur_ix = NULL;
+static SP_TLS int sp_poly_recur_ixcap = 0;    /* a power of two, or 0 before first use */
+static SP_TLS int sp_poly_recur_ixused = 0;   /* slots holding a frame, live or stale */
+SP_TLS int sp_poly_recur_ixtop = 0;
+
+/* Multipliers for the slot hash: 2^64 / phi and two more odd constants of the
+   same shape (xxHash's), so a pointer's bits spread across the word before the
+   fold and the mask. Any odd multipliers would do; these are the usual ones. */
+#define SP_POLY_RECUR_HASH_M1 0x9E3779B97F4A7C15ull
+#define SP_POLY_RECUR_HASH_M2 0xC2B2AE3D27D4EB4Full
+#define SP_POLY_RECUR_HASH_M3 0x165667B19E3779F9ull
+#define SP_POLY_RECUR_IX_MIN  256   /* slots; an eighth full at the scan budget */
+/* Callers guarantee a built table: sp_poly_recur_index rebuilds before any probe. */
+static inline int sp_poly_recur_slot_of(int kind, const void *a, const void *b) {
+  uint64_t h = ((uint64_t)(uintptr_t)a >> 4) * SP_POLY_RECUR_HASH_M1
+             ^ ((uint64_t)(uintptr_t)b >> 4) * SP_POLY_RECUR_HASH_M2
+             ^ (uint64_t)kind * SP_POLY_RECUR_HASH_M3;
+  h ^= h >> 32;
+  return (int)(h & (uint64_t)(sp_poly_recur_ixcap - 1));
+}
+static inline int sp_poly_recur_slot_live(const sp_poly_recur_slot *s) {
+  if (s->frame >= sp_poly_recur_top) return 0;
+  const sp_poly_recur_frame *f = &sp_poly_recur_stack[s->frame];
+  return f->a == s->a && f->b == s->b && f->kind == s->kind;
+}
+static void sp_poly_recur_ix_insert(int frame) {
+  const sp_poly_recur_frame *f = &sp_poly_recur_stack[frame];
+  int mask = sp_poly_recur_ixcap - 1;
+  int i = sp_poly_recur_slot_of(f->kind, f->a, f->b);
+  for (;;) {
+    sp_poly_recur_slot *s = &sp_poly_recur_ix[i];
+    if (s->frame < 0) { sp_poly_recur_ixused++; break; }
+    if (!sp_poly_recur_slot_live(s)) break;   /* a stale slot is free */
+    i = (i + 1) & mask;
+  }
+  sp_poly_recur_ix[i].a = f->a;
+  sp_poly_recur_ix[i].b = f->b;
+  sp_poly_recur_ix[i].kind = f->kind;
+  sp_poly_recur_ix[i].frame = frame;
+}
+SP_COLD static void sp_poly_recur_ix_rebuild(int frames) {
+  int cap = SP_POLY_RECUR_IX_MIN;
+  while (cap < frames * 4) cap *= 2;
+  if (cap != sp_poly_recur_ixcap) {
+    free(sp_poly_recur_ix);
+    sp_poly_recur_ix = (sp_poly_recur_slot *)malloc(sizeof(sp_poly_recur_slot) * (size_t)cap);
+    if (!sp_poly_recur_ix) sp_oom_die();
+    sp_poly_recur_ixcap = cap;
+  }
+  for (int i = 0; i < cap; i++) sp_poly_recur_ix[i].frame = -1;
+  sp_poly_recur_ixused = 0;
+  sp_poly_recur_ixtop = 0;
+}
+void sp_poly_recur_index(void) {
+  int top = sp_poly_recur_top;
+  if (sp_poly_recur_ixused + (top - sp_poly_recur_ixtop) > sp_poly_recur_ixcap / 2)
+    sp_poly_recur_ix_rebuild(top);
+  for (int i = sp_poly_recur_ixtop; i < top; i++) sp_poly_recur_ix_insert(i);
+  sp_poly_recur_ixtop = top;
+}
+int sp_poly_recur_seen_deep(int kind, const void *a, const void *b) {
+  /* a fiber switch (sp_exc_ctx_load) puts other frames under the index, and
+     the first deep lookup of a worker finds no table at all */
+  if (sp_poly_recur_ixcap == 0 || sp_poly_recur_ixtop < sp_poly_recur_top) sp_poly_recur_index();
+  int mask = sp_poly_recur_ixcap - 1;
+  int i = sp_poly_recur_slot_of(kind, a, b);
+  for (;;) {
+    const sp_poly_recur_slot *s = &sp_poly_recur_ix[i];
+    if (s->frame < 0) return 0;
+    if (s->a == a && s->b == b && s->kind == kind && sp_poly_recur_slot_live(s)) return 1;
+    i = (i + 1) & mask;
+  }
+}
+
+/* ---- the Set package's walks (prototypes and kinds in sp_inspect.h) ---- */
+static sp_int sp_poly_recur_enter(int kind, const void *a, const void *b) {
+  if (sp_poly_recur_seen(kind, a, b)) return -1;
+  return sp_poly_recur_push(kind, a, b);
+}
+sp_int sp_poly_recur_enter_inspect(sp_RbVal set) {
+  return sp_poly_recur_enter(SP_POLY_RECUR_SET_INSPECT, set.v.p, NULL);
+}
+sp_int sp_poly_recur_enter_eq(sp_RbVal set, sp_RbVal other) {
+  return sp_poly_recur_enter(SP_POLY_RECUR_SET_EQ, set.v.p, other.v.p);
+}
+sp_int sp_poly_recur_enter_flatten(sp_RbVal set) {
+  /* the Ruby raises on -1; as in the runtime's flatten, the walk's own frames
+     go before the raise (sp_poly_recur_drop_kind) */
+  if (sp_poly_recur_seen(SP_POLY_RECUR_SET_FLATTEN, set.v.p, NULL)) {
+    sp_poly_recur_drop_kind(SP_POLY_RECUR_SET_FLATTEN);
+    return -1;
+  }
+  return sp_poly_recur_push(SP_POLY_RECUR_SET_FLATTEN, set.v.p, NULL);
+}
+/* The mark comes back from Ruby, where anyone can spell the module's name. One
+   this path never handed out to a Set walk -- outside the frames, or naming a
+   frame of the runtime's own -- is ignored rather than moving the depth under
+   a walk that is still running. A Set walk's own mark whose frame a handler
+   has already dropped is beyond top, and ignored the same way. */
+void sp_poly_recur_leave(sp_int mark) {
+  if (mark < 0 || mark >= sp_poly_recur_top) return;
+  int kind = sp_poly_recur_stack[mark].kind;
+  if (kind != SP_POLY_RECUR_SET_INSPECT && kind != SP_POLY_RECUR_SET_EQ &&
+      kind != SP_POLY_RECUR_SET_FLATTEN) return;
+  sp_poly_recur_pop((int)mark);
+}
+
+const char *sp_inspect_container(sp_RbVal v) {
+  /* The container is live across the sp_String allocations below; root it so a
+     GC mid-inspect can't free it -- otherwise inspecting a freshly built,
+     otherwise-unrooted collection (e.g. `p hash.flat_map { ... }`) is a
+     use-after-free under GC pressure. */
+  SP_GC_ROOT_RBVAL(v);
+  int kind = sp_json_kind_fn ? sp_json_kind_fn(v) : 0;
+  sp_int n = sp_json_len_fn ? sp_json_len_fn(v) : 0;
+  /* A container reached from inside itself renders as the ellipsis and stops:
+     CRuby prints [[...]] for `a << a` and {h: {...}} for `h[:h] = h`. The mark
+     covers the loop below, so a SIBLING copy of the same object still renders
+     in full -- only the one the walk is standing inside is elided. */
+  if (sp_poly_recur_seen(SP_POLY_RECUR_INSPECT, v.v.p, NULL))
+    return kind == 1 ? SPL("[...]") : SPL("{...}");
+  int rmark = sp_poly_recur_push(SP_POLY_RECUR_INSPECT, v.v.p, NULL);
+  if (kind == 1) {  /* array: [e0, e1, ...] */
+    sp_String *s = sp_String_new("[");
+    SP_GC_ROOT(s);
+    for (sp_int i = 0; i < n; i++) {
+      if (i) sp_String_append(s, ", ");
+      sp_String_append(s, sp_poly_inspect_fn(sp_json_aref_fn(v, i)));
+    }
+    sp_String_append(s, "]");
+    sp_poly_recur_pop(rmark);
+    return sp_str_dup(s->data);
+  }
+  /* hash: {k => v, ...}, with the `sym: v` shorthand for a Symbol key. */
+  sp_String *s = sp_String_new("{");
+  SP_GC_ROOT(s);
+  for (sp_int i = 0; i < n; i++) {
+    if (i) sp_String_append(s, ", ");
+    sp_RbVal k, val;
+    sp_json_hpair_fn(v, i, &k, &val);
+    if (k.tag == SP_TAG_SYM) {
+      sp_String_append(s, sp_sym_inspect_key(sp_sym_name_fn ? sp_sym_name_fn((sp_sym)k.v.i) : ""));
+      sp_String_append(s, ": ");
+    }
+    else {
+      sp_String_append(s, sp_poly_inspect_fn(k));
+      sp_String_append(s, " => ");
+    }
+    sp_String_append(s, sp_poly_inspect_fn(val));
+  }
+  sp_String_append(s, "}");
+  sp_poly_recur_pop(rmark);
+  return sp_str_dup(s->data);
+}
+
+/* Array#inspect for heterogeneous poly arrays. Each element dispatches
+   through sp_poly_inspect, so a mixed `[1, "x", :y]` renders
+   `[1, "x", :y]` byte-for-byte identical to CRuby. NULL renders
+   "nil" so callers that store a nil-returning slot (assoc/rassoc
+   miss, etc.) round-trip cleanly through `.inspect`. */
+const char *sp_PolyArray_inspect(sp_PolyArray *a) {
+  if (!a) { char *r = sp_str_alloc(3); r[0] = 'n'; r[1] = 'i'; r[2] = 'l'; r[3] = 0; sp_str_set_len(r, 3); return r; }
+  return sp_inspect_container(sp_box_poly_array(a));
+}
+/* a pointer array by what it holds (#4486) */
+const char *sp_PtrArray_inspect_k(sp_PtrArray *a) {
+  if (!a) return SPL("nil");
+  if (a->elem_kind == SP_PTR_ELEM_UNKNOWN) return sp_PtrArray_inspect(a);   /* opaque, as the erased id always was */
+  return sp_PolyArray_inspect(sp_PtrArray_to_poly(a));
+}

data/ext/qr_reader_native/sp_inspect.h

@@ -0,0 +1,128 @@
+#ifndef SP_INSPECT_H
+#define SP_INSPECT_H
+/* sp_inspect.h -- generic container #inspect, split out of spinel_rt.h.
+
+   sp_inspect_container formats a boxed array or hash in Ruby #inspect form,
+   walking it through the generic sp_json_* / sp_poly_inspect_fn hooks (sp_gc.h)
+   and building the result with sp_String (sp_string.h). The per-type inspect
+   helpers in spinel_rt.h are now one-line wrappers that box their receiver and
+   call this, so all the inspect string-building compiles once in the archive
+   rather than in every generated TU. */
+#include "sp_gc.h"   /* sp_RbVal */
+
+const char *sp_inspect_container(sp_RbVal v);
+
+/* ---- the walk guard: an object already on the path stops the walk ----
+ *
+ * `a = []; a << a` is legal Ruby, and so is a Struct that holds itself. Every
+ * walk that descends into a container -- #inspect, ==, eql?, <=>, #hash,
+ * #flatten, #join, puts -- would follow such a cycle until the C stack ran
+ * out. CRuby's rb_exec_recursive keeps, per thread, the set of objects (or
+ * object PAIRS) the current walk is already inside and answers a fixed result
+ * for one it meets again; this is that set, as a small stack.
+ *
+ * Frames hold raw pointers that are only ever COMPARED, never dereferenced:
+ * the collector does not move objects, and pushing a frame allocates nothing,
+ * so a walk cannot collect the very object it is remembering. Per-worker
+ * (SP_TLS) like the exception stack, and carried across a green thread's
+ * suspension by sp_exc_ctx_save/load, so two fibers walking at once each keep
+ * their own path. */
+#define SP_POLY_RECUR_INSPECT 1
+#define SP_POLY_RECUR_EQ      2   /* shared by ==, eql? and <=>: all three answer
+                                     "equal" for a pair they are already inside */
+#define SP_POLY_RECUR_HASH    3
+#define SP_POLY_RECUR_FLATTEN 4
+#define SP_POLY_RECUR_JOIN    5
+#define SP_POLY_RECUR_PUTS    6   /* `puts a` walks an array without inspecting it */
+/* What a repeated object contributes to a #hash: a fixed ODD constant, because
+   nil, false and 0 all hash to 0 and a Struct holding itself must not hash like
+   one holding nil. */
+#define SP_POLY_RECUR_HASH_VALUE ((sp_int)0x3f5b9d7e2c1a4d05LL)
+typedef struct { const void *a, *b; int kind; } sp_poly_recur_frame;
+/* How many times a #hash walk has met a container it was already inside
+   (sp_rbval_hash_member compares it before and after a member). It only
+   counts up, per worker. */
+extern SP_TLS unsigned sp_poly_recur_hash_cycles;
+/* The frames grow on demand rather than sitting in a fixed TLS array: a fixed
+   cap would leave a cycle whose repeated object is deeper than the cap running
+   off the C stack, and kilobytes of TLS shift the layout (and the cost) of
+   every hot per-worker variable -- the break stack's own comment records
+   measuring 8% of optcarrot on exactly that. Only the pointer and the two
+   counts live in TLS; the frames are malloc'd on the first push, doubled when
+   full, and never shrunk, per worker. */
+extern SP_TLS sp_poly_recur_frame *sp_poly_recur_stack;
+extern SP_TLS int sp_poly_recur_top;
+extern SP_TLS int sp_poly_recur_cap;
+void sp_poly_recur_grow(int want);   /* first allocation and every doubling */
+/* A lookup scans the path: a real program's path is under ten frames, and a
+   scan of that beats any table. But a scan at every level of a deep walk is
+   quadratic -- a 2000-deep nest would compare 2000 frames at each of its 2000
+   levels, where CRuby's rb_exec_recursive, a hash, stays linear. So past
+   SP_POLY_RECUR_SCAN frames the path is also indexed (sp_inspect.c) and a
+   lookup is one probe. Frames [0, sp_poly_recur_ixtop) are in the index; a pop
+   below that simply lowers it, and the next deep push indexes what is missing. */
+#define SP_POLY_RECUR_SCAN 32
+extern SP_TLS int sp_poly_recur_ixtop;
+int  sp_poly_recur_seen_deep(int kind, const void *a, const void *b);
+void sp_poly_recur_index(void);      /* bring the index up to sp_poly_recur_top */
+/* Is (kind, a, b) already on the path? `b` is NULL for the single-object kinds
+   (inspect, hash, flatten, join, puts) and the other side of the pair for
+   equality. An empty path (the common case) reads one int and returns. */
+static inline int sp_poly_recur_seen(int kind, const void *a, const void *b) {
+  int top = sp_poly_recur_top;
+  /* the scan covers SCAN frames; the push of the frame at index SCAN is the
+     one that indexes (below), and from then on top is SCAN + 1 or more */
+  if (SP_UNLIKELY(top > SP_POLY_RECUR_SCAN)) return sp_poly_recur_seen_deep(kind, a, b);
+  for (int i = top - 1; i >= 0; i--) {
+    if (sp_poly_recur_stack[i].a == a && sp_poly_recur_stack[i].b == b &&
+        sp_poly_recur_stack[i].kind == kind) return 1;
+  }
+  return 0;
+}
+/* Push a frame and answer the mark to hand back to sp_poly_recur_pop. */
+static inline int sp_poly_recur_push(int kind, const void *a, const void *b) {
+  int mark = sp_poly_recur_top;
+  if (SP_UNLIKELY(mark == sp_poly_recur_cap)) sp_poly_recur_grow(mark + 1);
+  sp_poly_recur_stack[mark].a = a;
+  sp_poly_recur_stack[mark].b = b;
+  sp_poly_recur_stack[mark].kind = kind;
+  sp_poly_recur_top = mark + 1;
+  if (SP_UNLIKELY(mark >= SP_POLY_RECUR_SCAN)) sp_poly_recur_index();
+  return mark;
+}
+static inline void sp_poly_recur_pop(int mark) {
+  sp_poly_recur_top = mark;
+  if (SP_UNLIKELY(sp_poly_recur_ixtop > mark)) sp_poly_recur_ixtop = mark;
+}
+/* The current depth as a mark, for a walk that took a branch where it did not
+   push: the pop that pairs with it then leaves the path exactly as it was. */
+static inline int sp_poly_recur_save(void) { return sp_poly_recur_top; }
+/* Drop every frame of `kind` from the top of the path. A walk about to raise
+   with no answer to give -- an unlimited flatten or a join that met itself --
+   takes its own frames with it, so nothing is left on the path for a later
+   walk to trip over even where no handler restores the depth (an at_exit
+   block still walks). A handler further out that does restore re-exposes the
+   frames of walks that are still running, which is what it should do. */
+static inline void sp_poly_recur_drop_kind(int kind) {
+  int top = sp_poly_recur_top;
+  while (top > 0 && sp_poly_recur_stack[top - 1].kind == kind) top--;
+  sp_poly_recur_pop(top);
+}
+/* The Set package (packages/set/set.rb) walks its elements in Ruby, so its
+   #inspect, #== and #flatten bind these through native_func and keep their
+   frames on this same path: per fiber, restored by every longjmp, and with no
+   `ensure` in the Ruby. `enter` answers the mark for sp_poly_recur_leave, or
+   -1 when the walk is already inside that Set (or pair), which is the caller's
+   cue to stop. The module is reachable by name from Ruby, so `leave` ignores a
+   mark this path never handed out to a Set walk. The kinds are Set's own so a
+   frame the runtime pushed for the same object or pair -- sp_poly_eql on two
+   Sets reaches Set#== through the user hook -- is not mistaken for the Set
+   walk's. */
+#define SP_POLY_RECUR_SET_INSPECT 7
+#define SP_POLY_RECUR_SET_EQ      8
+#define SP_POLY_RECUR_SET_FLATTEN 9
+sp_int sp_poly_recur_enter_inspect(sp_RbVal set);
+sp_int sp_poly_recur_enter_eq(sp_RbVal set, sp_RbVal other);
+sp_int sp_poly_recur_enter_flatten(sp_RbVal set);
+void   sp_poly_recur_leave(sp_int mark);
+#endif /* SP_INSPECT_H */