qr_reader-native 0.0.1

data/ext/qr_reader_native/re_spinel.c

@@ -0,0 +1,363 @@
+/*
+** re_spinel.c - the regexp engine's entry points for spinel
+**
+** The engine in this directory is mruby-regexp's, taken from mruby as mruby
+** carries it (see shim/mruby.h). This file is the part that is spinel's own:
+** the mruby API the engine calls, answered with the C library, and the
+** re_compile / re_exec / re_free surface the runtime (lib/sp_re.c, the
+** strscan package) and the compiler's literal check (src/re_lit_check.c)
+** have always called. A compiled pattern is handed out as the engine's
+** mrb_regexp_pattern inside a record that also keeps the pattern text, for
+** Regexp#source and #inspect.
+*/
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include "re_spinel.h"
+#include <mruby/string.h>
+#include <mruby/error.h>
+
+#ifdef SP_THREADS
+# define RE_TLS _Thread_local
+#else
+# define RE_TLS
+#endif
+
+static mrb_state re_mrb;   /* nothing reads it; the engine passes it along */
+
+/* ---- memory ---- */
+
+static __attribute__((noreturn)) void re_nomem(void) {
+  fputs("[FATAL] regexp: failed to allocate memory\n", stderr);
+  abort();
+}
+void *mrb_malloc(mrb_state *mrb, size_t len) {
+  (void)mrb;
+  void *p = malloc(len ? len : 1);
+  if (!p) re_nomem();
+  return p;
+}
+void *mrb_malloc_simple(mrb_state *mrb, size_t len) {
+  (void)mrb;
+  return malloc(len ? len : 1);
+}
+void *mrb_calloc(mrb_state *mrb, size_t nelem, size_t len) {
+  (void)mrb;
+  void *p = calloc(nelem ? nelem : 1, len ? len : 1);
+  if (!p) re_nomem();
+  return p;
+}
+void *mrb_realloc(mrb_state *mrb, void *p, size_t len) {
+  (void)mrb;
+  void *q = realloc(p, len ? len : 1);
+  if (!q) re_nomem();
+  return q;
+}
+void *mrb_realloc_simple(mrb_state *mrb, void *p, size_t len) {
+  (void)mrb;
+  return realloc(p, len ? len : 1);
+}
+void mrb_free(mrb_state *mrb, void *p) { (void)mrb; free(p); }
+
+/* ---- the strings a compile makes ----
+   mruby's GC collects these; here every one made while a compile runs is on
+   one list, and the compile releases the list when it returns or raises. */
+
+static RE_TLS struct sp_re_str *re_strs;
+
+static mrb_value re_str_alloc(mrb_int capa) {
+  struct sp_re_str *s = (struct sp_re_str *)mrb_malloc(NULL, sizeof *s);
+  s->capa = capa < 16 ? 16 : capa;
+  s->ptr = (char *)mrb_malloc(NULL, (size_t)s->capa + 1);
+  s->len = 0;
+  s->ptr[0] = 0;
+  s->next = re_strs;
+  re_strs = s;
+  return s;
+}
+static void re_strs_release(void) {
+  while (re_strs) {
+    struct sp_re_str *n = re_strs->next;
+    free(re_strs->ptr);
+    free(re_strs);
+    re_strs = n;
+  }
+}
+static void re_str_reserve(mrb_value s, mrb_int need) {
+  if (need <= s->capa) return;
+  mrb_int capa = s->capa;
+  while (capa < need) capa *= 2;
+  s->ptr = (char *)mrb_realloc(NULL, s->ptr, (size_t)capa + 1);
+  s->capa = capa;
+}
+mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *p, size_t len) {
+  (void)mrb;
+  re_str_reserve(str, str->len + (mrb_int)len);
+  memcpy(str->ptr + str->len, p, len);
+  str->len += (mrb_int)len;
+  str->ptr[str->len] = 0;
+  return str;
+}
+mrb_value mrb_str_new(mrb_state *mrb, const char *p, size_t len) {
+  mrb_value s = re_str_alloc((mrb_int)len);
+  if (p) mrb_str_cat(mrb, s, p, len);
+  else { s->len = (mrb_int)len; memset(s->ptr, 0, len + 1); }
+  return s;
+}
+mrb_value mrb_str_new_cstr(mrb_state *mrb, const char *p) {
+  return mrb_str_new(mrb, p, strlen(p));
+}
+mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len) {
+  (void)mrb;
+  re_str_reserve(str, len);
+  if (len > str->len) memset(str->ptr + str->len, 0, (size_t)(len - str->len));
+  str->len = len;
+  str->ptr[len] = 0;
+  return str;
+}
+void *mrb_temp_alloc(mrb_state *mrb, size_t size) {
+  return RSTRING_PTR(mrb_str_new(mrb, NULL, size));
+}
+
+/* mruby's format, for the directives the engine uses: %l (a pointer and a
+   size_t length), %v (a String), %c (a char, passed as an int), %d (an int),
+   and a backslash that takes the next character literally */
+mrb_value mrb_format(mrb_state *mrb, const char *fmt, ...) {
+  mrb_value s = re_str_alloc(64);
+  va_list ap;
+  va_start(ap, fmt);
+  for (const char *p = fmt; *p; p++) {
+    /* a backslash takes the next character as it is, as mruby's does */
+    if (*p == '\\' && p[1]) { p++; mrb_str_cat(mrb, s, p, 1); continue; }
+    if (*p != '%' || !p[1]) { mrb_str_cat(mrb, s, p, 1); continue; }
+    p++;
+    switch (*p) {
+      case 'l': {
+        const char *q = va_arg(ap, const char *);
+        size_t n = va_arg(ap, size_t);
+        mrb_str_cat(mrb, s, q, n);
+        break;
+      }
+      case 'v': {
+        mrb_value v = va_arg(ap, mrb_value);
+        if (v) mrb_str_cat(mrb, s, v->ptr, (size_t)v->len);
+        break;
+      }
+      case 'c': { char ch = (char)va_arg(ap, int); mrb_str_cat(mrb, s, &ch, 1); break; }
+      case 'd': {
+        char buf[24];
+        int n = snprintf(buf, sizeof buf, "%d", va_arg(ap, int));
+        mrb_str_cat(mrb, s, buf, (size_t)n);
+        break;
+      }
+      default: mrb_str_cat(mrb, s, p, 1); break;
+    }
+  }
+  va_end(ap);
+  return s;
+}
+
+/* ---- the one exception the engine raises ---- */
+
+/* Issue #781: the program installs a handler at startup that raises its
+   RegexpError (sp_raise_cls is per translation unit, so the library reaches
+   it through this pointer); it does not return. Without one the message is
+   printed and the process exits, as it was. */
+static void (*sp_re_error_handler)(const char *msg) = NULL;
+void sp_re_set_error_handler(void (*fn)(const char *msg)) {
+  sp_re_error_handler = fn;
+}
+
+static RE_TLS char re_errbuf[1024];
+
+static __attribute__((noreturn)) void re_raise_msg(const char *msg, size_t len) {
+  if (len >= sizeof re_errbuf) len = sizeof re_errbuf - 1;
+  memcpy(re_errbuf, msg, len);
+  re_errbuf[len] = 0;
+  re_strs_release();   /* the message is copied out: nothing reads the list now */
+  if (sp_re_error_handler) sp_re_error_handler(re_errbuf);
+  fprintf(stderr, "RegexpError: %s\n", re_errbuf);
+  exit(1);
+}
+
+struct RClass *mrb_exc_get_id(mrb_state *mrb, mrb_sym name) {
+  (void)mrb; (void)name;
+  return NULL;
+}
+mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass *c, mrb_value str) {
+  (void)mrb; (void)c;
+  return str;
+}
+void mrb_exc_raise(mrb_state *mrb, mrb_value exc) {
+  (void)mrb;
+  re_raise_msg(exc ? exc->ptr : "invalid pattern", exc ? (size_t)exc->len : 15);
+}
+
+/* A compile error quotes the pattern as Regexp#inspect would, `/src/flags`.
+   Ruby's `m` is RE_FLAG_DOTALL to spinel, which is the bit spinel passes. */
+void mrb_re_flags_cat(mrb_state *mrb, mrb_value str, uint32_t flags) {
+  if (flags & RE_FLAG_DOTALL)     mrb_str_cat(mrb, str, "m", 1);
+  if (flags & RE_FLAG_IGNORECASE) mrb_str_cat(mrb, str, "i", 1);
+  if (flags & RE_FLAG_EXTENDED)   mrb_str_cat(mrb, str, "x", 1);
+}
+
+/* ---- UTF-8 ---- */
+
+#include "re_spinel_utf8.inc"
+
+int re_utf8_charlen(const char *s, const char *end) {
+  return (int)mrb_re_charlen(s, end, FALSE);
+}
+
+/* ---- spinel's surface ---- */
+
+/* The engine's pattern and the text it was compiled from. The pattern is the
+   first member, so a pattern pointer is the record's. */
+typedef struct {
+  mrb_regexp_pattern pat;
+  char *source;
+  uint32_t source_len;
+  /* the group names as C strings: the engine keeps each as a pointer and a
+     length into one arena, with nothing between them, and spinel's side
+     reads a name up to its NUL */
+  char **names;
+} sp_re_record;
+
+mrb_regexp_pattern *re_compile(const char *pattern, mrb_int len, uint32_t flags) {
+  sp_re_record *r = (sp_re_record *)mrb_calloc(NULL, 1, sizeof *r);
+  r->source = (char *)mrb_malloc(NULL, (size_t)len + 1);
+  memcpy(r->source, pattern, (size_t)len);
+  r->source[len] = 0;
+  r->source_len = (uint32_t)len;
+  mrb_re_compile(&re_mrb, &r->pat, pattern, len, flags, FALSE);
+  re_strs_release();
+  if (r->pat.num_named) {
+    r->names = (char **)mrb_calloc(NULL, r->pat.num_named, sizeof(char *));
+    for (uint16_t i = 0; i < r->pat.num_named; i++) {
+      const re_named_capture *nc = &r->pat.named_captures[i];
+      r->names[i] = (char *)mrb_malloc(NULL, (size_t)nc->name_len + 1);
+      memcpy(r->names[i], nc->name, nc->name_len);
+      r->names[i][nc->name_len] = 0;
+    }
+  }
+  return &r->pat;
+}
+
+void re_free(mrb_regexp_pattern *pat) {
+  if (!pat) return;
+  sp_re_record *r = (sp_re_record *)pat;
+  free(r->source);
+  if (r->names) {
+    for (uint16_t i = 0; i < pat->num_named; i++) free(r->names[i]);
+    free(r->names);
+  }
+  /* mrb_re_free() releases the pattern block too, which is the record */
+  mrb_re_free(&re_mrb, pat);
+}
+
+/* A search that stops at one of the engine's limits has no answer to give:
+   what it found by then is neither a shorter nor a later match. mruby raises
+   RegexpError there, and so does this; the engine used to answer no match. */
+int re_exec(const mrb_regexp_pattern *pat, const char *str, mrb_int len, mrb_int start,
+            int *captures, int captures_size, int binary) {
+  int n = mrb_re_exec(&re_mrb, pat, str, len, start, captures, captures_size, (mrb_bool)(binary != 0));
+  if (n >= 0) return n;
+  if (n == RE_NOMEM) re_nomem();
+  const char *m = n == RE_OVER_STEP_LIMIT ? "step limit over (MRB_REGEXP_STEP_LIMIT)"
+                                           : "stack limit over (MRB_REGEXP_STACK_LIMIT)";
+  re_raise_msg(m, strlen(m));
+}
+
+/* ---- named captures ---- */
+
+int re_num_named(const mrb_regexp_pattern *pat) {
+  return pat ? (int)pat->num_named : 0;
+}
+const char *re_named_name(const mrb_regexp_pattern *pat, int i, int *group_out) {
+  if (!pat || i < 0 || i >= (int)pat->num_named) return NULL;
+  if (group_out) *group_out = (int)pat->named_captures[i].group;
+  return ((const sp_re_record *)pat)->names[i];
+}
+/* group index -> its name (NUL-terminated copy in a static rotating buffer),
+   or NULL when the group is positional. For MatchData#inspect. */
+const char *re_group_name(const mrb_regexp_pattern *pat, int group) {
+  static RE_TLS char buf[4][64];
+  static RE_TLS int rot = 0;
+  if (!pat) return NULL;
+  for (int k = 0; k < pat->num_named; k++) {
+    if (pat->named_captures[k].group == group) {
+      size_t n = pat->named_captures[k].name_len;
+      if (n > 63) n = 63;
+      char *o = buf[rot = (rot + 1) & 3];
+      memcpy(o, pat->named_captures[k].name, n);
+      o[n] = 0;
+      return o;
+    }
+  }
+  return NULL;
+}
+/* A name may repeat across alternation branches; CRuby resolves to the last
+   declared group, so keep scanning and take the final match. */
+int re_named_group(const mrb_regexp_pattern *pat, const char *name) {
+  if (!pat || !name) return -1;
+  size_t nlen = strlen(name);
+  int group = -1;
+  for (uint16_t i = 0; i < pat->num_named; i++) {
+    const re_named_capture *nc = &pat->named_captures[i];
+    if (nc->name_len == nlen && memcmp(nc->name, name, nlen) == 0)
+      group = (int)nc->group;
+  }
+  return group;
+}
+
+/* ---- Regexp's readers ---- */
+
+const char *sp_re_source(void *vpat) {
+  sp_re_record *r = (sp_re_record *)vpat;
+  return (r && r->source) ? r->source : "";
+}
+/* ...and its byte length: the text may hold a NUL, which a strlen stops at */
+uint32_t sp_re_source_len(void *vpat) {
+  sp_re_record *r = (sp_re_record *)vpat;
+  return (r && r->source) ? r->source_len : 0;
+}
+/* Regexp#options: CRuby's public option bits IGNORECASE=1, EXTENDED=2,
+   MULTILINE=4 (the /m "dot matches newline", RE_FLAG_DOTALL here). Returns
+   the runtime's sp_int (intptr_t), as sp_re.h declares it. */
+intptr_t sp_re_options(void *vpat) {
+  mrb_regexp_pattern *pat = (mrb_regexp_pattern *)vpat;
+  uint32_t f = pat ? pat->flags : 0;
+  intptr_t o = 0;
+  if (f & RE_FLAG_IGNORECASE) o |= 1;
+  if (f & RE_FLAG_EXTENDED)   o |= 2;
+  if (f & RE_FLAG_DOTALL)     o |= 4;
+  return o;
+}
+/* Regexp#== / #eql? is source AND options: /ab/ and /ab/i differ (#3631).
+   Declared sp_bool (a C bool) by the runtime. */
+bool sp_re_eq(void *a, void *b) {
+  if (a == b) return 1;
+  if (!a || !b) return 0;
+  uint32_t la = sp_re_source_len(a), lb = sp_re_source_len(b);
+  return la == lb && memcmp(sp_re_source(a), sp_re_source(b), la) == 0 &&
+         sp_re_options(a) == sp_re_options(b);
+}
+bool sp_re_casefold_p(void *vpat) {
+  mrb_regexp_pattern *pat = (mrb_regexp_pattern *)vpat;
+  return (pat && (pat->flags & RE_FLAG_IGNORECASE)) ? true : false;
+}
+/* The engine's own flag word, for re-compiling a copy (Regexp.new(re)) with
+   the source pattern's exact options. */
+uint32_t sp_re_raw_flags(void *vpat) {
+  mrb_regexp_pattern *pat = (mrb_regexp_pattern *)vpat;
+  return pat ? pat->flags : 0;
+}
+/* The public Regexp option bits Regexp.new's second argument carries, as the
+   flag bits re_compile takes (#3055). */
+uint32_t sp_re_opts_to_flags(intptr_t o) {
+  uint32_t f = 0;
+  if (o & 1) f |= RE_FLAG_IGNORECASE;
+  if (o & 2) f |= RE_FLAG_EXTENDED;
+  if (o & 4) f |= RE_FLAG_DOTALL;   /* Ruby MULTILINE == "dot matches newline" */
+  return f;
+}

