qr_reader-native 0.0.1

data/ext/qr_reader_native/sp_dtoa.h

@@ -0,0 +1,29 @@
+/* sp_dtoa.h -- locale-independent float <-> string conversion.
+ *
+ * mruby's fp_uscale.c (Russ Cox's Unrounded Scaling; see
+ * https://research.swtch.com/fp), adapted for spinel. It is pure integer
+ * arithmetic and never touches libc's locale-sensitive snprintf/strtod, so a
+ * float always renders and parses with a `.` decimal point regardless of the
+ * process locale -- the invariant Ruby guarantees. */
+#ifndef SP_DTOA_H
+#define SP_DTOA_H
+
+#include "sp_types.h"
+
+/* Shortest-round-trip and printf-style float formatting into `buf` (NUL
+   terminated). fmt is one of 'e'/'f'/'g' (upper-case for E/upper output);
+   prec is the precision, or -2 for shortest round-trip ('g' only). sign is a
+   forced leading sign ('+'/' ') or '\0'. Returns the written length. */
+int sp_format_float(sp_float f, char *buf, size_t buf_size, char fmt, int prec, char sign);
+
+/* Parse a float prefix of `str` (leading space skipped). On success stores the
+   value in *fp, sets *endp past the consumed text, and returns TRUE. */
+sp_bool sp_read_float(const char *str, char **endp, double *fp);
+
+/* Shortest-round-trip significant digits of a finite non-zero f: writes the
+   NUL-terminated digits to `digs`, their count to *nd, and returns the base-10
+   exponent of the leading digit. The caller applies its own fixed/scientific
+   layout (Ruby's Float#to_s threshold is not %g's). */
+int sp_float_shortest(double f, char *digs, int *nd);
+
+#endif

data/ext/qr_reader_native/sp_encoding_names.h

