yeptris 0.6.22.1 → 0.6.24.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b02278afda0c454592a7e6b4d95fb4649960c08a4b7e3ad7e5260467333edc57
-  data.tar.gz: c554fd944064c8b691003b83d9e3a6adc8500a04865dcf6c4fa28db1ba320db5
+  metadata.gz: 5e37c8d5060f33c0a23b4ecf7fb540f811f8f540c1a942c09b26e57c10f7f138
+  data.tar.gz: a4574d33636fec838f1ceb5c06724507a496b4a41a16e7d9a764adb35f6d8fc6
 SHA512:
-  metadata.gz: 7a1ed5aae840b006a5e2bb6ed27d8a1292969cb14b7963be92bd625f8ac0957ae974de91f73f11f8f642375eda5f773b747c21ee51479473742f7ff323f3b72a
-  data.tar.gz: c21b92bec887dce27696762deb7818d30243647775e6113d6ccd4a2d07c759153be042f66f764c962afab3092bb30faacf265c51a1ccb5812ff07c89c8f918a4
+  metadata.gz: 5a3f7b3a97b1c38801e8ae382755f1795928905bcd85cca4d77f40724c94399792b14c8882388b034f120d027f4cdd1ee8eccdea3a40e0198fc9327bffb2fe47
+  data.tar.gz: 5e75a67767f990861d1343ddd05c6e0599e122fe8954c138ecafd9905ed017db28838a80dc05546e9d8bbb0f87ae95857a392fa04844a0721bc7ed5433e27a0f

data/lib/yeptris/document.rb

@@ -17,6 +17,16 @@ class Yeptris::Document
   attr_reader :parse_schema
 
   def initialize(c_ptr = nil, freed = Freed.new(:alive), parse_schema = :core_12)
+    # The pointer is produced by the FFI parse/create calls; a nil (or
+    # non-pointer) argument is an API misuse — Document.parse and
+    # Document.create are the entry points. Fail with that guidance
+    # instead of a NoMethodError from the finalizer guard below (the
+    # FFI::Pointer#null? probe does not exist on nil).
+    unless c_ptr.is_a?(::FFI::Pointer)
+      raise ArgumentError,
+            "a document FFI pointer is required — build documents with " \
+            "Yeptris::Document.parse or Yeptris::Document.create"
+    end
     @c_ptr = c_ptr
     @freed = freed
     @parse_schema = parse_schema

data/lib/yeptris.rb

@@ -3,7 +3,7 @@
 module Yeptris
   # The gem's version lives in the parent namespace's file — the last
   # internal require (yeptris/version) retired with it.
-  VERSION = "0.6.22.1".freeze
+  VERSION = "0.6.24.1".freeze
 
   # Informational notices are OPT-IN (yeptris-ruby#217): consumers
   # embed yeptris inside CLIs that assert clean stderr, and a

