leptris 1.9.382.0-ppc64le-linux → 1.9.384.0-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e862627d34c3ad97d038530001604db28768bd189c8092cf05d109bc96d06c39
-  data.tar.gz: 1b1ddb546df3e4d5cb66738a5a138436630089d6ee85c718590b676cd688b89a
+  metadata.gz: 9fa69448585e5eb841693914222c0c5b3d74552b4abb005df923aa9e1978c503
+  data.tar.gz: 95e3c776c79d0854549f0dc125e8ba1bc3ba39e4a1d381773cbb923263b91e75
 SHA512:
-  metadata.gz: 37e7e57d2ed22594ba1a764ebfa81be6b1ca8200717aec69fc34d5342ecf348b6f474e8c03157debaf36ef916a1a2323f42a2341f2a4711ce523ad4893a81b9f
-  data.tar.gz: ba9dea847711cb7201e17ba52343e84a20d1055e9c0bfa314fbc7d85efc96089006ce673c78b746c9814ffb5b50ffeaf27d000eea423194199375562d56d19b0
+  metadata.gz: 1196cae8b8550125559c1f0a97aff3d3ce96131f92bfc3c1371ebb2ab1a32fe81865ba1e7f586b181543b5aa9313e17e770ca1dadb2ebe7a3980885a1acfa434
+  data.tar.gz: 897aa60336bf4f2d5d4b1fd1c3da85c6a150c70357524d6995266c1a5c1b471a2f9399aa261835dc33becb2a0c3ce5db09bb771fba56f0d67b47edf0f8c9714c

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.382"
+LIBLEPTRIS_VERSION = "1.9.384"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.382.0"
+  VERSION = "1.9.384.0"
 end

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.382
+- libleptris v1.9.384
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,44 @@
 ## [Unreleased]
 