@@ -0,0 +1,172 @@
+/* Encoding names and aliases, CRuby 4.0.7. Generated by tools/gen_encoding_names.rb. */
+  {"646", "US-ASCII"},
+  {"ANSI_X3.4-1968", "US-ASCII"},
+  {"ASCII", "US-ASCII"},
+  {"ASCII-8BIT", "ASCII-8BIT"},
+  {"BINARY", "ASCII-8BIT"},
+  {"Big5", "Big5"},
+  {"Big5-HKSCS", "Big5-HKSCS"},
+  {"Big5-HKSCS:2008", "Big5-HKSCS"},
+  {"Big5-UAO", "Big5-UAO"},
+  {"CESU-8", "CESU-8"},
+  {"CP1250", "Windows-1250"},
+  {"CP1251", "Windows-1251"},
+  {"CP1252", "Windows-1252"},
+  {"CP1253", "Windows-1253"},
+  {"CP1254", "Windows-1254"},
+  {"CP1255", "Windows-1255"},
+  {"CP1256", "Windows-1256"},
+  {"CP1257", "Windows-1257"},
+  {"CP1258", "Windows-1258"},
+  {"CP437", "IBM437"},
+  {"CP50220", "CP50220"},
+  {"CP50221", "CP50221"},
+  {"CP51932", "CP51932"},
+  {"CP65000", "UTF-7"},
+  {"CP65001", "UTF-8"},
+  {"CP720", "IBM720"},
+  {"CP737", "IBM737"},
+  {"CP775", "IBM775"},
+  {"CP850", "CP850"},
+  {"CP852", "CP852"},
+  {"CP855", "CP855"},
+  {"CP857", "IBM857"},
+  {"CP860", "IBM860"},
+  {"CP861", "IBM861"},
+  {"CP862", "IBM862"},
+  {"CP863", "IBM863"},
+  {"CP864", "IBM864"},
+  {"CP865", "IBM865"},
+  {"CP866", "IBM866"},
+  {"CP869", "IBM869"},
+  {"CP874", "Windows-874"},
+  {"CP878", "KOI8-R"},
+  {"CP932", "Windows-31J"},
+  {"CP936", "GBK"},
+  {"CP949", "CP949"},
+  {"CP950", "CP950"},
+  {"CP951", "CP951"},
+  {"EUC-CN", "GB2312"},
+  {"EUC-JIS-2004", "EUC-JIS-2004"},
+  {"EUC-JISX0213", "EUC-JIS-2004"},
+  {"EUC-JP", "EUC-JP"},
+  {"EUC-KR", "EUC-KR"},
+  {"EUC-TW", "EUC-TW"},
+  {"Emacs-Mule", "Emacs-Mule"},
+  {"GB12345", "GB12345"},
+  {"GB18030", "GB18030"},
+  {"GB1988", "GB1988"},
+  {"GB2312", "GB2312"},
+  {"GBK", "GBK"},
+  {"IBM037", "IBM037"},
+  {"IBM437", "IBM437"},
+  {"IBM720", "IBM720"},
+  {"IBM737", "IBM737"},
+  {"IBM775", "IBM775"},
+  {"IBM850", "CP850"},
+  {"IBM852", "IBM852"},
+  {"IBM855", "IBM855"},
+  {"IBM857", "IBM857"},
+  {"IBM860", "IBM860"},
+  {"IBM861", "IBM861"},
+  {"IBM862", "IBM862"},
+  {"IBM863", "IBM863"},
+  {"IBM864", "IBM864"},
+  {"IBM865", "IBM865"},
+  {"IBM866", "IBM866"},
+  {"IBM869", "IBM869"},
+  {"ISO-2022-JP", "ISO-2022-JP"},
+  {"ISO-2022-JP-2", "ISO-2022-JP-2"},
+  {"ISO-2022-JP-KDDI", "ISO-2022-JP-KDDI"},
+  {"ISO-8859-1", "ISO-8859-1"},
+  {"ISO-8859-10", "ISO-8859-10"},
+  {"ISO-8859-11", "ISO-8859-11"},
+  {"ISO-8859-13", "ISO-8859-13"},
+  {"ISO-8859-14", "ISO-8859-14"},
+  {"ISO-8859-15", "ISO-8859-15"},
+  {"ISO-8859-16", "ISO-8859-16"},
+  {"ISO-8859-2", "ISO-8859-2"},
+  {"ISO-8859-3", "ISO-8859-3"},
+  {"ISO-8859-4", "ISO-8859-4"},
+  {"ISO-8859-5", "ISO-8859-5"},
+  {"ISO-8859-6", "ISO-8859-6"},
+  {"ISO-8859-7", "ISO-8859-7"},
+  {"ISO-8859-8", "ISO-8859-8"},
+  {"ISO-8859-9", "ISO-8859-9"},
+  {"ISO2022-JP", "ISO-2022-JP"},
+  {"ISO2022-JP2", "ISO-2022-JP-2"},
+  {"ISO8859-1", "ISO-8859-1"},
+  {"ISO8859-10", "ISO-8859-10"},
+  {"ISO8859-11", "ISO-8859-11"},
+  {"ISO8859-13", "ISO-8859-13"},
+  {"ISO8859-14", "ISO-8859-14"},
+  {"ISO8859-15", "ISO-8859-15"},
+  {"ISO8859-16", "ISO-8859-16"},
+  {"ISO8859-2", "ISO-8859-2"},
+  {"ISO8859-3", "ISO-8859-3"},
+  {"ISO8859-4", "ISO-8859-4"},
+  {"ISO8859-5", "ISO-8859-5"},
+  {"ISO8859-6", "ISO-8859-6"},
+  {"ISO8859-7", "ISO-8859-7"},
+  {"ISO8859-8", "ISO-8859-8"},
+  {"ISO8859-9", "ISO-8859-9"},
+  {"KOI8-R", "KOI8-R"},
+  {"KOI8-U", "KOI8-U"},
+  {"MacJapan", "MacJapanese"},
+  {"MacJapanese", "MacJapanese"},
+  {"PCK", "Windows-31J"},
+  {"SJIS", "Windows-31J"},
+  {"SJIS-DoCoMo", "SJIS-DoCoMo"},
+  {"SJIS-KDDI", "SJIS-KDDI"},
+  {"SJIS-SoftBank", "SJIS-SoftBank"},
+  {"Shift_JIS", "Shift_JIS"},
+  {"TIS-620", "TIS-620"},
+  {"UCS-2BE", "UTF-16BE"},
+  {"UCS-4BE", "UTF-32BE"},
+  {"UCS-4LE", "UTF-32LE"},
+  {"US-ASCII", "US-ASCII"},
+  {"UTF-16", "UTF-16"},
+  {"UTF-16BE", "UTF-16BE"},
+  {"UTF-16LE", "UTF-16LE"},
+  {"UTF-32", "UTF-32"},
+  {"UTF-32BE", "UTF-32BE"},
+  {"UTF-32LE", "UTF-32LE"},
+  {"UTF-7", "UTF-7"},
+  {"UTF-8", "UTF-8"},
+  {"UTF-8-HFS", "UTF8-MAC"},
+  {"UTF-8-MAC", "UTF8-MAC"},
+  {"UTF8-DoCoMo", "UTF8-DoCoMo"},
+  {"UTF8-KDDI", "UTF8-KDDI"},
+  {"UTF8-MAC", "UTF8-MAC"},
+  {"UTF8-SoftBank", "UTF8-SoftBank"},
+  {"Windows-1250", "Windows-1250"},
+  {"Windows-1251", "Windows-1251"},
+  {"Windows-1252", "Windows-1252"},
+  {"Windows-1253", "Windows-1253"},
+  {"Windows-1254", "Windows-1254"},
+  {"Windows-1255", "Windows-1255"},
+  {"Windows-1256", "Windows-1256"},
+  {"Windows-1257", "Windows-1257"},
+  {"Windows-1258", "Windows-1258"},
+  {"Windows-31J", "Windows-31J"},
+  {"Windows-874", "Windows-874"},
+  {"csWindows31J", "Windows-31J"},
+  {"ebcdic-cp-us", "IBM037"},
+  {"euc-jp-ms", "eucJP-ms"},
+  {"eucCN", "GB2312"},
+  {"eucJP", "EUC-JP"},
+  {"eucJP-ms", "eucJP-ms"},
+  {"eucKR", "EUC-KR"},
+  {"eucTW", "EUC-TW"},
+  {"macCentEuro", "macCentEuro"},
+  {"macCroatian", "macCroatian"},
+  {"macCyrillic", "macCyrillic"},
+  {"macGreek", "macGreek"},
+  {"macIceland", "macIceland"},
+  {"macRoman", "macRoman"},
+  {"macRomania", "macRomania"},
+  {"macThai", "macThai"},
+  {"macTurkish", "macTurkish"},
+  {"macUkraine", "macUkraine"},
+  {"stateless-ISO-2022-JP", "stateless-ISO-2022-JP"},
+  {"stateless-ISO-2022-JP-KDDI", "stateless-ISO-2022-JP-KDDI"},

