yeptris 0.6.21.1-arm-linux-eabihf → 0.6.23.1-arm-linux-eabihf

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f28d08ec5958231b1fe465347ed53ea2f03dc51d3012f49501c2b0b0c425439
-  data.tar.gz: afe0d37786ef93cbcfcae545b7095dc76668a9fae7ddd8f3099c3df6c9655178
+  metadata.gz: 627e70bedb0bd290674f8a94d08ad53c68e48cf60b5752783b6d8db3391921d3
+  data.tar.gz: 79403cdb0ce605fd4d79777291e02274afb041200f9f5b7d8972538442a29a31
 SHA512:
-  metadata.gz: a6d8196d4017395748fef1170e4d7dd3ee6a0c2dd3e246d17d170ddd5b1dfb7b40b272fbf5d0f459c47e6eefd0599c752b038b3db9adbd89e310f54662db06f9
-  data.tar.gz: 2e57246545fa63e30626aa16b2ea60b6da89b3fff8802de16e6d5dee38bd6df97297dff7e9f9c8cf6244bfb614e94bf40702316fc54664f3d9daaf2231d4b4c1
+  metadata.gz: 1512bd1736078082f3de2a1c07afc42c998ba53a5204fb2073a8c3f49510231c42deb96322cf92ac16764df6c24eeaa7b02fad5cfc0113bdefbd97beb039355a
+  data.tar.gz: 44c9e72d06b689ce1e18e4b2283421f99d20ee9b89a076a1e0439d91d0b0254cae04a819334c6b63a3ba49d686efe57eef39871dce52f36a36cfb5301c67fbf1

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.21.1".freeze
+  VERSION = "0.6.23.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.21
+    VERSION 0.6.23
     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/parse/engine.c

@@ -2457,13 +2457,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 +2470,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 +2508,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 +2532,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;

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

@@ -601,12 +601,49 @@ 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).
  * One pass, no state machine words: sign, digits (leading-zero rule),
- * optional .digits, optional e[+-]digits, consume exactly len. */
-static int tape_num_ok(const char* p, size_t len) {
+ * optional .digits, optional e[+-]digits, consume exactly len.
+ * always_inline: the spans are 3-8 bytes and the out-of-line call was
+ * the cost (the rescan itself is nothing). */
+#if defined(__GNUC__)
+#define TAPE_NUM_OK_INLINE __attribute__((always_inline)) inline
+#else
+#define TAPE_NUM_OK_INLINE
+#endif
+static TAPE_NUM_OK_INLINE int tape_num_ok(const char* p, size_t len) {
     size_t k = 0;
     if (k < len && p[k] == '-') {
         k++;
@@ -770,6 +807,38 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
                 i = cl_ + 1;                                                                       \
                 goto after;                                                                        \
             }                                                                                      \
+            /* rounds 2-4 (up to 32 bytes inline): the email-class strings                         \
+             * close here without the quote_scan call and its redundant                            \
+             * content re-sweep; reached only when round 1 had no close,                           \
+             * so the short-string case pays nothing */                                            \
+            if ((qm_ | bm_ | c0_ | hi_) == 0) {                                                    \
+                size_t nr_ = (len - j_) >> 3;                                                      \
+                if (nr_ > 4) {                                                                     \
+                    nr_ = 4;                                                                       \
+                }                                                                                  \
+                for (size_t r_ = 1; r_ < nr_; r_++) {                                              \
+                    size_t b2_ = j_ + (r_ << 3);                                                   \
+                    memcpy(&w_, p + b2_, 8);                                                       \
+                    qm_ = (w_ ^ 0x2222222222222222ull);                                            \
+                    bm_ = (w_ ^ 0x5C5C5C5C5C5C5C5Cull);                                            \
+                    qm_ = (qm_ - 0x0101010101010101ull) & ~qm_ & 0x8080808080808080ull;            \
+                    bm_ = (bm_ - 0x0101010101010101ull) & ~bm_ & 0x8080808080808080ull;            \
+                    c0_ = (w_ - 0x2020202020202020ull) & ~w_ & 0x8080808080808080ull;              \
+                    hi_ = cl ? (w_ & 0x8080808080808080ull) : 0;                                   \
+                    if (qm_ != 0 && ((bm_ | c0_ | hi_) & (qm_ - 1)) == 0) {                        \
+                        size_t cl_ = b2_ + (size_t)yep_ctz64(qm_) / 8;                             \
+                        recs[count] = ((uint64_t)((uint32_t)j_) << 32) |                           \
+                                      ((uint64_t)((uint32_t)(cl_ - j_)) << 8) |                    \
+                                      (uint64_t)(YEP_T_STR);                                       \
+                        count++;                                                                   \
+                        i = cl_ + 1;                                                               \
+                        goto after;                                                                \
+                    }                                                                              \
+                    if ((qm_ | bm_ | c0_ | hi_) != 0) {                                            \
+                        break; /* escape, c0 or hi: kernel authority */                            \
+                    }                                                                              \
+                }                                                                                  \
+            }                                                                                      \
         }                                                                                          \
         {                                                                                          \
             const yep_text_kernels* kk_ = yep_text_active();                                       \
@@ -845,99 +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;
-                }
-                digits_only = 0;
-                if (d == '-' || d == '+' || d == '.' || d == 'e' || d == 'E') {
-                    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++;
@@ -966,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) {
@@ -973,8 +1076,9 @@ lseqval: {
                 saw_digit = 1;
                 continue;
             }
-            digits_only = 0;
+            /* consumed-only clearing: see the map arm's comment */
             if (d == '-' || d == '+' || d == '.' || d == 'e' || d == 'E') {
+                digits_only = 0;
                 k++;
                 continue;
             }
@@ -1036,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++;
@@ -1048,6 +1164,7 @@ lseqafter:
 
 ldone:
 #undef LWS
+#undef LNUM_RUN
 #undef LPUSH
 #undef LCLOSE
 #undef LSTR_SCAN

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.21.1
+  version: 0.6.23.1
 platform: arm-linux-eabihf
 authors:
 - Ribose Inc.