data/ext/qr_reader_native/re_spinel.h

@@ -0,0 +1,22 @@
+/*
+** re_spinel.h - spinel's surface of the regexp engine (re_spinel.c)
+**
+** The engine's own header, re_internal.h, is mruby-regexp's; the calls spinel
+** makes into the engine are these. lib/sp_re.h and the strscan package name
+** them again for the runtime, which does not include the engine's headers.
+*/
+#ifndef SP_RE_SPINEL_H
+#define SP_RE_SPINEL_H
+#include "re_internal.h"
+
+mrb_regexp_pattern *re_compile(const char *pattern, mrb_int len, uint32_t flags);
+void re_free(mrb_regexp_pattern *pat);
+int re_exec(const mrb_regexp_pattern *pat, const char *str, mrb_int len, mrb_int start,
+            int *captures, int captures_size, int binary);
+void sp_re_set_error_handler(void (*fn)(const char *msg));
+int re_utf8_charlen(const char *s, const char *end);
+int re_num_named(const mrb_regexp_pattern *pat);
+const char *re_named_name(const mrb_regexp_pattern *pat, int i, int *group_out);
+const char *re_group_name(const mrb_regexp_pattern *pat, int group);
+int re_named_group(const mrb_regexp_pattern *pat, const char *name);
+#endif