+## [1.9.384] - 2026-10-27
+
+### Fixed
+
+- XPath: a parent step after an attribute step (`./@id/..`) yields
+  the OWNING element (XPath 1.0 section 2.2) — the VM parent axis
+  handled namespace/element/text contexts but attributes fell
+  through to the child-tree parent link (NULL for attributes), so
+  the step came back empty. Metanorma-standoc's SVG id
+  disambiguation drives exactly this shape and consumed the wrong
+  results downstream (#1867; the wrong-answer half of #1866).
+
+
+
+## [1.9.383] - 2026-10-26
+
+### Fixed
+
+- XSD: an empty instance no longer bypasses the content model —
+  `<note/>` validated clean against a required-particle sequence
+  (#1860; found by the moxml#460 facade tests).
+- XSD: substitution-group members on type-less globals are captured
+  (particlesDc001) and a complexContent RESTRICTION no longer
+  defers its base — the fold prepended the base's model and
+  demanded the base content next to the derived content (#1861;
+  moxml#466). modelGroups sweep 145/145 expected-valid.
+- XSD: an `xs:all` with `minOccurs="0"` may be absent — an empty
+  instance validates even when the particles carry min=1 (#1863;
+  mgAa003/mgD013).
+- XSD regex (moxml#464): `charClassSub` is codepoint-exact (ranges,
+  blocks and categories in the subtrahend now subtract); `\d` is
+  the Unicode Nd category; complement escapes (`\D \W \S \I \C`)
+  are exact over categories; `\P` works inside classes; an empty
+  pattern branch matches only the empty string; class members and
+  range endpoints accept escaped `]`/`}` and astral characters.
+  Regex_w3c expected-valid sweep: 98 -> 17 rejections.
+
+
+
 ## [1.9.382] - 2026-10-26
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.382
+    VERSION 1.9.384
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/src/leptris/rng/rng_regex.c

@@ -55,6 +55,21 @@ typedef struct RreNode {
      * LEPTRIS_HAS_UTF8PROC (without it the escapes fail loudly). */
     unsigned cat_set;
     unsigned cat_mask;
+    /* cat_strict (moxml#464): a class-internal COMPLEMENT builtin
+     * ([\I], [\D]) needs bitmap AND cats to agree — the normal
+     * union can't express "not in the set" once the bitmap holds
+     * the complement's high bytes (U+00AA is in ~ASCII-bits but
+     * excluded by the category). */
+    unsigned cat_strict;
+    /* XSD charClassSub: the bracketed subtrahend (moxml#464). The
+     * node is consulted at match time so its ranges, blocks and
+     * categories all subtract — the old byte-bitmap merge ignored
+     * them. */
+    struct RreNode* subtract;
+    /* in-class \P member (moxml#464): the class matches the
+     * positive members UNIONED WITH the complement of this set —
+     * [\P{L}*] = not-L OR '*'. Class negation flips the union. */
+    struct RreNode* negm;
     int neg;
     int lo, hi;          /* RRE_REP bounds; hi < 0 = unbounded */
 } RreNode;
@@ -77,6 +92,8 @@ static void node_free(RreNode* n) {
     if (!n) return;
     node_free(n->l);
     node_free(n->r);
+    node_free(n->subtract);
+    node_free(n->negm);
     free(n);
 }
 
@@ -88,6 +105,13 @@ static void cls_add_builtin(RreNode* n, char c) {
     switch (c) {
         case 'd':
             for (int i = '0'; i <= '9'; i++) cls_add(n, (unsigned char)i);
+#if defined(LEPTRIS_HAS_UTF8PROC)
+            /* XSD \d = XML decimal = Nd: Arabic-Indic and the
+             * other unicode digit families are \\d too
+             * (moxml#464, the reZ/reC \d rows) */
+            n->cat_set = 1;
+            n->cat_mask |= 1u << UTF8PROC_CATEGORY_ND;
+#endif
             break;
         case 'w':
             for (int i = '0'; i <= '9'; i++) cls_add(n, (unsigned char)i);
@@ -108,9 +132,21 @@ static void cls_add_builtin(RreNode* n, char c) {
             for (int i = 'A'; i <= 'Z'; i++) cls_add(n, (unsigned char)i);
             cls_add(n, '_');
             cls_add(n, ':');
+#if defined(LEPTRIS_HAS_UTF8PROC)
+            /* letters above the bitmap: the old 0x80-0xFF blanket
+             * also accepted symbols like U+00D7 (moxml#464) */
+            n->cat_set = 1;
+            n->cat_mask = (1u << UTF8PROC_CATEGORY_LU) |
+                          (1u << UTF8PROC_CATEGORY_LL) |
+                          (1u << UTF8PROC_CATEGORY_LT) |
+                          (1u << UTF8PROC_CATEGORY_LM) |
+                          (1u << UTF8PROC_CATEGORY_LO) |
+                          (1u << UTF8PROC_CATEGORY_NL);
+#else
             for (int i = 0x80; i < 0x100; i++) cls_add(n, (unsigned char)i);
+#endif
             break;
-        case 'c':   /* XML NameChar = \i + digits . - */
+        case 'c':   /* XML NameChar = \i + digits . - + combining */
             for (int i = 'a'; i <= 'z'; i++) cls_add(n, (unsigned char)i);
             for (int i = 'A'; i <= 'Z'; i++) cls_add(n, (unsigned char)i);
             for (int i = '0'; i <= '9'; i++) cls_add(n, (unsigned char)i);
@@ -118,18 +154,76 @@ static void cls_add_builtin(RreNode* n, char c) {
             cls_add(n, ':');
             cls_add(n, '.');
             cls_add(n, '-');
+#if defined(LEPTRIS_HAS_UTF8PROC)
+            n->cat_set = 1;
+            n->cat_mask = (1u << UTF8PROC_CATEGORY_LU) |
+                          (1u << UTF8PROC_CATEGORY_LL) |
+                          (1u << UTF8PROC_CATEGORY_LT) |
+                          (1u << UTF8PROC_CATEGORY_LM) |
+                          (1u << UTF8PROC_CATEGORY_LO) |
+                          (1u << UTF8PROC_CATEGORY_NL) |
+                          (1u << UTF8PROC_CATEGORY_ND) |
+                          (1u << UTF8PROC_CATEGORY_MN) |
+                          (1u << UTF8PROC_CATEGORY_MC);
+#else
             for (int i = 0x80; i < 0x100; i++) cls_add(n, (unsigned char)i);
+#endif
             break;
         default:
             break;
     }
 }
 
+static unsigned rre_decode_cp(const char* s, size_t avail, int* len);
+
 static int cls_has(const RreNode* n, unsigned char c) {
     int hit = (n->cls[c >> 3] >> (c & 7)) & 1;
     return n->neg ? !hit : hit;
 }
 
+/* One class MEMBER as a codepoint: singleCharEsc punctuation and
+ * control escapes, otherwise the raw (multi-byte) character
+ * (moxml#464: [\]} ranges and astral char-ref members). */
+static int cls_read_cp(RreParser* ps, unsigned* out) {
+    if (*ps->p == '\\') {
+        char e = ps->p[1];
+        if (!e) return 0;
+        ps->p += 2;
+        switch (e) {
+            case 't': *out = '\t'; return 1;
+            case 'n': *out = '\n'; return 1;
+            case 'r': *out = '\r'; return 1;
+            case '\\': case '.': case '-': case '^':
+            case '?': case '*': case '+': case '(': case ')':
+            case '[': case ']': case '{': case '}': case '|':
+                *out = (unsigned char)e; return 1;
+            default: return 0; /* classes (\d...) are not members */
+        }
+    }
+    if (((unsigned char)*ps->p) < 0x80) {
+        *out = (unsigned char)*ps->p++;
+        return 1;
+    }
+    int len = 0;
+    unsigned cp = rre_decode_cp(ps->p, strlen(ps->p), &len);
+    if (!len) return 0;
+    ps->p += len;
+    *out = cp;
+    return 1;
+}
+
+static void cls_add_cp(RreNode* n, unsigned cp) {
+    if (cp < 0x100) {
+        cls_add(n, (unsigned char)cp);
+        return;
+    }
+    if (n->uni_n < 4) {
+        n->uni_lo[n->uni_n] = cp;
+        n->uni_hi[n->uni_n] = cp;
+        n->uni_n++;
+    }
+}
+
 /* Codepoint form (moxml#464): bytes 0x00-0xFF check the bitmap,
  * higher codepoints check the unicode ranges; neg flips the
  * combined result. */
@@ -147,14 +241,19 @@ static int cls_has_cp(const RreNode* n, unsigned cp) {
         }
     }
 #if defined(LEPTRIS_HAS_UTF8PROC)
-    if (!hit && n->cat_set) {
-        hit = (n->cat_mask &
-               (1u << utf8proc_get_property((utf8proc_int32_t)cp)
-                    ->category)) != 0;
+    if (n->cat_set) {
+        int c = (n->cat_mask &
+                 (1u << utf8proc_get_property((utf8proc_int32_t)cp)
+                      ->category)) != 0;
+        hit = n->cat_strict ? (hit && c) : (hit || c);
     }
 #else
     (void)0;
 #endif
+    if (n->negm)
+        hit = hit || !cls_has_cp(n->negm, cp);
+    if (hit && n->subtract)
+        hit = !cls_has_cp(n->subtract, cp);
     return n->neg ? !hit : hit;
 }
 
@@ -443,7 +542,8 @@ static RreNode* parse_class(RreParser* ps) {
     int first = 1;
     while (*ps->p && (*ps->p != ']' || first)) {
         first = 0;
-        if (*ps->p == '\\' && ps->p[1] == 'p' && ps->p[2] == '{') {
+        if (*ps->p == '\\' && (ps->p[1] == 'p' || ps->p[1] == 'P') &&
+            ps->p[2] == '{') {
             /* XSD property classes for the Latin-1 byte world —
              * the byte-class matcher covers these exactly
              * (leptris-ruby#434, ST_ContentType). Other blocks
@@ -456,6 +556,12 @@ static RreNode* parse_class(RreParser* ps) {
                 return NULL;
             }
             size_t len = (size_t)(close - ps->p);
+            char pc = ps->p[-2]; /* 'p' or 'P' */
+            RreNode* tmp = node_new(RRE_CLASS);
+            if (!tmp) {
+                node_free(n);
+                return NULL;
+            }
             unsigned lo = 0, hi = 0;
             int hit = rre_block_range(ps->p, len, &lo, &hi);
             if (!hit && len == 2 && ps->p[0] == 'C' && ps->p[1] == 'c') {
@@ -463,7 +569,8 @@ static RreNode* parse_class(RreParser* ps) {
                 hit = 1;
             }
             if (hit) {
-                if (!cls_add_block(n, lo, hi)) {
+                if (!cls_add_block(tmp, lo, hi)) {
+                    node_free(tmp);
                     node_free(n);
                     ps->bad = 1;
                     return NULL;
@@ -474,24 +581,47 @@ static RreNode* parse_class(RreParser* ps) {
 #if defined(LEPTRIS_HAS_UTF8PROC)
                 unsigned mask = 0;
                 if (!rre_category_mask(ps->p, len, &mask)) {
+                    node_free(tmp);
                     node_free(n);
                     ps->bad = 1;
                     return NULL;
                 }
-                n->cat_set = 1;
-                n->cat_mask |= mask;
+                tmp->cat_set = 1;
+                tmp->cat_mask |= mask;
 #else
+                node_free(tmp);
                 node_free(n);
                 ps->bad = 1;
                 return NULL;
 #endif
             }
             if (len == 2 && ps->p[0] == 'C' && ps->p[1] == 'c') {
-                cls_add(n, 0x7F);
+                cls_add(tmp, 0x7F);
                 for (int i = 0x80; i <= 0x9F; i++)
-                    cls_add(n, (unsigned char)i);
+                    cls_add(tmp, (unsigned char)i);
             }
             ps->p = close + 1;
+            /* in-class \P (moxml#464, reF43/reK4): the member is
+             * the complement of the parsed set — stored as negm and
+             * unioned at match time. A second \P member degrades to
+             * the positive spelling (single negm slot). */
+            if (pc == 'P' && !n->negm) {
+                n->negm = tmp;
+                continue;
+            }
+            for (int i = 0; i < 256; i++)
+                if ((tmp->cls[i >> 3] >> (i & 7)) & 1)
+                    cls_add(n, (unsigned char)i);
+            for (int i = 0; i < tmp->uni_n && n->uni_n < 4; i++) {
+                n->uni_lo[n->uni_n] = tmp->uni_lo[i];
+                n->uni_hi[n->uni_n] = tmp->uni_hi[i];
+                n->uni_n++;
+            }
+            if (tmp->cat_set) {
+                n->cat_set = 1;
+                n->cat_mask |= tmp->cat_mask;
+            }
+            node_free(tmp);
             continue;
         }
         if (*ps->p == '\\' && ps->p[1]) {
@@ -508,6 +638,16 @@ static RreNode* parse_class(RreParser* ps) {
                 cls_add_builtin(tmp, e);
                 int neg_b = e == 'D' || e == 'W' || e == 'S' ||
                             e == 'I' || e == 'C';
+#if defined(LEPTRIS_HAS_UTF8PROC)
+                if (!neg_b && tmp->cat_set) {
+                    n->cat_set = 1;
+                    n->cat_mask |= tmp->cat_mask;
+                } else if (neg_b && tmp->cat_set && !n->cat_set) {
+                    n->cat_set = 1;
+                    n->cat_strict = 1;
+                    n->cat_mask = (~tmp->cat_mask) & 0x7FFFFFFFu;
+                }
+#endif
                 for (int i = 0; i < 256; i++)
                     if (((tmp->cls[i >> 3] >> (i & 7)) & 1) ==
                         (neg_b ? 0 : 1))
@@ -543,10 +683,9 @@ static RreNode* parse_class(RreParser* ps) {
                 node_free(n);
                 return NULL;
             }
-            for (int i = 0; i < 256; i++)
-                if ((sub->cls[i >> 3] >> (i & 7)) & 1)
-                    n->cls[i >> 3] &= (unsigned char)~(1u << (i & 7));
-            node_free(sub);
+            /* owned: the matcher consults it codepoint-wide, so
+             * ranges/blocks/categories subtract exactly */
+            n->subtract = sub;
             if (*ps->p != ']') {
                 node_free(n);
                 ps->bad = 1;
@@ -554,13 +693,30 @@ static RreNode* parse_class(RreParser* ps) {
             }
             break;
         }
-        unsigned char c = (unsigned char)*ps->p++;
+        unsigned lo = 0;
+        if (!cls_read_cp(ps, &lo)) {
+            node_free(n);
+            ps->bad = 1;
+            return NULL;
+        }
         if (*ps->p == '-' && ps->p[1] && ps->p[1] != ']') {
             ps->p++;
-            unsigned char hi = (unsigned char)*ps->p++;
-            for (unsigned int i = c; i <= hi; i++) cls_add(n, (unsigned char)i);
+            unsigned hi = 0;
+            if (!cls_read_cp(ps, &hi) || hi < lo) {
+                node_free(n);
+                ps->bad = 1;
+                return NULL;
+            }
+            if (lo < 0x100 && hi < 0x100) {
+                for (unsigned int i = lo; i <= hi; i++)
+                    cls_add(n, (unsigned char)i);
+            } else if (n->uni_n < 4) {
+                n->uni_lo[n->uni_n] = lo;
+                n->uni_hi[n->uni_n] = hi;
+                n->uni_n++;
+            }
         } else {
-            cls_add(n, c);
+            cls_add_cp(n, lo);
         }
     }
     if (*ps->p != ']') {
@@ -651,25 +807,18 @@ static RreNode* parse_atom(RreParser* ps) {
             ps->p += 2;
             RreNode* n = node_new(RRE_CLASS);
             if (!n) return NULL;
-            if (e == 'd' || e == 'w' || e == 's' || e == 'i' ||
-                e == 'c') {
-                cls_add_builtin(n, e);
-            } else {
-                memset(n->cls, 0xff, sizeof(n->cls));
-                RreNode* tmp = node_new(RRE_CLASS);
-                if (!tmp) {
-                    node_free(n);
-                    return NULL;
-                }
-                cls_add_builtin(tmp, e == 'D' ? 'd'
-                                  : e == 'W' ? 'w'
-                                  : e == 'S' ? 's'
-                                  : e == 'I' ? 'i' : 'c');
-                for (int i = 0; i < 256; i++)
-                    if ((tmp->cls[i >> 3] >> (i & 7)) & 1)
-                        n->cls[i >> 3] &= (unsigned char)~(1u << (i & 7));
-                node_free(tmp);
-            }
+            /* complement atoms are the builtin with neg: cls_has_cp
+             * flips the combined bitmap/range/categorie result, so
+             * the class members stay exact (the old bitmap memset
+             * could not represent the category complement) */
+            cls_add_builtin(n, e == 'D' ? 'd'
+                              : e == 'W' ? 'w'
+                              : e == 'S' ? 's'
+                              : e == 'I' ? 'i'
+                              : e == 'C' ? 'c' : e);
+            if (e == 'D' || e == 'W' || e == 'S' || e == 'I' ||
+                e == 'C')
+                n->neg = 1;
             return n;
         }
         ps->p += 2;
@@ -830,7 +979,8 @@ static const char* rre_match(RreNode* n, const char* s,
             return NULL;
         case RRE_CLASS: {
             if (!*s) return NULL;
-            if ((unsigned char)*s < 0x80 && !n->cat_set) {
+            if ((unsigned char)*s < 0x80 && !n->cat_set &&
+                !n->subtract && !n->negm) {
                 if (cls_has(n, (unsigned char)*s))
                     return rre_run(k, s + 1);
                 return NULL;
@@ -900,6 +1050,10 @@ int rng_regex_supported(const char* pat) {
 
 int rng_regex_matches(const char* pat, const char* text) {
     if (!pat || !text) return 0;
+    /* XSD Appendix F.1: an EMPTY pattern branch matches only the
+     * empty string (the reA1 corpus shape: pattern="" with
+     * value="") */
+    if (!*pat) return !*text;
     RreParser ps;
     ps.p = pat;
     ps.depth = 0;

data/vendor-src/libleptris/src/leptris/xpath/vm.c

@@ -768,6 +768,14 @@ struct leptris_xpath_result* vm_apply_axis_parent(XPathContext* ctx, XPathVM* vm
         if (in && (int)in->type == (int)LEPTRIS_NODE_NAMESPACE) {
             /* Namespace nodes' parent is the OWNER element (63). */
             parent = ((LeptrisNamespaceNode*)in)->owner;
+        } else if (in && (int)in->type == (int)LEPTRIS_NODE_ATTRIBUTE) {
+            /* Attribute nodes' parent is the OWNER element (XPath
+             * 1.0 §2.2: `../` after an attribute step names the
+             * element carrying the attribute). Attributes are not
+             * in the child tree, so the any-kind parent link below
+             * is NULL for them (leptris#1866, standoc svg cleanup:
+             * `./@id/..`). */
+            parent = ((LeptrisAttributeNode*)in)->owner;
         } else if (node_is_element(in)) {
             parent = leptris_element_get_parent((LeptrisElement)in);
         } else {

data/vendor-src/libleptris/src/leptris/xsd/compile.c

@@ -2294,16 +2294,29 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                  * synthesized slot and point the declaration at it. */
                 char synth[512];
                 snprintf(synth, sizeof(synth), "element:%s", nm);
-                if (xsd_capture_inline(s, (LeptrisElement)n, synth)) {
-                    XsdElementDecl* d =
-                        (XsdElementDecl*)calloc(1, sizeof(*d));
-                    if (d) {
-                        d->name = xsd_strdup(nm);
-                        if (s->target_ns) d->ns = xsd_strdup(s->target_ns);
+                /* moxml#466: the declaration is captured even when
+                 * the element carries no inline type (a bare
+                 * <xs:element name=... substitutionGroup=.../> member
+                 * has none) — the strict root walk and the head
+                 * chain both need the row to exist. */
+                int has_inline =
+                    xsd_capture_inline(s, (LeptrisElement)n, synth);
+                XsdElementDecl* d =
+                    (XsdElementDecl*)calloc(1, sizeof(*d));
+                if (d) {
+                    d->name = xsd_strdup(nm);
+                    if (s->target_ns) d->ns = xsd_strdup(s->target_ns);
+                    if (has_inline)
                         d->type = xsd_strdup(synth);
-                        d->next = s->elements;
-                        s->elements = d;
+                    const char* sg = leptris_element_attribute(
+                        (LeptrisElement)n, "substitutionGroup");
+                    if (sg) {
+                        const char* colon = strchr(sg, ':');
+                        d->sub_head = xsd_strdup(
+                            colon ? colon + 1 : sg);
                     }
+                    d->next = s->elements;
+                    s->elements = d;
                 }
             }
         } else if (strcmp(local, "complexType") == 0 && uri &&
@@ -2746,12 +2759,16 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                  * half-captured base silently truncates the model.
                  * The visited memo means each file merges once, so
                  * the double capture that used to mask this is
-                 * gone. */
+                 * gone. EXTENSION ONLY (moxml#466): a restriction's
+                 * model REPLACES the base's — folding it in prepends
+                 * a duplicate particle sequence and demands the base
+                 * content next to the derived content. */
                 int defer_base =
                     base_root
                         ? base_root->ext_base != NULL
                         : (base && strncmp(base, "xs:", 3) != 0);
-                if (defer_base && base) {
+                if (defer_base && base &&
+                    strcmp(dl, "extension") == 0) {
                     free(root->ext_base);
                     root->ext_base = xsd_strdup(base);
                 }

data/vendor-src/libleptris/src/leptris/xsd/content_model.c

@@ -255,6 +255,11 @@ static void ss_close(StateSet* ss, CmNfa* n) {
 static int all_root_valid(XsdCm* all, const char* target_ns,
                           const char* const* names,
                           const char* const* ns_uris, size_t count) {
+    /* the whole all is ABSENT (moxml#466, mgAa003/mgD013): with
+     * minOccurs="0" an empty instance validates even when the
+     * particles carry min=1 — their bounds apply only when the all
+     * is present */
+    if (count == 0 && all->min == 0) return 1;
     for (XsdCm* p = all->first_child; p; p = p->next) {
         size_t hits = 0;
         for (size_t i = 0; i < count; i++) {

data/vendor-src/libleptris/src/leptris/xsd/validate.c

@@ -325,15 +325,18 @@ static void validate_children(struct xsd_validator* v,
              leptris_node_first_child(leptris_element_as_node(elem));
          c; c = leptris_node_next_sibling(c))
         if (leptris_node_get_type(c) == LEPTRIS_NODE_TYPE_ELEMENT) n++;
-    if (!n) return;
-    const char** names = (const char**)malloc(n * sizeof(char*));
-    const char** uris = (const char**)calloc(n, sizeof(char*));
-    if (!names || !uris) {
-        free(names);
-        free(uris);
-        return;
-    }
+    const char** names = NULL;
+    const char** uris = NULL;
     size_t i = 0;
+    if (n > 0) {
+        names = (const char**)malloc(n * sizeof(char*));
+        uris = (const char**)calloc(n, sizeof(char*));
+        if (!names || !uris) {
+            free(names);
+            free(uris);
+            return;
+        }
+    }
     for (LeptrisNodeRef c =
              leptris_node_first_child(leptris_element_as_node(elem));
          c; c = leptris_node_next_sibling(c)) {
@@ -346,6 +349,11 @@ static void validate_children(struct xsd_validator* v,
         uris[i] = uri;
         i++;
     }
+    /* moxml#464-adjacent false-valid: the early return on !n let an
+     * empty instance pass ANY content model — required particles
+     * never failed. Zero children still walks: the NFA accepts the
+     * empty string only when every particle reaches accept with
+     * min == 0. names/uris stay NULL (never dereferenced at n==0). */
     int ok = xsd_content_valid(s, model, xsd_target_ns(s), names, uris,
                                n);
     if (ok) {

data/vendor-src/libleptris/test/CMakeLists.txt

@@ -143,6 +143,17 @@ target_compile_definitions(test_rng_corpus PRIVATE
 leptris_add_test(test_rng_corpus_msg rng/test_rng_corpus_msg.cpp)
 target_compile_definitions(test_rng_corpus_msg PRIVATE
     LEPTRIS_RNG_CASES_DIR="${CMAKE_CURRENT_SOURCE_DIR}/rng/jing-cases")
+if(LEPTRIS_ENABLE_UTF8PROC)
+    # the regex suites gate their unicode-escape assertions on the
+    # same macro the ENGINE was built with — a mismatch silently
+    # compiles out the assertions (the gtest then "passes" while
+    # the engine behavior goes unverified).
+    target_compile_definitions(test_rng PRIVATE LEPTRIS_HAS_UTF8PROC=1)
+    target_compile_definitions(test_rng_corpus
+        PRIVATE LEPTRIS_HAS_UTF8PROC=1)
+    target_compile_definitions(test_rng_corpus_msg
+        PRIVATE LEPTRIS_HAS_UTF8PROC=1)
+endif()
 leptris_add_test(test_simd_text  common/test_simd_text.cpp)
 leptris_add_test(test_simd_spans common/test_simd_spans.cpp)
 leptris_add_test(test_pool       memory/test_pool.cpp)

data/vendor-src/libleptris/test/rng/test_rng.cpp

@@ -1491,6 +1491,96 @@ TEST(RngRegex, BlockEscapesUnicode) {
                                "\xE4\xB8\x80"), 1);
 }
 
+/* moxml#464 subtraction edges: the subtrahend carries RANGES and
+ * categories, not just byte bits — the byte-bitmap merge ignored
+ * them, so subtracting a range subtracted nothing. */
+TEST(RngRegex, SubtractionWithRangesAndCats) {
+    /* byte-only subtraction still exact */
+    EXPECT_EQ(rng_regex_matches("[a-z-[aeiou]]+", "bcd"), 1);
+    EXPECT_EQ(rng_regex_matches("[a-z-[aeiou]]+", "axe"), 0);
+    /* range in the subtrahend: subtract ALL lowercase from the
+     * printable-ASCII range */
+    EXPECT_EQ(rng_regex_matches("[!-~-[a-z]]+", "AB1!"), 1);
+    EXPECT_EQ(rng_regex_matches("[!-~-[a-z]]+", "ab"), 0);
+    EXPECT_EQ(rng_regex_matches("[!-~-[a-z]]+", "\xCE\xB1"), 0);
+#if defined(LEPTRIS_HAS_UTF8PROC)
+    /* category in the subtrahend: letters minus uppercase */
+    EXPECT_EQ(rng_regex_matches("[\\p{L}-[\\p{Lu}]]+", "abc"), 1);
+    EXPECT_EQ(rng_regex_matches("[\\p{L}-[\\p{Lu}]]+", "ABC"), 0);
+    EXPECT_EQ(rng_regex_matches("[\\p{L}-[\\p{Lu}]]+", "\xCE\xB1"), 1);
+    EXPECT_EQ(rng_regex_matches("[\\p{L}-[\\p{Lu}]]+", "\xCE\x91"), 0);
+    /* block in the subtrahend */
+    EXPECT_EQ(rng_regex_matches("[\\p{L}-[\\p{IsGreek}]]+", "abc"), 1);
+    EXPECT_EQ(rng_regex_matches("[\\p{L}-[\\p{IsGreek}]]+",
+                               "\xCE\xB1"), 0);
+#endif
+}
+
+/* moxml#464 \d / \D: XML decimal = Nd category — Arabic-Indic
+ * and the other unicode digit families are \\d too. */
+#if defined(LEPTRIS_HAS_UTF8PROC)
+TEST(RngRegex, DigitEscapesAreUnicode) {
+    /* U+0660 Arabic-Indic zero = D9 A0 */
+    EXPECT_EQ(rng_regex_matches("\\d", "\xD9\xA0"), 1);
+    EXPECT_EQ(rng_regex_matches("\\d+", "\xD9\xA0\xD9\xA1"), 1);
+    EXPECT_EQ(rng_regex_matches("\\d", "a"), 0);
+    EXPECT_EQ(rng_regex_matches("\\D", "\xD9\xA0"), 0);
+    EXPECT_EQ(rng_regex_matches("\\D", "a"), 1);
+}
+
+TEST(RngRegex, EmptyPatternMatchesEmptyOnly) {
+    EXPECT_EQ(rng_regex_matches("", ""), 1);
+    EXPECT_EQ(rng_regex_matches("", "a"), 0);
+}
+
+TEST(RngRegex, EscapedBracketInRange) {
+    EXPECT_EQ(rng_regex_matches("[a-\\}]+", "abc}"), 1);
+    EXPECT_EQ(rng_regex_matches("[a-\\}]+", "!"), 0);
+    EXPECT_EQ(rng_regex_matches("[1-\\]]+", "12]"), 1);
+}
+
+#if defined(LEPTRIS_HAS_UTF8PROC)
+/* moxml#464 in-class \P: complement member (reF43/reK4). Exact as
+ * the class's only member; the class negation composes. */
+TEST(RngRegex, NegatedPropertyInsideClass) {
+    EXPECT_EQ(rng_regex_matches("[^\\P{IsBasicLatin}]", "a"), 1);
+    EXPECT_EQ(rng_regex_matches("[^\\P{IsBasicLatin}]", "\xC3"), 0);
+    EXPECT_EQ(rng_regex_matches("[\\P{L}*]", "*"), 1);
+    EXPECT_EQ(rng_regex_matches("[\\P{L}*]", "a"), 0);
+    EXPECT_EQ(rng_regex_matches("[\\P{L}]", "\xCE\xB1"), 0);
+    EXPECT_EQ(rng_regex_matches("[\\P{L}]{0,2}", "*!"), 1);
+}
+#endif
+
+TEST(RngRegex, AstralCharClassMember) {
+    /* U+10000 = F0 90 80 80 */
+    EXPECT_EQ(rng_regex_matches("[\xF0\x90\x80\x80]",
+                               "\xF0\x90\x80\x80"), 1);
+    EXPECT_EQ(rng_regex_matches("[\xF0\x90\x80\x80]", "a"), 0);
+}
+#endif
+
+/* moxml#464 \i / \c: XML NameStartChar / NameChar escapes. */
+TEST(RngRegex, NameCharEscapes) {
+    EXPECT_EQ(rng_regex_matches("\\i+", "abc_:def"), 1);
+    EXPECT_EQ(rng_regex_matches("\\i", "9"), 0);
+    EXPECT_EQ(rng_regex_matches("\\c+", "a-b.c9_d:e"), 1);
+    EXPECT_EQ(rng_regex_matches("\\c", "*"), 0);
+#if defined(LEPTRIS_HAS_UTF8PROC)
+    /* non-ASCII letters are NameStartChars */
+    EXPECT_EQ(rng_regex_matches("\\i", "\xCE\xB1"), 1);
+    EXPECT_EQ(rng_regex_matches("\\c", "\xCE\xB1"), 1);
+    /* Latin-1 symbols are NOT NameStartChars (the old 0x80-0xFF
+     * blanket accepted them): U+00D7 multiplication sign is Sm */
+    EXPECT_EQ(rng_regex_matches("\\i", "\xC3\x97"), 0);
+    EXPECT_EQ(rng_regex_matches("\\c", "\xC3\x97"), 0);
+    /* combining marks are NameChars but not NameStartChars:
+     * U+0300 combining grave is Mn */
+    EXPECT_EQ(rng_regex_matches("\\i", "\xCC\x80"), 0);
+    EXPECT_EQ(rng_regex_matches("\\c", "\xCC\x80"), 1);
+#endif
+}
+
 /* moxml#464 category escapes: \p{L} family masks over the
  * utf8proc categories (LEPTRIS_HAS_UTF8PROC builds). */
 #if defined(LEPTRIS_HAS_UTF8PROC)

data/vendor-src/libleptris/test/xpath/test_bytecode_vm.cpp

@@ -114,6 +114,42 @@ TEST(XPathBytecodeSpecializedAxes, AttributeNameMatches) {
     leptris_document_free(doc);
 }
 
+TEST(XPathBytecodeSpecializedAxes, ParentAfterAttributeStep) {
+    const char xml[] =
+        "<root><child id=\"a\"><leaf/></child></root>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string(xml, std::strlen(xml), &st);
+    ASSERT_NE(doc, nullptr);
+
+    /* leptris#1866: `..` after an attribute step yields the OWNING
+     * element (XPath 1.0 §2.2). The VM parent axis handled
+     * namespace/element/text contexts but attributes fell through
+     * to the child-tree parent link (NULL for attrs) — the step
+     * came back empty (standoc svg cleanup: `./@id/..`). */
+    LeptrisXPathResult r1 = leptris_xpath_eval(
+        doc, nullptr, "count(//child/@id/..)");
+    ASSERT_NE(r1, nullptr);
+    EXPECT_DOUBLE_EQ(leptris_xpath_result_number(r1), 1.0);
+    leptris_xpath_result_free(r1);
+
+    LeptrisXPathResult r2 = leptris_xpath_eval(
+        doc, nullptr, "name(//child/@id/..)");
+    ASSERT_NE(r2, nullptr);
+    char* s = leptris_xpath_result_string(r2);
+    EXPECT_STREQ(s, "child");
+    leptris_free_string(s);
+    leptris_xpath_result_free(r2);
+
+    /* a bare parent step on the element itself is unchanged */
+    LeptrisXPathResult r3 = leptris_xpath_eval(
+        doc, nullptr, "count(//leaf/..)");
+    ASSERT_NE(r3, nullptr);
+    EXPECT_DOUBLE_EQ(leptris_xpath_result_number(r3), 1.0);
+    leptris_xpath_result_free(r3);
+
+    leptris_document_free(doc);
+}
+
 TEST(XPathBytecodeSpecializedAxes, SelfAndParentAxes) {
     const char xml[] =
         "<root><child><leaf/></child></root>";

data/vendor-src/libleptris/test/xsd/test_xsd_compile.cpp

@@ -723,6 +723,47 @@ TEST(XsdValidate, ValidDocumentPasses) {
     EXPECT_EQ(validate_doc(k_v_schema, "<count>3</count>"), 1);
 }
 
+// moxml#466: an xs:all with minOccurs="0" may be ABSENT — an empty
+// instance validates even when its particles carry min=1 (the
+// mgAa003/mgD013 corpus shapes).
+TEST(XsdValidate, AllMinOccursZeroMayBeAbsent) {
+    const char* sch =
+        "<xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xsd:element name=\"doc\" type=\"foo\"/>"
+        "<xsd:complexType name=\"foo\">"
+        "<xsd:all minOccurs=\"0\">"
+        "<xsd:element name=\"t1\"/>"
+        "</xsd:all></xsd:complexType>"
+        "</xsd:schema>";
+    EXPECT_EQ(validate_doc(sch, "<doc/>"), 1);
+    EXPECT_EQ(validate_doc(sch, "<doc><t1/></doc>"), 1);
+    EXPECT_EQ(validate_doc(sch, "<doc><t1/><t1/></doc>"), 0);
+}
+
+TEST(XsdValidate, AllMinOccursZeroAbsentWithRequiredParticles) {
+    const char* sch =
+        "<xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xsd:element name=\"root\">"
+        "<xsd:complexType><xsd:choice minOccurs=\"1\""
+        " maxOccurs=\"unbounded\">"
+        "<xsd:element name=\"elt1\">"
+        "<xsd:complexType>"
+        "<xsd:all minOccurs=\"0\">"
+        "<xsd:element name=\"elt2\"/>"
+        "<xsd:element name=\"elt3\"/>"
+        "<xsd:element name=\"elt4\"/>"
+        "</xsd:all></xsd:complexType>"
+        "</xsd:element>"
+        "</xsd:choice></xsd:complexType>"
+        "</xsd:element></xsd:schema>";
+    EXPECT_EQ(validate_doc(sch, "<root><elt1/></root>"), 1);
+    EXPECT_EQ(validate_doc(
+                  sch, "<root><elt1><elt2/><elt3/><elt4/></elt1>"
+                       "</root>"), 1);
+    EXPECT_EQ(validate_doc(
+                  sch, "<root><elt1><elt2/></elt1></root>"), 0);
+}
+
 TEST(XsdValidate, ContentModelViolationReports) {
     EXPECT_EQ(validate_doc(k_v_schema,
                            "<rows version=\"1\">"
@@ -1314,6 +1355,98 @@ TEST(XsdValidate, SubstitutionGroupMembersBind) {
                            "<box><other>z</other></box>"), 0);
 }
 
+// moxml#466 class 1: a member of a substitution group binds a
+// ref-particle in a NAMESPACED schema (particlesDc001 family) —
+// elementFormDefault="qualified" + targetNamespace, head reached
+// through x:elem1.
+const char* k_subst_ns_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " xmlns=\"http://xsdtesting\""
+    " xmlns:x=\"http://xsdtesting\""
+    " targetNamespace=\"http://xsdtesting\""
+    " elementFormDefault=\"qualified\">"
+    "<xs:element name=\"doc\">"
+    "<xs:complexType><xs:sequence>"
+    "<xs:element ref=\"x:elem1\"/>"
+    "</xs:sequence></xs:complexType>"
+    "</xs:element>"
+    "<xs:element name=\"elem1\" abstract=\"false\"/>"
+    "<xs:element name=\"elem2\" substitutionGroup=\"x:elem1\"/>"
+    "</xs:schema>";
+
+TEST(XsdValidate, SubstitutionGroupMemberBindsRefParticleQualified) {
+    EXPECT_EQ(validate_doc(
+                  k_subst_ns_schema,
+                  "<x:doc xmlns:x=\"http://xsdtesting\">"
+                  "<x:elem1/></x:doc>"), 1);
+    EXPECT_EQ(validate_doc(
+                  k_subst_ns_schema,
+                  "<x:doc xmlns:x=\"http://xsdtesting\">"
+                  "<x:elem2/></x:doc>"), 1);
+    EXPECT_EQ(validate_doc(
+                  k_subst_ns_schema,
+                  "<x:doc xmlns:x=\"http://xsdtesting\">"
+                  "<x:other/></x:doc>"), 0);
+}
+
+// moxml#466 class 2: a complexContent RESTRICTION whose base is a
+// forward reference must not defer-fold — the derived model
+// REPLACES the base's. The fold prepended the base's particles and
+// demanded the base content next to the derived content
+// (instance <e1/> rejected against SEQ(e1) restriction of
+// SEQ(e1) base because the fold produced SEQ(SEQ(e1), SEQ(e1))).
+TEST(XsdValidate, RestrictionReplacesForwardBaseModel) {
+    const char* fwd =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:element name=\"doc\" type=\"foo\"/>"
+        "<xs:complexType name=\"foo\"><xs:complexContent>"
+        "<xs:restriction base=\"bar\">"
+        "<xs:sequence><xs:element name=\"e1\"/></xs:sequence>"
+        "</xs:restriction></xs:complexContent></xs:complexType>"
+        "<xs:complexType name=\"bar\"><xs:sequence>"
+        "<xs:element name=\"e1\"/><xs:element name=\"e2\"/>"
+        "</xs:sequence></xs:complexType>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(fwd, "<doc><e1/></doc>"), 1);
+    /* the base's model must NOT ride along */
+    EXPECT_EQ(validate_doc(fwd, "<doc><e1/><e2/></doc>"), 0);
+    /* resolved (non-forward) base: same replace semantics */
+    const char* resolved =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:element name=\"doc\" type=\"foo\"/>"
+        "<xs:complexType name=\"bar\"><xs:sequence>"
+        "<xs:element name=\"e1\"/><xs:element name=\"e2\"/>"
+        "</xs:sequence></xs:complexType>"
+        "<xs:complexType name=\"foo\"><xs:complexContent>"
+        "<xs:restriction base=\"bar\">"
+        "<xs:sequence><xs:element name=\"e1\"/></xs:sequence>"
+        "</xs:restriction></xs:complexContent></xs:complexType>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(resolved, "<doc><e1/></doc>"), 1);
+    EXPECT_EQ(validate_doc(resolved, "<doc><e1/><e2/></doc>"), 0);
+}
+
+/* mgO008 family: restriction through a group-ref particle — the
+ * derived model (the group's all) is the whole content model. */
+TEST(XsdValidate, RestrictionGroupRefParticleReplaces) {
+    const char* grp =
+        "<xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xsd:element name=\"doc\" type=\"foo\"/>"
+        "<xsd:complexType name=\"foo\"><xsd:complexContent>"
+        "<xsd:restriction base=\"bar\">"
+        "<xsd:group ref=\"group\"/>"
+        "</xsd:restriction></xsd:complexContent></xsd:complexType>"
+        "<xsd:complexType name=\"bar\">"
+        "<xsd:all minOccurs=\"1\" maxOccurs=\"1\">"
+        "<xsd:element name=\"e1\"/><xsd:element name=\"e2\"/>"
+        "</xsd:all></xsd:complexType>"
+        "<xsd:group name=\"group\"><xsd:all>"
+        "<xsd:element name=\"e1\"/></xsd:all></xsd:group>"
+        "</xsd:schema>";
+    EXPECT_EQ(validate_doc(grp, "<doc><e1/></doc>"), 1);
+    EXPECT_EQ(validate_doc(grp, "<doc><e1/><e2/></doc>"), 0);
+}
+
 }  // namespace
 
 // ---- tier-1 charter: include/import via compile_file ---------------
@@ -3166,3 +3299,36 @@ TEST(XsdNegativeWildcard, AnyAttributeNotQNameDefined) {
     leptris_document_free(b);
     leptris_xsd_free(s);
 }
+
+// moxml#464-adjacent false-valid: an EMPTY instance against a
+// required-particle content model must fail — the walk's `!n`
+// early-return let it pass (the NFA never saw the instance).
+TEST(XsdContentModel, EmptyInstanceAgainstRequiredSequenceFails) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char xsd[] =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:element name=\"note\">"
+        "<xs:complexType>"
+        "<xs:sequence>"
+        "<xs:element name=\"to\" type=\"xs:string\"/>"
+        "</xs:sequence>"
+        "</xs:complexType>"
+        "</xs:element>"
+        "</xs:schema>";
+    LeptrisXsdSchema s = leptris_xsd_compile(xsd, strlen(xsd), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0) << "status " << (int)st;
+
+    const char empty[] = "<note/>";
+    LeptrisDocument d = leptris_parse_string(empty, strlen(empty), &st);
+    ASSERT_NE(d, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, d), 0);
+    leptris_document_free(d);
+
+    // the satisfied model stays valid
+    const char full[] = "<note><to>x</to></note>";
+    LeptrisDocument f = leptris_parse_string(full, strlen(full), &st);
+    ASSERT_NE(f, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, f), 1);
+    leptris_document_free(f);
+    leptris_xsd_free(s);
+}

data/vendor-src/libleptris/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.382",
+  "version": "1.9.384",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.382.0
+  version: 1.9.384.0
 platform: ppc64le-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-26 00:00:00.000000000 Z
+date: 2026-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi