teptris 0.3.23.0 → 0.3.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a15759fbe1769570b78923b39bb95576a8d42fed349e61fde761085dcf0c7b85
-  data.tar.gz: 2622149afc41e720402bfbbba2f1f85499ec887e44ab6fa2f7604f27cb6db50c
+  metadata.gz: 4063376572c74e54b603e2c960d0c37a6f7322fcb60fc13c851ba537a5ecc3f4
+  data.tar.gz: 2c9216707cc91cb020909c0606ee1db5c6303de629eae1db1b9f81e003d4e512
 SHA512:
-  metadata.gz: 7b32e4a4e8165a739221d26b2904593be57b9c6b12d55f4a29d5ff10ede9becfb2c7dca61e8b70e6374acb859b972812b1d21bf17ff46c0216c3c048fc33187e
-  data.tar.gz: 83a570f3731f22e40570200251d4daae427e3a39c74ef96cb8259b0a5a9247ef810bab18638b59ae0f2711fb2bfdc38d0cad37afdf0ca3cdcaa240d76b08a500
+  metadata.gz: 634870c546775f3b2405803b9a0a34b80e8aeda5be6c7da5b488e481b216bafa1cfa4b04391c959633937c0bc4ba20e0379a3e3dc393a43311298e59eac2c0b3
+  data.tar.gz: 242e90ad01de5cf198eaf34bf0ac212fba289b9dd2ee70dc10846fbbf84c8eeca88e91851d9334ead183b8f2c7c697bd9e2f53f4903c51b1d425111cc33bf8b8

data/ext/teptris_ext/engine/README.md

@@ -1,4 +1,4 @@
-# libteptris 0.3.23 — vendored source
+# libteptris 0.3.24 — vendored source
 
 This directory carries the COMPLETE C source of the engine this
 gem's extension was built from (the packaging doctrine: compiled

data/ext/teptris_ext/engine/src/include/teptris/version.h

@@ -3,7 +3,7 @@
 
 #define TEPTRIS_VERSION_MAJOR 0
 #define TEPTRIS_VERSION_MINOR 3
-#define TEPTRIS_VERSION_PATCH 23
-#define TEPTRIS_VERSION_STRING "0.3.23"
+#define TEPTRIS_VERSION_PATCH 24
+#define TEPTRIS_VERSION_STRING "0.3.24"
 
 #endif /* TEPTRIS_VERSION_H */

data/ext/teptris_ext/engine/src/teptris/schema/regex.c

@@ -20,6 +20,7 @@
 #include <string.h>
 
 #include "regex.h"
+#include "unicode_props.h"
 
 /* ---------------------------------------------------------------- AST -- */
 
@@ -199,6 +200,94 @@ static void cls_add_cp(pctx *c, ra *cl, uint32_t cp) {
     cl->n_ranges++;
 }
 