data/ext/qr_reader_native/sp_enum.h

@@ -0,0 +1,86 @@
+/* sp_enum.h -- the Enumerator handle (cursor/generator ops in lib/sp_cold.c).
+ *
+ * Two flavors: a materialized snapshot (items + cursor, from a collection's
+ * blockless #each) or a fiber-backed generator (Enumerator.new { |y| ... },
+ * where `y << v` is a Fiber.yield). The fiber is created lazily on first
+ * #next and re-created on #rewind. */
+#ifndef SP_ENUM_H
+#define SP_ENUM_H
+
+#include "sp_alloc.h"
+#include "sp_fiber.h"
+
+#define SP_PAIR_EACH   1
+#define SP_PAIR_PACKED 2
+
+/* The Array a generator step that yields several values packs them in: an
+   ordinary poly array, told apart by its scan function so a generator that
+   also yields single values (an Array among them) keeps each step's arity. */
+void sp_PolyArray_pack_scan(void *p);
+sp_PolyArray *sp_PolyArray_new_pack(void);
+static inline sp_bool sp_poly_is_pack(sp_RbVal v) {
+  return v.tag == SP_TAG_OBJ && v.cls_id == SP_BUILTIN_POLY_ARRAY && v.v.p &&
+         ((sp_gc_hdr *)((char *)v.v.p - sizeof(sp_gc_hdr)))->scan == sp_PolyArray_pack_scan;
+}
+
+/* A generator step that yields no value (`y.yield`, `y.yield(*[])`): nil to a
+   reader of the item, and no values to a `|*r|` block. The mark rides in the
+   nil's cls_id, which nothing else reads. */
+static inline sp_RbVal sp_box_empty_step(void) {
+  sp_RbVal r = sp_box_nil(); r.cls_id = 1; return r;
+}
+static inline sp_bool sp_poly_is_empty_step(sp_RbVal v) {
+  return v.tag == SP_TAG_NIL && v.cls_id == 1;
+}
+
+typedef struct {
+  sp_PolyArray *items; sp_int cursor;   /* materialized mode (items != NULL) */
+  void (*gen)(sp_Fiber *);                /* generator body (fiber mode, gen != NULL) */
+  void *gen_cap;                          /* captures, passed via fiber user_data */
+  sp_Fiber *fib;                          /* current generator fiber (lazy) */
+  sp_bool peeked; sp_RbVal peek_val;     /* #peek lookahead cache */
+  sp_RbVal size;                          /* #size for a generator: a value, a
+                                             callable (Proc), or nil. Unused by
+                                             the materialized path (items->len). */
+  sp_RbVal feed; sp_bool has_feed;       /* #feed: value returned by the next Fiber.yield */
+  sp_RbVal gen_result;                    /* generator body's return -> StopIteration#result */
+  sp_RbVal source;                        /* the iterated receiver -> materialized StopIteration#result */
+  sp_bool has_src;                       /* source is set, even to nil: `nil.then`'s receiver IS
+                                             nil, and #inspect must not read that as "no source"
+                                             and fall back to the items (sp_gc_alloc zero-fills) */
+  const char *meth;                       /* creating method name, for #inspect ("each", ...):
+                                             an SPL literal or a GC-traced heap label */
+  sp_bool gen_label;                     /* #inspect as a Generator wrapper (chunk_while & co.):
+                                             the items are an eager snapshot, but CRuby shows
+                                             #<Enumerator: #<Enumerator::Generator:0x..>:each> */
+  sp_bool frozen;                        /* Object#freeze observed (sp_gc_alloc zero-fills) */
+  sp_bool is_chain;                      /* built by Enumerable#chain / Enumerator#+: the items
+                                             are the concatenated sources, and #class reports
+                                             Enumerator::Chain (sp_gc_alloc zero-fills) */
+  sp_bool is_product;                    /* built by Enumerator.product / Enumerator::Product.new:
+                                             the items are the tuples, `source` the factors, and
+                                             #class reports Enumerator::Product (zero-filled) */
+  sp_bool endless;                       /* an argless #cycle: the items are one round, and
+                                             #next / #peek start over at their end, so the
+                                             enumerator never stops (sp_gc_alloc zero-fills) */
+  sp_bool is_bsearch;                    /* Array#bsearch enum_for: items are candidates,
+                                             with the block result steering the search */
+  sp_int bsearch_lo, bsearch_hi, bsearch_mid;
+  sp_bool bsearch_waiting;
+  sp_RbVal bsearch_result;
+  unsigned char yields_pair;             /* SP_PAIR_EACH: each item is the two values one step
+                                             yields (each_with_index, with_index,
+                                             each_with_object, with_object) packed as an Array,
+                                             which a block of map and its kin takes spread;
+                                             SP_PAIR_PACKED: only the items packed by a
+                                             generator step that yielded several values
+                                             (sp_PolyArray_new_pack) are (sp_gc_alloc
+                                             zero-fills) */
+  sp_PolyArray *walk_buf;                /* a walker (sp_enum_walker_boxed): the items pulled
+                                             so far by an index walk over a generator or
+                                             endless source, one at a time; NULL otherwise */
+  sp_int walk_next;                      /* the walk's next index: how far it has read */
+  sp_bool walk_done;                     /* the source has no more items */
+} sp_Enumerator;
+
+#endif