data/ext/qr_reader_native/re_spinel_utf8.inc

@@ -0,0 +1,97 @@
+/* re_spinel_utf8.inc - mruby's src/string.c UTF-8 readers the engine calls, as
+   mruby spells them (included by re_spinel.c) */
+mrb_int
+mrb_utf8_to_buf(char *buf, mrb_int cp)
+{
+  if (cp < 0) {
+    return 0;
+  }
+  else if (cp < 0x80) {
+    buf[0] = (char)cp;
+    return 1;
+  }
+  else if (cp < 0x800) {
+    buf[0] = (char)(0xC0 | (cp >> 6));
+    buf[1] = (char)(0x80 | (cp & 0x3F));
+    return 2;
+  }
+  else if (cp < 0x10000) {
+    buf[0] = (char)(0xE0 | (cp >> 12));
+    buf[1] = (char)(0x80 | ((cp >> 6) & 0x3F));
+    buf[2] = (char)(0x80 | (cp & 0x3F));
+    return 3;
+  }
+  else if (cp <= 0x10FFFF) {
+    buf[0] = (char)(0xF0 | (cp >> 18));
+    buf[1] = (char)(0x80 | ((cp >> 12) & 0x3F));
+    buf[2] = (char)(0x80 | ((cp >> 6) & 0x3F));
+    buf[3] = (char)(0x80 | (cp & 0x3F));
+    return 4;
+  }
+  return 0;  /* above U+10FFFF */
+}
+
+#define utf8_islead(c) ((unsigned char)((c)&0xc0) != 0x80)
+
+/* What a lead byte's second byte may be for the sequence to spell a
+   character under RFC 3629 (Unicode D93b), one pair per lead byte from
+   0xC0: the floor of each length (0xE0 A0, 0xF0 90; 0xC0 and 0xC1 have
+   nothing to spell), the UTF-16 surrogates (0xED up to 9F), U+10FFFF
+   (0xF4 up to 8F), and nothing at all for 0xF5 and above. This is the one
+   view the scan keeps none of; unpack("U") in mruby-pack holds its own. */
+#define R(lo, hi) {0x##lo, 0x##hi}
+static const uint8_t utf8_rfc3629_bounds[64][2] = {
+  R(C0,BF), R(C0,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF),  /* C0..C7 */
+  R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF),  /* C8..CF */
+  R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF),  /* D0..D7 */
+  R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF),  /* D8..DF */
+  R(A0,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF),  /* E0..E7 */
+  R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,BF), R(80,9F), R(80,BF), R(80,BF),  /* E8..EF */
+  R(90,BF), R(80,BF), R(80,BF), R(80,BF), R(80,8F), R(80,7F), R(80,7F), R(80,7F),  /* F0..F7 */
+  R(80,7F), R(80,7F), R(80,7F), R(80,7F), R(80,7F), R(80,7F), R(80,7F), R(80,7F),  /* F8..FF */
+};
+#undef R
+
+mrb_int
+mrb_utf8len(const char* p, const char* e)
+{
+  mrb_int n = mrb_utf8_scan(p, e, NULL, utf8_rfc3629_bounds);
+  return n < 0 ? 1 : n;
+}
+
+/* The byte the character covering `p` starts at, or `p` itself when `p` is
+   already a character boundary. A continuation byte belongs to the character
+   that reaches it; one that no lead byte reaches belongs to none and stands as
+   a character of its own. Whether a lead byte reaches is mrb_utf8len()'s
+   answer, so the boundaries found here are the ones the character count is
+   taken over. Reading back three bytes covers it, since nothing longer than
+   four bytes spells a character. */
+const char*
+mrb_utf8_char_head(const char *beg, const char *p, const char *end)
+{
+  if (p >= end || utf8_islead(p[0])) return p;
+  for (mrb_int back = 1; back <= 3 && back <= p - beg; back++) {
+    const char *lead = p - back;
+    if (!utf8_islead(lead[0])) continue;  /* another continuation byte */
+    return mrb_utf8len(lead, end) > back ? lead : p;
+  }
+  return p;
+}
+
+/* Decode a UTF-8 character and return its codepoint.
+   *lenp is set to the byte length consumed. What mrb_utf8len() rejects is
+   rejected here by the same view, so those consume a single byte and come
+   back as the lead byte itself. */
+uint32_t
+mrb_utf8_decode(const char *p, const char *e, mrb_int *lenp)
+{
+  uint32_t uv;
+  mrb_int n = mrb_utf8_scan(p, e, &uv, utf8_rfc3629_bounds);
+
+  if (n < 0) {
+    *lenp = 1;
+    return (uint8_t)p[0];
+  }
+  *lenp = n;
+  return uv;
+}

