qr_reader-native 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 302d0fa96881495731eb70720ef57850577cd6abccdce2037be53640ad961fa2
+  data.tar.gz: 9b16290e8a14b8f8d9852e5306553bf7dc266b34a32d6e6c90b5f2fab7e02533
+SHA512:
+  metadata.gz: b80a5b426ca64035ed32c7f03ddb4a38bf7f784e6fc96ffd1c1bae5112ea530230ddac1aaaa053b80017e45b6798b5c3d5a47e0c82d3a44285dfe38b7615c49b
+  data.tar.gz: 4712f8478d40c573807b3d65552910e6dc1ee583b4b51c93e36cbceac92dfd7a33f4eca90788e8082e2f577e958d5ecacbeaa1738749afa870e0dff970b75f49

data/LICENSE-mruby.txt

@@ -0,0 +1,22 @@
+Parts of the Spinel runtime under ext/qr_reader_native (marked "See Copyright
+Notice in mruby.h") are derived from mruby:
+
+Copyright (c) 2010- mruby developers
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

data/LICENSE-spinel.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2024- Yukihiro Matsumoto (matz@ruby.or.jp)
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andi Idogawa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+# qr_reader-native
+
+Optional native speed-up for [qr_reader](https://github.com/largo/qr_reader).
+
+qr_reader is pure Ruby. Its hot loops (image decoding, binarization, pattern
+scanning) are written as plain-Ruby "kernels" in a subset of Ruby that the
+[Spinel](https://github.com/matz/spinel) AOT compiler understands. This gem is
+those very kernels compiled to C by Spinel: install it next to qr_reader and
+qr_reader uses them automatically.
+
+```ruby
+# Gemfile
+gem "qr_reader"
+gem "qr_reader-native"   # optional; needs a C compiler at install time
+```
+
+```ruby
+require "qr_reader"
+QrReader.native?          # => true when the native kernels are in use
+```
+
+- Same results: the native kernels are compiled from the same source as the
+  Ruby ones and are tested against them.
+- Safe to omit: without this gem, or on Rubies without C extensions (JRuby,
+  ruby.wasm, ...), qr_reader runs the same code as Ruby.
+- Version-locked: it depends on the identical qr_reader version and is only
+  used when its kernel digest matches the installed qr_reader.
+- `QR_READER_NATIVE=0` disables it at runtime.
+
+## Which kernels run natively
+
+Each kernel is used natively only where that was measured to be faster
+(`QrReader::NativeKernels::ALWAYS`/`WITHOUT_YJIT`/`NEVER`):
+
+| kernel | with YJIT | without YJIT |
+|---|---|---|
+| hybrid binarization | 2.6x faster | 8.9x faster |
+| finder-pattern scan | 9.6x faster | 6.3x faster |
+| downscale | ~same | 8x faster |
+| CCITT G3/G4 | ~same | 3.6x faster |
+| JPEG IDCT rendering | 4-20x faster | 4-20x faster |
+| PNG / pixel conversion | slower -> Ruby | 3x faster |
+| JPEG entropy decoding | not used | not used |
+
+JPEG entropy decoding compiled by the current Spinel (see
+ext/qr_reader_native/SPINEL_VERSION) is 2x faster on small images but slows
+down superlinearly with image size (32 ms at 640x480, 3 s at 2560x1920, versus
+83 ms in Ruby), so it stays Ruby until that is fixed in Spinel. The usual
+suspects (`byteindex`, `byteslice`, `getbyte` on strings passed from CRuby,
+appends, Strings held in Arrays) are all linear in isolation (see
+bench/spinel/ in the qr_reader repository).
+
+Installing compiles about 4 MB of generated C (Spinel's runtime included);
+Spinel itself is not needed.
+
+## Licenses
+
+MIT (see LICENSE.txt). `ext/qr_reader_native` contains code generated by
+Spinel and the Spinel runtime (MIT, Copyright (c) 2024- Yukihiro Matsumoto,
+see LICENSE-spinel.txt), parts of which derive from mruby (MIT, see
+LICENSE-mruby.txt).

data/ext/qr_reader_native/SPINEL_VERSION

@@ -0,0 +1 @@
+spinel 2026.09.12+7228 (84f5b5020) [gcc 15.2.0 (cc)]

data/ext/qr_reader_native/extconf.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+# The sources are generated by Spinel (script/native_generate.rb) and include
+# Spinel's runtime; they only need a C compiler.
+$INCFLAGS << " -I$(srcdir)"
+create_makefile("qr_reader_native/qr_reader_native")

data/ext/qr_reader_native/mruby/error.h

@@ -0,0 +1,13 @@
+/* shim/mruby/error.h - see shim/mruby.h */
+#ifndef SP_RE_SHIM_MRUBY_ERROR_H
+#define SP_RE_SHIM_MRUBY_ERROR_H
+#include "../mruby.h"
+
+struct RClass;
+struct RClass *mrb_exc_get_id(mrb_state *mrb, mrb_sym name);
+mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass *c, mrb_value str);
+/* the one exception the engine raises is a RegexpError, and it hands the
+   message to spinel's handler (sp_re_set_error_handler), which does not
+   return */
+__attribute__((noreturn)) void mrb_exc_raise(mrb_state *mrb, mrb_value exc);
+#endif

data/ext/qr_reader_native/mruby/internal.h

@@ -0,0 +1,145 @@
+/* shim/mruby/internal.h - see shim/mruby.h. The UTF-8 scan and the case
+   declarations below are mruby's include/mruby/internal.h as it spells them. */
+#ifndef SP_RE_SHIM_MRUBY_INTERNAL_H
+#define SP_RE_SHIM_MRUBY_INTERNAL_H
+#include "../mruby.h"
+
+#define MRB_ENC_MULTIBYTE_P 1
+
+/* a buffer that lives until the compile ends (re_spinel.c) */
+void *mrb_temp_alloc(mrb_state *mrb, size_t size);
+
+mrb_int mrb_utf8_to_buf(char *buf, mrb_int cp);
+
+#define MRB_UTF8_MALFORMED (-1)
+#define MRB_UTF8_TRUNCATED (-2)
+#define MRB_UTF8_REDUNDANT (-3)
+#define MRB_UTF8_EXCLUDED  (-4)
+#define MRB_UTF8_LONG      (-5)
+
+static inline mrb_int
+mrb_utf8_scan(const char *p, const char *e, uint32_t *uv, const uint8_t bounds[][2])
+{
+  /* the byte length a lead byte claims, by its top five bits; the last entry
+     folds 0xF8-0xFF together and they are told apart below. The table lives
+     in the function, as the lookup tables of boxing_word.h do, so that a
+     translation unit that never reads through the scan emits neither, at
+     any optimization level. */
+  static const uint8_t lead[32] = {
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 3, 3, 4, 0
+  };
+  const unsigned char *q = (const unsigned char*)p;
+  unsigned char c = q[0];
+  mrb_int n = lead[c >> 3];
+
+  if (n <= 1) {
+    if (n == 1) {
+      if (uv) *uv = c;
+      return 1;
+    }
+    /* a continuation byte leads nothing; 0xF8-0xFD claim five or six,
+       the lengths RFC 3629 withdrew, which a reader that wants them reads
+       for itself */
+    return (c < 0xF8 || c >= 0xFE) ? MRB_UTF8_MALFORMED : MRB_UTF8_LONG;
+  }
+  if (n > e - p) return MRB_UTF8_TRUNCATED;
+
+  /* Each byte after the lead has to continue it. A second byte inside its
+     bounds has, since the table admits nothing else, so only one outside
+     them walks the sequence to tell a malformed one from a bounded one. The
+     later checks nest in the order the bytes come, so a length costs the
+     compares up to its own and none past it. Read as a signed char, a
+     continuation byte is one below -0x40, a single compare where the mask
+     takes three. A caller that wants the form alone passes no `uv`, and the
+     value is dead code the compiler drops. */
+  const uint8_t *b = bounds[c - 0xC0];
+  if (q[1] < b[0] || q[1] > b[1]) {
+    for (mrb_int i = 1; i < n; i++) {
+      if ((signed char)q[i] >= -0x40) return MRB_UTF8_MALFORMED;
+    }
+    return q[1] < b[0] ? MRB_UTF8_REDUNDANT : MRB_UTF8_EXCLUDED;
+  }
+  uint32_t v = ((c & (0x7F >> n)) << 6) | (q[1] & 0x3F);
+  if (n > 2) {
+    if ((signed char)q[2] >= -0x40) return MRB_UTF8_MALFORMED;
+    v = (v << 6) | (q[2] & 0x3F);
+    if (n > 3) {
+      if ((signed char)q[3] >= -0x40) return MRB_UTF8_MALFORMED;
+      v = (v << 6) | (q[3] & 0x3F);
+    }
+  }
+  if (uv) *uv = v;
+  return n;
+}
+
+mrb_int mrb_utf8len(const char *str, const char *end);
+const char *mrb_utf8_char_head(const char *beg, const char *p, const char *end);
+uint32_t mrb_utf8_decode(const char *p, const char *e, mrb_int *lenp);
+
+static inline mrb_int
+mrb_enc_charlen(const char *p, const char *e)
+{
+  return mrb_utf8len(p, e);
+}
+
+static inline const char *
+mrb_enc_char_head(const char *beg, const char *p, const char *end)
+{
+  return mrb_utf8_char_head(beg, p, end);
+}
+
+static inline uint32_t
+mrb_enc_decode(const char *p, const char *e, mrb_int *lenp)
+{
+  return mrb_utf8_decode(p, e, lenp);
+}
+
+enum mrb_case_kind {
+  MRB_CASE_KIND_LOWER,
+  MRB_CASE_KIND_UPPER,
+  MRB_CASE_KIND_TITLE,
+  MRB_CASE_KIND_SWAP,
+  MRB_CASE_KIND_FOLD
+};
+
+/* The buffer mrb_uni_case_map() writes into. A mapping may spell several
+   characters, so this is wider than one of them; unicase.c asserts that the
+   table it carries fits. */
+#define MRB_UNI_CASE_MAX_BYTES 8
+
+/* The `kind` mapping of `cp`, written into `buf` as UTF-8, answering how many
+   bytes it took, or 0 for a character that maps to itself. */
+mrb_int mrb_uni_case_map(enum mrb_case_kind kind, uint32_t cp, char *buf);
+
+#ifdef HAVE_MRUBY_REGEXP_GEM
+/* The four below are the foldings /i reads off the same table, in the two
+   directions a pattern needs them. A build without mruby-regexp has nothing
+   that reads them, so a caller reaching for one there is a compile error
+   rather than a link one. */
+
+/* Simple case folding: the folded codepoint, or cp itself when it folds to
+   nothing else. A codepoint whose folding spells several characters (U+FB00
+   to "ff") folds to itself here, which is what makes this the simple folding
+   rather than the full one mrb_uni_case_map() answers with. */
+uint32_t mrb_uni_case_fold(uint32_t cp);
+
+/* At most this many codepoints share one folded form. */
+#define MRB_UNI_MAX_UNFOLD 4
+
+/* Write every other codepoint sharing cp's folded form into out, at most max
+   of them, and answer how many were written. */
+int mrb_uni_case_unfold(uint32_t cp, uint32_t *out, int max);
+
+/* The same two directions over a span rather than one codepoint, reporting
+   what they find by calling add() with each span of it: fold_range the folds
+   of the sources in [lo, hi], unfold_range the sources of the folds in
+   [lo, hi]. Spans may repeat or overlap what the caller already holds; the
+   caller merges. */
+void mrb_uni_case_fold_range(uint32_t lo, uint32_t hi,
+                             void (*add)(void *, uint32_t, uint32_t), void *user);
+void mrb_uni_case_unfold_range(uint32_t lo, uint32_t hi,
+                               void (*add)(void *, uint32_t, uint32_t), void *user);
+#endif  /* HAVE_MRUBY_REGEXP_GEM */
+
+#endif /* SP_RE_SHIM_MRUBY_INTERNAL_H */

data/ext/qr_reader_native/mruby/string.h

@@ -0,0 +1,22 @@
+/* shim/mruby/string.h - see shim/mruby.h */
+#ifndef SP_RE_SHIM_MRUBY_STRING_H
+#define SP_RE_SHIM_MRUBY_STRING_H
+#include "../mruby.h"
+
+struct sp_re_str {
+  char *ptr;
+  mrb_int len;
+  mrb_int capa;
+  struct sp_re_str *next;   /* the compile's list of strings to release */
+};
+#define RSTRING_PTR(s) ((s)->ptr)
+#define RSTRING_LEN(s) ((s)->len)
+
+mrb_value mrb_str_new(mrb_state *mrb, const char *p, size_t len);
+mrb_value mrb_str_new_cstr(mrb_state *mrb, const char *p);
+mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *p, size_t len);
+mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len);
+/* mruby's format: %l takes a pointer and a size_t length, %v a String, %c a
+   char; the engine uses no other directive */
+mrb_value mrb_format(mrb_state *mrb, const char *fmt, ...);
+#endif

data/ext/qr_reader_native/mruby.h

@@ -0,0 +1,93 @@
+/*
+** shim/mruby.h - the slice of mruby's API the regexp engine reads
+**
+** lib/regexp holds mruby-regexp's engine as mruby carries it (re_compile.c,
+** re_exec.c, re_utf8.c, re_internal.h, re_ctype.h, re_cased.h) together
+** with mruby's case tables (unicase.c, unicase.h), so that a later change
+** there is taken by copying the files again. The engine is written against
+** mruby's API; spinel has no mruby VM, and these headers answer the calls
+** the engine makes with the C library. re_spinel.c defines the functions
+** declared here and gives the engine the entry points spinel calls.
+*/
+#ifndef SP_RE_SHIM_MRUBY_H
+#define SP_RE_SHIM_MRUBY_H
+
+#include "sp_re_names.h"
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+/* the build the engine reads a string as: UTF-8, with the Unicode tables
+   (RE_UNICODE_CASE, and re_ctype.h above ASCII) unless a -DMRB_USE_ASCII_CTYPE
+   build leaves them out */
+#ifndef MRB_UTF8_STRING
+# define MRB_UTF8_STRING
+#endif
+#ifndef HAVE_MRUBY_REGEXP_GEM
+# define HAVE_MRUBY_REGEXP_GEM
+#endif
+/* spinel's switches for a build without the Unicode tables: mruby has the
+   one, which leaves out the case foldings and the classes above ASCII
+   together */
+#if (defined(RE_NO_UNICODE_CASE) || defined(RE_NO_UNICODE_CTYPE)) && !defined(MRB_USE_ASCII_CTYPE)
+# define MRB_USE_ASCII_CTYPE
+#endif
+
+#ifdef __cplusplus
+# define MRB_BEGIN_DECL extern "C" {
+# define MRB_END_DECL }
+#else
+# define MRB_BEGIN_DECL
+# define MRB_END_DECL
+#endif
+
+/* The backtracking engine's ceiling, as spinel's engine had it before this
+   one: mruby's default of 2048 entries refuses a subject spinel matched
+   (a backreference to a run of 20000, test/regexp_backtrack_heap_stack.rb),
+   and a limit is not lowered because what it counts moved. */
+#ifndef MRB_REGEXP_STACK_LIMIT
+# define MRB_REGEXP_STACK_LIMIT 32768
+#endif
+
+typedef int64_t mrb_int;
+typedef uint8_t mrb_bool;
+#ifndef TRUE
+# define TRUE 1
+#endif
+#ifndef FALSE
+# define FALSE 0
+#endif
+#define MRB_INT_MAX INT64_MAX
+
+/* The engine threads an mrb_state through every call it makes; nothing
+   reads it here. */
+typedef struct mrb_state { int unused; } mrb_state;
+
+/* A String, as the engine uses one: a growable buffer it builds a message or
+   a table in. Every one made during a compile is released when the compile
+   ends (re_spinel.c), as mruby's GC would release it. */
+typedef struct sp_re_str *mrb_value;
+static inline mrb_value mrb_nil_value(void) { return NULL; }
+static inline mrb_bool mrb_nil_p(mrb_value v) { return v == NULL; }
+
+typedef int mrb_sym;
+#define MRB_SYM(name) 0
+
+#ifdef MRB_DEBUG
+# define mrb_assert(p) assert(p)
+#else
+# define mrb_assert(p) ((void)0)
+#endif
+#define mrb_static_assert(...) _Static_assert(__VA_ARGS__)
+
+void *mrb_malloc(mrb_state *mrb, size_t len);
+void *mrb_malloc_simple(mrb_state *mrb, size_t len);
+void *mrb_calloc(mrb_state *mrb, size_t nelem, size_t len);
+void *mrb_realloc(mrb_state *mrb, void *p, size_t len);
+void *mrb_realloc_simple(mrb_state *mrb, void *p, size_t len);
+void mrb_free(mrb_state *mrb, void *p);
+
+#endif /* SP_RE_SHIM_MRUBY_H */

data/ext/qr_reader_native/mruby_shim.h

@@ -0,0 +1,118 @@
+/*
+ * Minimal shim to compile mruby-bigint without the full mruby runtime.
+ * Provides just enough types and macros for bigint.c to compile standalone.
+ */
+#ifndef MRUBY_SHIM_H
+#define MRUBY_SHIM_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+
+/* GCC < 10 doesn't predefine __has_builtin, so #if expressions like
+   `defined(__GNUC__) || __has_builtin(...)` choke on the bare token.
+   Provide a no-op fallback so the || short-circuits cleanly on the
+   left when the compiler doesn't support __has_builtin (issue #55). */
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+
+/* Basic mruby types */
+typedef int64_t mrb_int;
+typedef uint64_t mrb_uint;
+typedef double mrb_float;
+typedef int mrb_bool;
+#define TRUE 1
+#define FALSE 0
+#define MRB_INT_MAX INT64_MAX
+#define MRB_INT_MIN INT64_MIN
+#define MRB_INT_BIT 64
+
+/* mrb_state stub */
+typedef struct mrb_state {
+  int dummy;
+} mrb_state;
+
+/* Memory allocation */
+#define mrb_malloc(mrb, sz) malloc(sz)
+#define mrb_realloc(mrb, p, sz) realloc(p, sz)
+#define mrb_free(mrb, p) free(p)
+#define mrb_malloc_simple(mrb, sz) malloc(sz)
+
+/* Error handling — sp_bigint.c is compiled as a separate TU and
+   would otherwise hard-exit on internal errors (mini-gmp's zero-
+   divisor check, allocation overflow, etc.). The mrb_raise macro
+   now dispatches on the symbolic class enum: ZeroDivisionError is
+   routed through sp_bigint_raise_zerodiv (defined non-static in
+   spinel_rt.h, linked from gen.c) so it reaches spinel's longjmp
+   rescue net and is catchable by `rescue ZeroDivisionError`.
+   Other classes still hard-exit — they're internal invariants
+   (allocation overflow) where graceful handling buys little. */
+extern void sp_bigint_raise_zerodiv(const char *msg);
+#define E_RANGE_ERROR 1
+#define E_RUNTIME_ERROR 2
+#define E_ARGUMENT_ERROR 3
+#define E_TYPE_ERROR 4
+#define E_ZERODIV_ERROR 5
+#define mrb_raise(mrb, cls, msg) do { \
+  if ((cls) == E_ZERODIV_ERROR) { sp_bigint_raise_zerodiv(msg); } \
+  else { fprintf(stderr, "%s\n", msg); exit(1); } \
+} while(0)
+#define mrb_int_zerodiv(mrb) sp_bigint_raise_zerodiv("divided by 0")
+
+/* mrb_value stub - tagged union */
+typedef struct mrb_value {
+  union {
+    mrb_int i;
+    mrb_float f;
+    void *p;
+  } value;
+  int tt;
+} mrb_value;
+
+enum mrb_vtype {
+  MRB_TT_FALSE = 0,
+  MRB_TT_TRUE,
+  MRB_TT_INTEGER,
+  MRB_TT_FLOAT,
+  MRB_TT_STRING,
+  MRB_TT_BIGINT,
+};
+
+#define mrb_integer(v) ((v).value.i)
+#define mrb_float(v) ((v).value.f)
+#define mrb_ptr(v) ((v).value.p)
+#define mrb_type(v) ((v).tt)
+#define mrb_integer_p(v) ((v).tt == MRB_TT_INTEGER)
+#define mrb_float_p(v) ((v).tt == MRB_TT_FLOAT)
+#define mrb_bigint_p(v) ((v).tt == MRB_TT_BIGINT)
+#define mrb_fixnum_value(i) ((mrb_value){{.i=(i)}, MRB_TT_INTEGER})
+#define mrb_int_value(mrb, i) mrb_fixnum_value(i)
+
+/* Object header stub */
+#define MRB_OBJECT_HEADER uint32_t flags; uint32_t _pad
+#define mrb_obj_ptr(v) ((struct RBasic*)mrb_ptr(v))
+#define mrb_static_assert_object_size(t) /* nop */
+#define mrb_assert(x) assert(x)
+
+/* String */
+#define RSTRING_PTR(s) ((const char*)mrb_ptr(s))
+#define RSTRING_LEN(s) ((mrb_int)strlen(RSTRING_PTR(s)))
+
+/* nil value */
+static inline mrb_value mrb_nil_value(void) {
+  mrb_value v; v.tt = MRB_TT_FALSE; v.value.i = 0; return v;
+}
+
+/* MRB_ENSURE stub - execute body, no exception handling */
+#define MRB_ENSURE(mrb, exc, body, data) \
+  { mrb_value exc = body(mrb, data); (void)exc; } if(0)
+
+/* Bigint object creation */
+struct RBasic {
+  MRB_OBJECT_HEADER;
+};
+
+#endif /* MRUBY_SHIM_H */