+/* ------------------------------------------------- \p{...} properties -- */
+
+static void cls_reserve(pctx *c, ra *cl, size_t cap);
+
+/* the property named by s[0..n) (decoded code points): binary search
+ * over the sorted table */
+static const teptris_uc_prop *uc_find(const uint32_t *s, size_t n) {
+    int lo = 0, hi = teptris_n_unicode_props - 1;
+    while (lo <= hi) {
+        int mid = (lo + hi) / 2;
+        const char *name = teptris_unicode_props[mid].name;
+        int cmp = 0;
+        for (size_t i = 0; i < n; i++) {
+            unsigned char c = (unsigned char)name[i];
+            if (c == '\0' || (uint32_t)c != s[i]) {
+                cmp = (uint32_t)c < s[i] ? -1 : 1;
+                break;
+            }
+        }
+        if (cmp == 0 && name[n] == '\0') return &teptris_unicode_props[mid];
+        if (cmp == 0) cmp = 1; /* longer table name: s sorts first */
+        if (cmp < 0) lo = mid + 1;
+        else hi = mid - 1;
+    }
+    return NULL;
+}
+
+/* the complement of sorted ranges over the whole codepoint space (the
+ * caller reserved headroom) */
+static void cls_append_complement(pctx *c, ra *cl,
+                                  const teptris_uc_range *rs, int n) {
+    (void)c;
+    uint32_t expect = 0;
+    for (int i = 0; i <= n; i++) {
+        uint32_t lo = i < n ? rs[i].lo : 0x110000;
+        uint32_t hi = i < n ? rs[i].hi : 0x110000;
+        if (lo > expect) {
+            cl->ranges[cl->n_ranges].lo = expect;
+            cl->ranges[cl->n_ranges].hi = lo - 1;
+            cl->n_ranges++;
+        }
+        if (hi + 1 > expect) expect = hi + 1;
+    }
+}
+
+/* parse \p{...} / \P{...} / \p{^...} with c->pos after the letter;
+ * the ranges (or their complement) append into cl */
+static void prop_escape(pctx *c, ra *cl, bool negate_letter) {
+    bool inner_neg = false;
+    if (c->pos >= c->n || c->s[c->pos] != '{') {
+        pfail(c, "\\p needs a {property} name");
+        return;
+    }
+    c->pos++;
+    if (c->pos < c->n && c->s[c->pos] == '^') {
+        inner_neg = true;
+        c->pos++;
+    }
+    size_t start = c->pos;
+    while (c->pos < c->n && c->s[c->pos] != '}') c->pos++;
+    if (c->pos >= c->n) {
+        pfail(c, "unterminated \\p{...}");
+        return;
+    }
+    size_t n = c->pos - start;
+    c->pos++; /* the closing brace */
+    if (n == 0) {
+        pfail(c, "empty \\p{} property name");
+        return;
+    }
+    const teptris_uc_prop *p = uc_find(c->s + start, n);
+    if (p == NULL) {
+        pfail(c, "unknown \\p{...} property name");
+        return;
+    }
+    bool negate = negate_letter != inner_neg;
+    cls_reserve(c, cl, negate ? (size_t)2 * p->n + 8 : (size_t)p->n + 8);
+    if (negate) {
+        cls_append_complement(c, cl, p->ranges, p->n);
+    } else {
+        for (int i = 0; i < p->n; i++) {
+            cl->ranges[cl->n_ranges].lo = p->ranges[i].lo;
+            cl->ranges[cl->n_ranges].hi = p->ranges[i].hi;
+            cl->n_ranges++;
+        }
+    }
+}
+
 /* expand a class shorthand (\d \w \s) into its ranges */
 static void cls_shorthand(pctx *c, ra *cl, uint32_t e) {
     if (e == 'd' || e == 'D') {
@@ -241,6 +330,10 @@ static long class_escape(pctx *c, ra *cl) {
         c->pos++;
         cls_shorthand(c, cl, e);
         return -1;
+    case 'p': case 'P':
+        c->pos++;
+        prop_escape(c, cl, e == 'P');
+        return -1;
     case 'x': {
         c->pos++;
         if (c->pos + 2 > c->n) {
@@ -291,6 +384,34 @@ static long class_escape(pctx *c, ra *cl) {
 }
 
 /* parse the body of a [...]; c->pos sits after '[' */
+/* sort + merge a class's ranges in place (property tables arrive
+ * sorted; literals interleave arbitrarily) so matching can binary
+ * search and negation sees a canonical form */
+static void cls_sort_merge(pctx *c, ra *cl) {
+    (void)c;
+    int n = cl->n_ranges;
+    for (int i = 1; i < n; i++) {
+        ra_range r = cl->ranges[i];
+        int j = i - 1;
+        while (j >= 0 && (cl->ranges[j].lo > r.lo)) {
+            cl->ranges[j + 1] = cl->ranges[j];
+            j--;
+        }
+        cl->ranges[j + 1] = r;
+    }
+    int w = 0;
+    for (int i = 1; i < n; i++) {
+        if (cl->ranges[i].lo <= cl->ranges[w].hi + 1) {
+            if (cl->ranges[i].hi > cl->ranges[w].hi) {
+                cl->ranges[w].hi = cl->ranges[i].hi;
+            }
+        } else {
+            cl->ranges[++w] = cl->ranges[i];
+        }
+    }
+    cl->n_ranges = w + 1;
+}
+
 static ra *rclass(pctx *c) {
     ra *cl = rn(c, RA_CLASS);
     if (c->pos < c->n && c->s[c->pos] == '^') {
@@ -303,6 +424,7 @@ static ra *rclass(pctx *c) {
     while (c->pos < c->n) {
         if (c->s[c->pos] == ']' && !first) {
             c->pos++;
+            cls_sort_merge(c, cl);
             return cl;
         }
         first = false;
@@ -495,6 +617,13 @@ static ra *ratom(pctx *c) {
             cls_shorthand(c, cl, e);
             return cl;
         }
+        if (e == 'p' || e == 'P') {
+            c->pos++;
+            ra *cl = rn(c, RA_CLASS);
+            prop_escape(c, cl, e == 'P');
+            if (c->err[0] != '\0') return NULL;
+            return cl;
+        }
         if (e == 'b') {
             c->pos++;
             return rn(c, RA_WORDB);
@@ -701,12 +830,13 @@ static bool emit_node(nctx *c, ra *r, frag *f) {
         int s = nstate(c, RS_CHAR);
         if (s < 0) return false;
         if (r->ci) {
-            /* a folded letter matches both cases */
+            /* a folded letter matches both cases (stored ascending:
+             * cls_match binary-searches) */
             c->states[s].ranges = teptris_arena_alloc(c->a, 2 * sizeof(ra_range));
-            c->states[s].ranges[0].lo = r->cp;
-            c->states[s].ranges[0].hi = r->cp;
-            c->states[s].ranges[1].lo = fold_cp(r->cp) - 32;
-            c->states[s].ranges[1].hi = fold_cp(r->cp) - 32;
+            c->states[s].ranges[0].lo = fold_cp(r->cp) - 32;
+            c->states[s].ranges[0].hi = fold_cp(r->cp) - 32;
+            c->states[s].ranges[1].lo = r->cp;
+            c->states[s].ranges[1].hi = r->cp;
             c->states[s].n_ranges = 2;
         } else {
             c->states[s].ranges = teptris_arena_alloc(c->a, sizeof(ra_range));
@@ -937,9 +1067,15 @@ struct sch_regex *sch_regex_compile(teptris_arena *a, const char *pattern,
 
 static bool cls_match(const rstate *st, uint32_t cp) {
     if (st->any) return true;
+    int lo = 0, hi = st->n_ranges - 1;
     bool in = false;
-    for (int i = 0; i < st->n_ranges; i++) {
-        if (cp >= st->ranges[i].lo && cp <= st->ranges[i].hi) {
+    while (lo <= hi) {
+        int mid = (lo + hi) / 2;
+        if (cp < st->ranges[mid].lo) {
+            hi = mid - 1;
+        } else if (cp > st->ranges[mid].hi) {
+            lo = mid + 1;
+        } else {
             in = true;
             break;
         }