data/ext/qr_reader_native/re_utf8.c

@@ -0,0 +1,156 @@
+/*
+** re_utf8.c - case folding, character types and word characters for regexp engine
+**
+** See Copyright Notice in mruby.h
+*/
+
+#include "re_internal.h"
+
+#ifdef RE_UNICODE_CTYPE
+
+#include "re_ctype.h"
+
+/* The table numbers its bits in the order re_internal.h names them, so that
+   an entry read off it is a re_ctype value as it stands. */
+mrb_static_assert(RE_CTYPE_TABLE_ALPHA == RE_CTYPE_ALPHA &&
+                  RE_CTYPE_TABLE_UPPER == RE_CTYPE_UPPER &&
+                  RE_CTYPE_TABLE_LOWER == RE_CTYPE_LOWER &&
+                  RE_CTYPE_TABLE_DIGIT == RE_CTYPE_DIGIT &&
+                  RE_CTYPE_TABLE_ALNUM == RE_CTYPE_ALNUM &&
+                  RE_CTYPE_TABLE_WORD  == RE_CTYPE_WORD &&
+                  RE_CTYPE_TABLE_PUNCT == RE_CTYPE_PUNCT &&
+                  RE_CTYPE_TABLE_SPACE == RE_CTYPE_SPACE &&
+                  RE_CTYPE_TABLE_BLANK == RE_CTYPE_BLANK &&
+                  RE_CTYPE_TABLE_GRAPH == RE_CTYPE_GRAPH &&
+                  RE_CTYPE_TABLE_PRINT == RE_CTYPE_PRINT &&
+                  RE_CTYPE_CNTRL >= (1 << RE_CTYPE_MASK_BITS),
+                  "re_ctype.h and re_internal.h number the types differently");
+
+/* The types of a codepoint above ASCII: the set of the run it falls in, which
+   is the last run starting at or below it, and cntrl from its range. */
+uint16_t
+mrb_re_ctype(uint32_t cp)
+{
+  if (cp < RE_CTYPE_MIN) return 0;
+  size_t lo = 0, hi = RE_CTYPE_RUN_COUNT;
+  while (hi - lo > 1) {
+    size_t mid = lo + (hi - lo) / 2;
+    if ((re_ctype_runs[mid] >> RE_CTYPE_MASK_BITS) <= cp) lo = mid;
+    else hi = mid;
+  }
+  uint16_t t = (uint16_t)(re_ctype_runs[lo] & ((1u << RE_CTYPE_MASK_BITS) - 1));
+  if (cp >= RE_CTYPE_CNTRL_LO && cp <= RE_CTYPE_CNTRL_HI) t |= RE_CTYPE_CNTRL;
+  return t;
+}
+
+/* Whether the brackets in a class admit a type: the pair says the type has a
+   bit of ctype_yes or lacks a bit of ctype_no, and the masks that an
+   intersection writes say it has every bit of ctype_all and none of
+   ctype_none. A class with no pair puts only the masks, which is what a
+   bracket read on its own never leaves it with. */
+static mrb_bool
+ctype_admits(const re_charclass *cc, uint16_t t)
+{
+  if ((cc->ctype_yes | cc->ctype_no) &&
+      !((t & cc->ctype_yes) || (~t & cc->ctype_no))) {
+    return FALSE;
+  }
+  return (t & cc->ctype_all) == cc->ctype_all && (t & cc->ctype_none) == 0;
+}
+
+/* Whether a class holds a codepoint above ASCII through the POSIX brackets in
+   it, once its ranges have said nothing: yes when the brackets admit the
+   codepoint's type, and failing that whatever utf8_any says. A byte, tagged
+   RE_CLASS_BYTE by the caller, has no type: it is in the class through a
+   negated bracket and not through a positive one.
+
+   Under /i a character is in the class when any character sharing its folding
+   is, so the question is put to every one of them, and to each as a whole:
+   the brackets are a conjunction once an intersection has been taken, and it
+   is one character having to answer all of it rather than a bracket at a time
+   finding a different character to answer. The ASCII ones are left out, since
+   what the class holds through an ASCII counterpart is in its ranges already;
+   see compile_charclass(). */
+mrb_bool
+mrb_re_class_ctype_match(const re_charclass *cc, uint32_t cp)
+{
+  if (cp & RE_CLASS_BYTE) return ctype_admits(cc, 0) || cc->utf8_any;
+  if (ctype_admits(cc, mrb_re_ctype(cp))) return TRUE;
+  if (cc->ctype_fold) {
+    uint32_t alt[MRB_UNI_MAX_UNFOLD];
+    int n = mrb_uni_case_unfold(cp, alt, MRB_UNI_MAX_UNFOLD);
+    for (int i = 0; i < n; i++) {
+      if (alt[i] < 128) continue;
+      if (ctype_admits(cc, mrb_re_ctype(alt[i]))) return TRUE;
+    }
+  }
+  return cc->utf8_any;
+}
+
+uint32_t
+mrb_re_ctype_span(const re_charclass *cc, uint32_t lo, uint32_t hi, mrb_bool *in)
+{
+  size_t i = 0, j = RE_CTYPE_RUN_COUNT;
+  while (j - i > 1) {
+    size_t mid = i + (j - i) / 2;
+    if ((re_ctype_runs[mid] >> RE_CTYPE_MASK_BITS) <= lo) i = mid;
+    else j = mid;
+  }
+  uint32_t end = i + 1 < RE_CTYPE_RUN_COUNT
+                   ? (re_ctype_runs[i + 1] >> RE_CTYPE_MASK_BITS) - 1 : 0x10ffff;
+  /* The control range is not a run of its own: mrb_re_ctype() lays it over
+     whatever runs it falls in, so it breaks a run the same way one does. */
+  if (lo < RE_CTYPE_CNTRL_LO) {
+    if (end >= RE_CTYPE_CNTRL_LO) end = RE_CTYPE_CNTRL_LO - 1;
+  }
+  else if (lo <= RE_CTYPE_CNTRL_HI) {
+    if (end > RE_CTYPE_CNTRL_HI) end = RE_CTYPE_CNTRL_HI;
+  }
+  if (end > hi) end = hi;
+  *in = mrb_re_class_ctype_match(cc, lo);
+  return end;
+}
+
+#endif  /* RE_UNICODE_CTYPE */
+
+/* Check if character is a "word" character (\w): [a-zA-Z0-9_] */
+mrb_bool
+mrb_re_is_word_char(uint32_t c)
+{
+  if (c >= 'a' && c <= 'z') return TRUE;
+  if (c >= 'A' && c <= 'Z') return TRUE;
+  if (c >= '0' && c <= '9') return TRUE;
+  if (c == '_') return TRUE;
+  return FALSE;
+}
+
+#ifndef RE_UNICODE_CASE
+
+#include "re_cased.h"
+
+mrb_bool
+mrb_re_needs_case_data(uint32_t lo, uint32_t hi)
+{
+  if (hi < RE_CASED_MIN || lo > RE_CASED_MAX) return FALSE;
+  for (size_t i = 0; i < RE_CASED_RANGE_COUNT; i++) {
+    if (lo <= re_cased_ranges[i][1] && re_cased_ranges[i][0] <= hi) return TRUE;
+  }
+  return FALSE;
+}
+
+#endif  /* !RE_UNICODE_CASE */
+
+uint32_t
+mrb_re_case_fold(uint32_t cp)
+{
+#ifdef RE_UNICODE_CASE
+  return mrb_uni_case_fold(cp);
+#else
+  /* Without the option there is no table to walk, and the compiler reaches
+     the same two foldings directly, since there are only two. */
+  if (cp < 128) return (cp >= 'A' && cp <= 'Z') ? cp + 32 : cp;
+  if (cp == RE_FOLD_LONG_S) return 's';
+  if (cp == RE_FOLD_KELVIN) return 'k';
+  return cp;
+#endif
+}