data/vendor/libyeptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(yeptris
-    VERSION 0.6.22
+    VERSION 0.6.25
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

data/vendor/libyeptris/src/yeptris/emit/style.c

@@ -28,8 +28,13 @@ int yep_style_plain_safe(const char* p, uint32_t len) {
     case '-':
     case '?':
         /* indicators only before a blank or EOL: "-5" and "?x" are
-         * plain (libyaml emits negative numbers plain; Psych, too) */
-        return !(len == 1 || is_blank(p[1]));
+         * plain (libyaml emits negative numbers plain; Psych, too) —
+         * but fall through: the document-marker check below owns
+         * the bare "---"/"..." (libyaml quotes those) */
+        if (len == 1 || is_blank(p[1])) {
+            return 0;
+        }
+        break;
     case ',':
     case '[':
     case ']':
@@ -50,20 +55,67 @@ int yep_style_plain_safe(const char* p, uint32_t len) {
     default:
         break;
     }
-    for (uint32_t i = 0; i < len; i++) {
-        char c = p[i];
-        if (is_break(c) || c == '\t') {
-            return 0;
-        }
-        if (c == ':') {
-            if (i + 1 >= len || is_blank(p[i + 1])) {
+    /* The interior scan in SWAR words: every reject condition is a
+     * byte-class adjacency, so one masked word test is exact —
+     * break/tab bytes reject directly; ':' rejects with a blank at its
+     * NEXT lane (or the span's EOL); '#' with a blank at its PREVIOUS
+     * lane (the span's first byte is exempt — the head switch already
+     * handled a leading '#'). Cross-word adjacency rides one carried
+     * byte per boundary; the tail runs the byte loop, whose rules read
+     * real neighbors and need no carries. */
+    {
+        const uint64_t ONES = 0x0101010101010101ull;
+        const uint64_t HIGH = 0x8080808080808080ull;
+#define YST_ZDET(w, ch)                                                                            \
+    ((((w) ^ (uint64_t)(ch) * ONES) - ONES) & ~((w) ^ (uint64_t)(ch) * ONES) & HIGH)
+        uint32_t i = 0;
+        int prev_blank7 = 0;
+        while (i + 8 <= len) {
+            uint64_t w;
+            memcpy(&w, p + i, 8);
+            uint64_t space = YST_ZDET(w, ' ');
+            uint64_t tab = YST_ZDET(w, '\t');
+            uint64_t blank = space | tab;
+            uint64_t colon = YST_ZDET(w, ':');
+            uint64_t hash = YST_ZDET(w, '#');
+            /* tab and the breaks reject outright */
+            if (tab | YST_ZDET(w, '\n') | YST_ZDET(w, '\r')) {
                 return 0;
             }
+            /* ':' + blank next: (blank >> 8) pulls lane i+1's flag down
+             * into lane i; the word's last lane takes the peeked byte
+             * (EOL at the span end counts as blank — the rule rejects
+             * there) */
+            if (colon) {
+                int next_blank = i + 8 < len ? is_blank(p[i + 8]) : 1;
+                if (colon & ((blank >> 8) | (next_blank ? (uint64_t)0x80 << 56 : 0))) {
+                    return 0;
+                }
+            }
+            /* '#' + blank prev: (blank << 8) lifts lane i-1's flag up
+             * into lane i; lane 0 takes the carried last-lane flag */
+            if (hash && (hash & ((blank << 8) | (prev_blank7 ? 0x80 : 0)))) {
+                return 0;
+            }
+            prev_blank7 = (int)((blank >> 63) & 1); /* lane 7's flag is its top bit */
+            i += 8;
         }
-        if (c == '#') {
-            if (i > 0 && is_blank(p[i - 1])) {
+#undef YST_ZDET
+        for (; i < len; i++) {
+            char c = p[i];
+            if (is_break(c) || c == '\t') {
                 return 0;
             }
+            if (c == ':') {
+                if (i + 1 >= len || is_blank(p[i + 1])) {
+                    return 0;
+                }
+            }
+            if (c == '#') {
+                if (i > 0 && is_blank(p[i - 1])) {
+                    return 0;
+                }
+            }
         }
     }
     /* document markers */

data/vendor/libyeptris/src/yeptris/emit/style.h

@@ -10,6 +10,10 @@
 
 #include <stdint.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* A plain scalar may be re-emitted plain only when every byte is safe
  * in ANY position of a block context: no leading/trailing space, no
  * indicator first byte, no ": " / " #" inside, no tab, no break, and
@@ -21,4 +25,8 @@ int yep_style_plain_safe(const char* p, uint32_t len);
  * (plain_safe plus: no ':' at all unless followed by a non-blank). */
 int yep_style_plain_key_safe(const char* p, uint32_t len);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* YEP_EMIT_STYLE_H */

data/vendor/libyeptris/src/yeptris/events/recorder.c

@@ -52,6 +52,12 @@ YEPTRIS_API YeptrisStatus yeptris_recorder_feed(YeptrisRecorder rec, const char*
         }
         yep_engine_set_resolver(rec->eng,
                                 rec->compat11 ? yep_resolver_compat11() : yep_resolver_core12());
+        /* the compat schema is the psych/libyaml surface: its grammar
+         * must accept what libyaml accepts (the flow indent floor is
+         * suite-strict, not libyaml — see yep_engine_set_compat_grammar;
+         * the recorder is the py safe_load path, which rode the floor
+         * and rejected multi-line flows #431 fixed everywhere else) */
+        yep_engine_set_compat_grammar(rec->eng, rec->compat11);
     }
     if (final) {
         rec->final_fed = 1;

data/vendor/libyeptris/src/yeptris/events/values.c

@@ -389,6 +389,11 @@ int yep_values_from_input(const char* yaml, size_t len, int schema_compat, yep_v
         return -1;
     }
     yep_engine_set_resolver(eng, schema_compat ? yep_resolver_compat11() : yep_resolver_core12());
+    if (schema_compat) {
+        yep_engine_set_compat_grammar(eng, 1); /* libyaml grammar parity
+                                                * (the value drains ride the
+                                                * same compat contract) */
+    }
 
     yep_value_ctx* c = ctx_create();
     if (c == NULL) {

data/vendor/libyeptris/src/yeptris/parse/engine.c

@@ -124,6 +124,13 @@ struct yep_engine {
     int doc_inline;                      /* content node opened on the --- line */
     uint16_t flow_floor;                 /* parent column of the current block-level flow */
     int flow_enforce;                    /* flow continuation lines must out-indent it */
+    int compat_grammar;                  /* 11-COMPAT: libyaml/psych grammar parity —
+                                          * the flow indent floor (9C9N/VJP3) is a
+                                          * yaml-test-suite rule libyaml never
+                                          * enforced, and real-world locale files
+                                          * close multi-line flows at the parent's
+                                          * column; the floor stays on for the
+                                          * strict 1.2 engine the suite runs */
 };
 
 /* ------------------------------------------------------------ forwards */
@@ -2308,7 +2315,7 @@ static int e_shape_flow_value(yep_engine* e, const yep_line_shape* sh, uint16_t
     yep_view none = {NULL, 0};
     e->pos = sh->val_start;
     e->flow_floor = floor;
-    e->flow_enforce = (e->depth > 0);
+    e->flow_enforce = (e->depth > 0) && !e->compat_grammar;
     int fast = e_flow_json(e, none, none, 0);
     e->flow_enforce = 0;
     if (fast == -2) {
@@ -2457,13 +2464,12 @@ static int e_classified(yep_engine* e, uint16_t floor_col) {
     }
     /* Whole-line fast path (TODO.restructure/54): the sink may build
      * the key and its classified value as one unit — no events. The
-     * value EVENT is prepared first (folded content, resolved alias,
-     * defined anchor: exactly what the chain below would emit), so a
-     * rejection emits key + prepared value unchanged. */
-    yep_event vv;
-    e_event_init(&vv, YEP_EV_SCALAR);
-    vv.line = e->line;
-    vv.col = e_col(e, sh->val_start) + 1;
+     * value EVENT is assembled ONLY on the fallback path (the sinks
+     * that take the pair read the yep_block_value and ignore it): the
+     * semantic helpers run unchanged (alias resolution, anchor
+     * definition, the fold), the fallback reuses the pair facts
+     * captured before the fold — e_plain_multiline advances
+     * line/pos across continuations, so post-fold e_col would lie. */
     /* the pair facts are captured BEFORE the fold: e_plain_multiline
      * advances line/pos across continuations */
     uint32_t pair_line = e->line;
@@ -2471,6 +2477,18 @@ static int e_classified(yep_engine* e, uint16_t floor_col) {
     yep_block_value v;
     memset(&v, 0, sizeof(v));
     v.cls = (uint8_t)sh->val;
+    yep_event vv; /* the fields the fallback reads are assigned HERE and
+                   * overwritten by the arms/helpers — MSVC C4701 cannot
+                   * see through the helpers' bypointer writes, so the
+                   * zero-init lives in this function, not a memset */
+    vv.value.p = NULL;
+    vv.value.len = 0;
+    vv.borrowed = 0;
+    vv.anchor.p = NULL;
+    vv.anchor.len = 0;
+    vv.anchor_id = 0;
+    vv.end_line = 0;
+    vv.end_col = 0;
     int prepared = 0;
     if (sh->val == YEP_LVAL_ALIAS) {
         e->pos = sh->val_start;
@@ -2497,8 +2515,6 @@ static int e_classified(yep_engine* e, uint16_t floor_col) {
         vv.value.p = e->p + sh->val_span.start;
         vv.value.len = sh->val_span.end - sh->val_span.start;
         vv.borrowed = 1;
-        vv.style = YEP_STYLE_PLAIN;
-        vv.implicit = 1;
         e->pos = sh->val_span.end;
         if (e_plain_multiline(e, sh->val_span, key_col, &vv, 0) != 0) {
             return -1;
@@ -2523,9 +2539,30 @@ static int e_classified(yep_engine* e, uint16_t floor_col) {
                 return 1;
             }
         }
+        /* Fallback: assemble the value event with the helper-filled
+         * fields preserved — e_alias stamps type=ALIAS + the end marks,
+         * e_plain_multiline stamps the fold end marks; the pair facts
+         * taken pre-fold (post-fold e_col would read the advanced
+         * line/pos). Field-for-field what the pre-fill built. */
+        yep_event ve;
+        e_event_init(&ve, YEP_EV_SCALAR);
+        ve.line = pair_line;
+        ve.col = (uint32_t)pair_val_col + 1;
+        ve.value = vv.value;
+        ve.borrowed = vv.borrowed;
+        ve.anchor = vv.anchor;
+        ve.anchor_id = vv.anchor_id;
+        ve.end_line = vv.end_line;
+        ve.end_col = vv.end_col;
+        if (sh->val == YEP_LVAL_ALIAS) {
+            ve.type = YEP_EV_ALIAS;
+        } else {
+            ve.style = YEP_STYLE_PLAIN;
+            ve.implicit = 1;
+        }
         yep_event kv;
         e_key_event(e, sh, key_col, pair_line, &kv);
-        if (emit_now(e, &kv) != 0 || emit_now(e, &vv) != 0) {
+        if (emit_now(e, &kv) != 0 || emit_now(e, &ve) != 0) {
             return -2;
         }
         return 1;
@@ -2705,7 +2742,7 @@ static int e_node(yep_engine* e, yep_ctx ctx, uint16_t floor_col) {
             /* JSON fast path first: its validating scan already finds the
              * close, replacing e_skip_flow's pre-scan when it applies. */
             e->flow_floor = floor_col;
-            e->flow_enforce = (e->depth > 0);
+            e->flow_enforce = (e->depth > 0) && !e->compat_grammar;
             int fast = e_flow_json(e, node_a, node_t, anchor_ordinal);
             e->flow_enforce = 0;
             if (fast == 1) {
@@ -2750,7 +2787,7 @@ static int e_node(yep_engine* e, yep_ctx ctx, uint16_t floor_col) {
         }
         {
             e->flow_floor = floor_col;
-            e->flow_enforce = (e->depth > 0);
+            e->flow_enforce = (e->depth > 0) && !e->compat_grammar;
             int rc = e_flow(e, node_a, node_t, node_aid);
             e->flow_enforce = 0;
             if (rc != 0) {
@@ -3082,6 +3119,12 @@ void yep_engine_set_resolver(yep_engine* e, const yep_resolver* r) {
     }
 }
 
+void yep_engine_set_compat_grammar(yep_engine* e, int on) {
+    if (e != NULL) {
+        e->compat_grammar = on != 0;
+    }
+}
+
 void yep_engine_set_max_depth(yep_engine* e, int depth) {
     if (e != NULL && depth > 0) {
         e->max_depth = depth > YEP_MAX_DEPTH ? YEP_MAX_DEPTH : depth;

data/vendor/libyeptris/src/yeptris/parse/engine.h

@@ -52,6 +52,13 @@ struct yep_resolver;
 void yep_engine_set_resolver(yep_engine* e, const struct yep_resolver* r);
 void yep_engine_set_max_depth(yep_engine* e, int depth);
 
+/* The 1.1-compat grammar (libyaml/psych parity): the block-level flow
+ * indent floor (9C9N, VJP3) is a yaml-test-suite rule libyaml never
+ * enforced — real-world locale files close multi-line flow collections
+ * at their parent's column ("k: {\n  a: b\n}"). Off by default (the
+ * strict 1.2 engine the conformance suite runs keeps the floor). */
+void yep_engine_set_compat_grammar(yep_engine* e, int on);
+
 /* Byte offset the last run reached (into that run's buffer); used by
  * consumers that stop the engine at a boundary and resume. */
 size_t yep_engine_pos(const yep_engine* e);

data/vendor/libyeptris/src/yeptris/parse.c

@@ -301,6 +301,12 @@ engine_enter:
         yep_engine_set_resolver(eng, opts->schema == YEPTRIS_SCHEMA_11_COMPAT
                                          ? yep_resolver_compat11()
                                          : yep_resolver_core12());
+        if (opts->schema == YEPTRIS_SCHEMA_11_COMPAT) {
+            /* the compat schema is the psych/libyaml surface: its grammar
+             * must accept what libyaml accepts (the flow floor is suite-
+             * strict, not libyaml — see yep_engine_set_compat_grammar) */
+            yep_engine_set_compat_grammar(eng, 1);
+        }
         if (opts->max_depth > 0) {
             yep_engine_set_max_depth(eng, opts->max_depth);
         }

data/vendor/libyeptris/src/yeptris/tape.c

@@ -601,6 +601,36 @@ reject:
  * (the classify scan carries no accept/reject structure) and
  * yeptris_tape_convert owns validation. Everything else matches
  * tape_walk state for state. */
+/* LNUM_RUN — the initial digit run of a number span: SWAR words, eight
+ * bytes per pass, with the byte loop below as tail and classifier.
+ * digit iff 0x30-0x39: a lane flags when (c+0x46) carries into bit7
+ * (c > '9'), when ((c|0x80)-0xB0) goes negative (c < '0'), or when the
+ * byte is non-ASCII — and since the all-digit prefix never borrows
+ * across lanes, the flags are exact up to the first non-digit, where
+ * the scan stops and the byte loop classifies what follows (the
+ * consumed-only digits_only law is untouched: the run sets saw_digit,
+ * nothing else). */
+#define LNUM_RUN                                                                                   \
+    do {                                                                                           \
+        size_t ks_ = k;                                                                            \
+        while (k + 8 <= len) {                                                                     \
+            uint64_t w_;                                                                           \
+            memcpy(&w_, p + k, 8);                                                                 \
+            uint64_t nd_ =                                                                         \
+                ((w_ + 0x4646464646464646ull) & 0x8080808080808080ull) |                           \
+                (((w_ | 0x8080808080808080ull) - 0xB0B0B0B0B0B0B0B0ull) & 0x8080808080808080ull) | \
+                (w_ & 0x8080808080808080ull);                                                      \
+            if (nd_ != 0) {                                                                        \
+                k += (size_t)yep_ctz64(nd_) >> 3;                                                  \
+                break;                                                                             \
+            }                                                                                      \
+            k += 8;                                                                                \
+        }                                                                                          \
+        if (k > ks_) {                                                                             \
+            saw_digit = 1;                                                                         \
+        }                                                                                          \
+    } while (0)
+
 /* The strict RFC 8259 number check over one number-ish run — the
  * in-walk float/exp validator (the out-of-line number_shape call +
  * rescan was 13% of json-doc; the digits-only case never gets here).
@@ -884,103 +914,132 @@ lmap1: /* {} closes here */
     goto lmapkey;
 
 lmap: /* a member MUST follow (after ','): JW_KEY — a closer rejects */
+    /* compact fast path: the byte is the key's quote already — LWS's
+     * loop would examine it once and exit */
+    if (i < len && p[i] == '"') {
+        goto lmapkey;
+    }
     LWS();
     if (p[i] != '"') {
         goto lreject;
     }
 lmapkey: { LSTR_SCAN(lmapcolon); }
 lmapcolon:
+    if (i < len && p[i] == ':') {
+        i++;
+        /* compact fast path: the value byte follows the colon with no
+         * whitespace — one load dispatches it (the ws test below is
+         * what LWS would run anyway) */
+        if (i < len) {
+            char v = p[i];
+            if (v != ' ' && v != '\n' && v != '\r' && (cl || v != '\t')) {
+                goto lmapval;
+            }
+        }
+        LWS();
+        goto lmapval;
+    }
     LWS();
     if (p[i] != ':') {
         goto lreject;
     }
     i++;
     LWS();
-    {
-        char c = p[i];
-        if (c == '"') {
-            LSTR_SCAN(lmapafter);
-        }
-        if ((unsigned)(c - '0') <= 9u || c == '-') {
-            size_t k = i + 1;
-            /* the digits-only tracking makes the pure-integer case a
-             * 3-cycle leading-zero check — number_shape (a call + a
-             * rescan, 13% of json-doc) runs only for dot/exp spans */
-            int digits_only = 1, saw_digit = (c != '-');
-            while (k < len) {
-                char d = p[k];
-                if ((unsigned)(d - '0') <= 9u) {
-                    k++;
-                    saw_digit = 1;
-                    continue;
-                }
-                /* the flag clears only on a CONSUMED byte: the run's
-                 * terminator (',', '}', ']', whitespace) must leave
-                 * digits_only intact, or every plain integer followed
-                 * by a delimiter falls into the full validator */
-                if (d == '-' || d == '+' || d == '.' || d == 'e' || d == 'E') {
-                    digits_only = 0;
-                    k++;
-                    continue;
-                }
-                break;
+lmapval: {
+    char c = p[i];
+    if (c == '"') {
+        LSTR_SCAN(lmapafter);
+    }
+    if ((unsigned)(c - '0') <= 9u || c == '-') {
+        size_t k = i + 1;
+        /* the digits-only tracking makes the pure-integer case a
+         * 3-cycle leading-zero check — number_shape (a call + a
+         * rescan, 13% of json-doc) runs only for dot/exp spans */
+        int digits_only = 1, saw_digit = (c != '-');
+        LNUM_RUN;
+        while (k < len) {
+            char d = p[k];
+            if ((unsigned)(d - '0') <= 9u) {
+                k++;
+                saw_digit = 1;
+                continue;
             }
-            if (strict_nums) {
-                int ok;
-                if (digits_only && saw_digit) {
-                    size_t d0 = (c == '-') ? i + 1 : i;
-                    ok = (k - d0 == 1) || p[d0] != '0';
-                } else {
-                    ok = tape_num_ok(p + i, (size_t)(k - i));
-                }
-                if (!ok) {
-                    goto lreject;
-                }
+            /* the flag clears only on a CONSUMED byte: the run's
+             * terminator (',', '}', ']', whitespace) must leave
+             * digits_only intact, or every plain integer followed
+             * by a delimiter falls into the full validator */
+            if (d == '-' || d == '+' || d == '.' || d == 'e' || d == 'E') {
+                digits_only = 0;
+                k++;
+                continue;
             }
-            recs[count] = ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)(k - i)) << 8) |
-                          (uint64_t)(YEP_T_NUM);
-            count++;
-            i = k;
-            goto lmapafter;
+            break;
         }
-        if (c == 't' || c == 'f' || c == 'n') {
-            size_t wl = c == 'f' ? 5 : 4;
-            if (i + wl > len) {
-                goto lreject;
+        if (strict_nums) {
+            int ok;
+            if (digits_only && saw_digit) {
+                size_t d0 = (c == '-') ? i + 1 : i;
+                ok = (k - d0 == 1) || p[d0] != '0';
+            } else {
+                ok = tape_num_ok(p + i, (size_t)(k - i));
             }
-            uint32_t got4;
-            memcpy(&got4, p + i, 4);
-            if (got4 != (c == 't'   ? 0x65757274u /* "true" */
-                         : c == 'n' ? 0x6C6C756Eu /* "null" */
-                                    : 0x736C6166u /* "fals" */) ||
-                (c == 'f' && p[i + 4] != 'e')) {
+            if (!ok) {
                 goto lreject;
             }
-            if (i + wl < len) {
-                char z = p[i + wl];
-                if (z != ' ' && z != '\t' && z != '\n' && z != '\r' && z != ',' && z != ']' &&
-                    z != '}' && z != ':') {
-                    goto lreject;
-                }
-            }
-            recs[count] = ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)wl) << 8) |
-                          (uint64_t)(c == 'n' ? YEP_T_NULL : (c == 't' ? YEP_T_TRUE : YEP_T_FALSE));
-            count++;
-            i += wl;
-            goto lmapafter;
         }
-        if (c == '{') {
-            LPUSH(1);
-            goto lmap1;
+        recs[count] = ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)(k - i)) << 8) |
+                      (uint64_t)(YEP_T_NUM);
+        count++;
+        i = k;
+        goto lmapafter;
+    }
+    if (c == 't' || c == 'f' || c == 'n') {
+        size_t wl = c == 'f' ? 5 : 4;
+        if (i + wl > len) {
+            goto lreject;
         }
-        if (c == '[') {
-            LPUSH(0);
-            goto lseq1;
+        uint32_t got4;
+        memcpy(&got4, p + i, 4);
+        if (got4 != (c == 't'   ? 0x65757274u /* "true" */
+                     : c == 'n' ? 0x6C6C756Eu /* "null" */
+                                : 0x736C6166u /* "fals" */) ||
+            (c == 'f' && p[i + 4] != 'e')) {
+            goto lreject;
         }
-        goto lreject;
+        if (i + wl < len) {
+            char z = p[i + wl];
+            if (z != ' ' && z != '\t' && z != '\n' && z != '\r' && z != ',' && z != ']' &&
+                z != '}' && z != ':') {
+                goto lreject;
+            }
+        }
+        recs[count] = ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)wl) << 8) |
+                      (uint64_t)(c == 'n' ? YEP_T_NULL : (c == 't' ? YEP_T_TRUE : YEP_T_FALSE));
+        count++;
+        i += wl;
+        goto lmapafter;
     }
+    if (c == '{') {
+        LPUSH(1);
+        goto lmap1;
+    }
+    if (c == '[') {
+        LPUSH(0);
+        goto lseq1;
+    }
+    goto lreject;
+}
 
 lmapafter:
+    /* compact fast path: value ',' key directly — the two LWS hops the
+     * general form runs both exit on byte one here */
+    if (i < len && p[i] == ',') {
+        i++;
+        if (i < len && p[i] == '"') {
+            goto lmapkey;
+        }
+        goto lmap;
+    }
     LWS();
     if (p[i] == ',') {
         i++;
@@ -1009,6 +1068,7 @@ lseqval: {
     if ((unsigned)(c - '0') <= 9u || c == '-') {
         size_t k = i + 1;
         int digits_only = 1, saw_digit = (c != '-');
+        LNUM_RUN;
         while (k < len) {
             char d = p[k];
             if ((unsigned)(d - '0') <= 9u) {
@@ -1080,6 +1140,18 @@ lseqval: {
 }
 
 lseqafter:
+    /* compact fast path: value ',' value directly — both LWS hops exit
+     * on byte one here */
+    if (i < len && p[i] == ',') {
+        i++;
+        if (i < len) {
+            char v = p[i];
+            if (v != ' ' && v != '\n' && v != '\r' && (cl || v != '\t')) {
+                goto lseqval;
+            }
+        }
+        goto lseq;
+    }
     LWS();
     if (p[i] == ',') {
         i++;
@@ -1092,6 +1164,7 @@ lseqafter:
 
 ldone:
 #undef LWS
+#undef LNUM_RUN
 #undef LPUSH
 #undef LCLOSE
 #undef LSTR_SCAN

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.22.1
+  version: 0.6.24.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-25 00:00:00.000000000 Z
+date: 2026-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi