leptris 1.9.334.1-ppc64le-linux → 1.9.336.0-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee8401dd5f352a77143af53ebfbba244b80d68c49added40a79cc10abe714ecc
-  data.tar.gz: 9fd20e2fa46823f1157094b33716dcaf4d0ae28eebc06ca09c03332da78c2c10
+  metadata.gz: 67a961b3def69a2e6249c91dfecbb9d501456233269b090d6069ae1630ced027
+  data.tar.gz: 6fb3c1105222a431ad17b63beb80a2bdbe014775f279abbd7d842ee85ac06136
 SHA512:
-  metadata.gz: c2bac9ee2a93a8970a171db436e6e1ea4c1aaa62a5d484b3f4f89c4073cd5b7c960c04d4e903810025877215b01eb9bb82d5ef666445a86b96f424c4d1386293
-  data.tar.gz: 3735da6924af4d3d77eb96823448394e6d62786b394de60b1b0202b57a00cca626e583078ed817665f6750333e0395715f716739e7983fb2dd6dcccf98babee6
+  metadata.gz: b4ec23a47d3dbc3860229d16225135569a7219d3b5b6338665fe260a793b6c94a7e906d87e3fceb481d961a04d880139a202af3373777ebaa6055e1b50b828f7
+  data.tar.gz: 94c877a350d646348dfcef4cd1159dda8b237b8e4d197380f3746509af70ba55a824c0259eaeb190485f0fbd56adaaf11a47f9eed07a8fd350714e93ed6ed46b

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.9.335.0] - 2026-10-11
+
+### Fixed — engine sync (libleptris 1.9.335)
+
+- **The #414 wave (#1626, engine PR #1627)**: cross-namespace
+  `xs:import` declarations merge under a compiling schema's own
+  targetNamespace (the wml-2010 chain shape — previously invisible),
+  prefixed QName type references (`type="w:CT_Border"`) resolve
+  with `xs:`/`xsd:` builtin spellings canonized (closing a silent
+  gap where `xsd:`-spelled types were untyped), and content-model
+  failures NAME the offending child once (`(at 'right')`) — a
+  misordered child no longer cascades anonymously down the
+  ancestors. All three pinned with minimal cases.
+
 ## [1.9.334.1] - 2026-10-10
 
 ### Performance

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.334"
+LIBLEPTRIS_VERSION = "1.9.336"
 # 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.334.1"
+  VERSION = "1.9.336.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.334
+- libleptris v1.9.336
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,51 @@
 ## [Unreleased]
 
+## [1.9.336] - 2026-10-10
+
+### Fixed
+
+- **plan_result_build members emit in op order on every platform
+  (leptris#1625, PR #1629).** The serializer orders children by
+  byte position with an unstable qsort; builder-created values
+  carry no position, so the tie fell to unspecified libc behavior
+  and collection members reversed on Windows (both x64 and
+  arm64). Builder values now take a dense insertion rank before
+  push — fixing an off-by-one in the element branch besides — and
+  the comparator breaks position ties on it, making the order
+  total and platform-independent. Walk output is undisturbed (the
+  walk's own ranks are dense already). The binding's round-trip
+  spec can flip to strict member order once a release carries
+  this.
+
+
+
+## [1.9.335] - 2026-10-10
+
+### Fixed
+
+- **XSD: cross-namespace imports, prefixed type refs, named
+  content errors (#1626, PR #1627).** `xs:import` with a foreign
+  targetNamespace merges its declarations — the previous gate
+  skipped the normal multi-namespace shape (wml-2010 imports were
+  invisible when the compiling schema carried its own
+  targetNamespace). Prefixed QName references
+  (`type="w:CT_Border"`) resolve by local name at every capture
+  site, and the `xs:`/`xsd:` builtin spellings canonize —
+  closing a pre-existing gap where `xsd:`-spelled types were
+  silently untyped. Content-model failures name the offending
+  child once (`children do not match the content model
+  (at 'insideH')`) via a greedy expected-next match with
+  `minOccurs="0"` optionals skippable — one misordered child no
+  longer cascades anonymously down the ancestors (the reported
+  ~175x amplification is a bounded single report).
+- **interleaved lane: compute record depths before sizing the
+  replay stacks (leptris#1577, PR #1624).** The sizing scan read
+  the still-zero-filled depth array, bound the replay to the
+  in-struct 256-slot buffers, and every document deeper than
+  DP_MAX_DEPTH overflowed them under a raised cap.
+
+
+
 ## [1.9.334] - 2026-10-10
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/src/leptris/descriptor/plan.c

@@ -1344,6 +1344,11 @@ static int dp_kid_pos_cmp(const void* a, const void* b) {
         (const struct leptris_plan_result* const*)b;
     if ((*ka)->position < (*kb)->position) return -1;
     if ((*ka)->position > (*kb)->position) return 1;
+    /* #1625: position ties (builder nodes, offset-less rows) fall
+     * to the dense insertion rank - qsort is not stable, and an
+     * unspecified tie reordered members per platform libc. */
+    if ((*ka)->order_index < (*kb)->order_index) return -1;
+    if ((*ka)->order_index > (*kb)->order_index) return 1;
     return 0;
 }
 
@@ -1586,12 +1591,16 @@ LEPTRIS_API LeptrisPlanResult leptris_plan_result_build(
                     return NULL;
                 }
                 root = v;
-            } else if (!dp_value_push(stack[sp - 1], v)) {
-                dp_result_free_rec(v);
-                goto oom;
+            } else {
+                /* rank BEFORE push (kid_count is post-increment) -
+                 * every value needs one: the serializer's qsort
+                 * breaks position ties on it (#1625) */
+                v->order_index = (uint32_t)stack[sp - 1]->kid_count;
+                if (!dp_value_push(stack[sp - 1], v)) {
+                    dp_result_free_rec(v);
+                    goto oom;
+                }
             }
-            v->order_index = (uint32_t)
-                (sp == 0 ? 0 : stack[sp - 1]->kid_count);
             stack[sp++] = v;
         } else if (op->kind == LEPTRIS_PLAN_OP_SCALAR) {
             if (sp == 0) {
@@ -1609,6 +1618,7 @@ LEPTRIS_API LeptrisPlanResult leptris_plan_result_build(
             if (!dp_value_set_str(v, op->value ? op->value : "",
                                   op->value ? op->value_len : 0))
                 dp_value_set_str(v, "", 0);
+            v->order_index = (uint32_t)stack[sp - 1]->kid_count;
             if (!dp_value_push(stack[sp - 1], v)) {
                 dp_result_free_rec(v);
                 goto oom;

data/vendor-src/libleptris/src/leptris/flat/direct_parse.c

@@ -64,15 +64,26 @@ typedef struct {
     char* end;
     LeptrisMemoryPool* pool;
     struct leptris_document* doc;
-    LeptrisElement open_stack[DP_MAX_DEPTH];
+    LeptrisElement open_stack_buf[DP_MAX_DEPTH];
     /* Round 10: journal slot of each open element's elem_pos entry —
      * the close path updates by slot (O(1)) instead of hashing. */
-    int pos_slot_stack[DP_MAX_DEPTH];
+    int pos_slot_stack_buf[DP_MAX_DEPTH];
     /* TODO 155 Phase C: per-depth last-child cache. Replaces the
      * last_child_off field on element. last_child_stack[i] holds
      * the most recently wired child of open_stack[i], or NULL when
      * no child has been wired yet at that depth. */
-    LeptrisNode* last_child_stack[DP_MAX_DEPTH];
+    LeptrisNode* last_child_stack_buf[DP_MAX_DEPTH];
+    /* Depth-stack indirection (leptris#1577): the in-struct buffers
+     * serve the default DP_MAX_DEPTH cap; a configured max depth
+     * above that (public leptris_set_max_depth / parse options)
+     * switches the pointers to one heap block sized for the cap.
+     * The open-tag guard honors the configured depth — with the
+     * arrays fixed at 256, any deeper document wrote past them. */
+    LeptrisElement* open_stack;
+    int* pos_slot_stack;
+    LeptrisNode** last_child_stack;
+    size_t stack_cap;
+    void* stack_heap;
     int depth;
     LeptrisElement root;
     /* Document children (issue #580): [prolog..., root, epilog...]
@@ -195,6 +206,36 @@ typedef struct {
     LeptrisDTD* dtd;
 } DParser;
 
+/* Depth stacks (leptris#1577): the default cap stays on the in-struct
+ * buffers (zero allocation); a larger configured cap gets one
+ * aligned heap block. Returns 0 on OOM (pointers left NULL). */
+static int dp_stacks_init(DParser* p, size_t cap) {
+    if (cap <= DP_MAX_DEPTH) {
+        p->open_stack = p->open_stack_buf;
+        p->pos_slot_stack = p->pos_slot_stack_buf;
+        p->last_child_stack = p->last_child_stack_buf;
+        p->stack_cap = DP_MAX_DEPTH;
+        p->stack_heap = NULL;
+        return 1;
+    }
+    size_t a = (cap * sizeof(LeptrisElement) + 15u) & ~(size_t)15u;
+    size_t b = (cap * sizeof(int) + 15u) & ~(size_t)15u;
+    size_t c = cap * sizeof(LeptrisNode*);
+    unsigned char* blk = (unsigned char*)malloc(a + b + c);
+    if (!blk) return 0;
+    p->open_stack = (LeptrisElement*)blk;
+    p->pos_slot_stack = (int*)(blk + a);
+    p->last_child_stack = (LeptrisNode**)(blk + a + b);
+    p->stack_cap = cap;
+    p->stack_heap = blk;
+    return 1;
+}
+
+static void dp_stacks_release(DParser* p) {
+    free(p->stack_heap);
+    p->stack_heap = NULL;
+}
+
 /* ---- #1125: immutable-buffer logs --------------------------------
  *
  * The zero-copy parse NUL-terminates names/values in place. To keep
@@ -1551,6 +1592,12 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
     p.end = buf + len;
     p.pool = pool;
     p.doc = doc;
+    {
+        extern LEPTRIS_THREAD_LOCAL int g_leptris_max_depth;
+        size_t dcap = g_leptris_max_depth > 0
+            ? (size_t)g_leptris_max_depth : (size_t)DP_MAX_DEPTH;
+        if (!dp_stacks_init(&p, dcap)) goto fail;
+    }
     p.skip_flags = skip_flags;
     p.depth = 0;
     p.root = NULL;
@@ -2311,6 +2358,7 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
      * ends the parse byte-identical to the input. (Runs after the
      * encoding/version strdups above, which read the buffer.) */
 
+    dp_stacks_release(&p);
     return doc;
 
 fail:
@@ -2372,6 +2420,7 @@ fail:
      * pool_destroy above. Don't LEPTRIS_FREE(doc) (TODO 154). */
     /* Round 8: scratch/pristine are arena-carved — pool_destroy
      * above already reclaimed them. */
+    dp_stacks_release(&p);
     return NULL;
 }
 
@@ -2446,7 +2495,35 @@ static LEPTRIS_ALWAYS_INLINE size_t il_name_end(const char* s,
     return (size_t)(p - s);
 }
 
+/* leptris#1577: the IL scan's depth stacks sized to the configured
+ * max depth (fixed 256 before — same overflow class as the classic
+ * lane). The wrapper owns the block so every body exit is covered. */
+static int il_stacks_init(IlCtx* c, size_t cap) {
+    if (cap <= LEPTRIS_IL_MAX_DEPTH) {
+        c->open = c->open_buf;
+        c->last_child = c->last_child_buf;
+        c->stack_heap = NULL;
+        return 1;
+    }
+    unsigned char* blk = (unsigned char*)malloc(
+        2u * cap * sizeof(uint32_t));
+    if (!blk) return 0;
+    c->open = (uint32_t*)blk;
+    c->last_child = (uint32_t*)(blk + cap * sizeof(uint32_t));
+    c->stack_heap = blk;
+    return 1;
+}
+
+static void il_stacks_release(IlCtx* c) {
+    free(c->stack_heap);
+    c->stack_heap = NULL;
+}
+
 int leptris_il_scan(char* s, size_t len, int drop_ws, IlCtx* c,
+                    uint32_t* root_out, size_t* trail_off,
+                    size_t* trail_len);
+
+static int il_scan_body(char* s, size_t len, int drop_ws, IlCtx* c,
                    uint32_t* root_out, size_t* trail_off,
                    size_t* trail_len) {
     const char* send = s + len;
@@ -2682,6 +2759,19 @@ int leptris_il_scan(char* s, size_t len, int drop_ws, IlCtx* c,
     }
 }
 
+int leptris_il_scan(char* s, size_t len, int drop_ws, IlCtx* c,
+                    uint32_t* root_out, size_t* trail_off,
+                    size_t* trail_len) {
+    extern LEPTRIS_THREAD_LOCAL int g_leptris_max_depth;
+    size_t dcap = g_leptris_max_depth > 0
+        ? (size_t)g_leptris_max_depth : (size_t)LEPTRIS_IL_MAX_DEPTH;
+    if (!il_stacks_init(c, dcap)) return 0;
+    int ok = il_scan_body(s, len, drop_ws, c, root_out, trail_off,
+                          trail_len);
+    il_stacks_release(c);
+    return ok;
+}
+
 
 /* Post-pass: build the public tree from the streams, replaying the
  * classic lane's exact stores. Returns NULL on OOM (caller frees). */
@@ -2791,11 +2881,28 @@ static struct leptris_document* dp_il_build(
     if (!smap || !rdepth || !lc) {
         free(smap); free(rdepth); free(lc); goto oom_pool;
     }
+    /* Depth-stack indirection (leptris#1577): record depths are not
+     * bounded by DP_MAX_DEPTH here — the replay indexes
+     * last_child_stack by them. Size the stacks to the document. */
+    /* Depth computation FIRST: the sizing scan below reads
+     * rdepth — computed here, before the max is taken (the sizing
+     * pass originally ran on the zero-filled array and sized the
+     * stacks to 1, so every deep replay overflowed the in-struct
+     * buffers — the exact class this PR fixes). */
+    for (size_t i = 0; i < c->nrec; i++) {
+        rdepth[i] = (c->recs[i].parent == IL_NONE)
+            ? 0 : rdepth[c->recs[i].parent] + 1;
+    }
+    uint32_t il_max_d = 0;
+    for (size_t i = 0; i < c->nrec; i++) {
+        if (rdepth[i] > il_max_d) il_max_d = rdepth[i];
+    }
+    if (!dp_stacks_init(&pp, (size_t)il_max_d + 1)) {
+        free(smap); free(rdepth); free(lc); goto oom_pool;
+    }
 
     for (size_t i = 0; i < c->nrec; i++) {
         IlRec* r = &c->recs[i];
-        rdepth[i] = (r->parent == IL_NONE)
-            ? 0 : rdepth[r->parent] + 1;
         if (r->kind == 0) {
             LeptrisElement e = &eblk[nelem++];
             e->base.type = LEPTRIS_NODE_TYPE_ELEMENT;
@@ -3015,10 +3122,14 @@ static struct leptris_document* dp_il_build(
     }
 
     leptris_root_doc_register(doc->root, doc);
+    dp_stacks_release(&pp);
     free(smap); free(rdepth); free(lc);
     return doc;
 
 oom_pool:
+    /* Reached only at/after the replay's DParser init — the init
+     * failure path leaves stack_heap NULL, so the release is safe. */
+    dp_stacks_release(&pp);
     leptris_pool_destroy(pool);
     free(scratch);
     free(pristine);

data/vendor-src/libleptris/src/leptris/flat/il_scan.h

@@ -43,8 +43,16 @@ typedef struct IlAttr {
 typedef struct IlCtx {
     IlRec* recs; size_t nrec, crec;
     IlAttr* attrs; size_t nattr, cattr;
-    uint32_t open[LEPTRIS_IL_MAX_DEPTH];
-    uint32_t last_child[LEPTRIS_IL_MAX_DEPTH];
+    /* Depth stacks (leptris#1577): the fixed buffers serve the
+     * default 256 cap; a configured max depth above that switches
+     * the pointers to one heap block. Owned by leptris_il_scan —
+     * initialized at entry, released at every exit; callers never
+     * touch these directly. */
+    uint32_t open_buf[LEPTRIS_IL_MAX_DEPTH];
+    uint32_t last_child_buf[LEPTRIS_IL_MAX_DEPTH];
+    uint32_t* open;
+    uint32_t* last_child;
+    void* stack_heap;
     int depth;
 } IlCtx;
 

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

@@ -88,6 +88,37 @@ static XsdAssert* xsd_capture_assert(struct leptris_xsd_schema* s,
                                      LeptrisElement e);
 static XsdCm* xsd_capture_any(LeptrisElement any_child);
 static char* xsd_capture_any_attr_ns(LeptrisElement container);
+
+/* #1626: prefixed QName refs (type="w:CT_Border") resolve by local
+ * name — the engine's tables key on local names; the prefix maps
+ * to a namespace the name-based resolution folds away. Returns the
+ * local part after the colon when present, else the argument. */
+static char xsd_qname_buf[8][512];
+static int xsd_qname_slot;
+
+static const char* xsd_local_name(const char* qname) {
+    if (!qname) return NULL;
+    const char* colon = strchr(qname, ':');
+    if (!colon) return qname;
+    /* xs:/xsd: are builtin references — canonize to "xs:local" so
+     * text_valid's dispatch matches both spellings (xsd:-spelled
+     * types were silently untyped before #1626). */
+    size_t pl = (size_t)(colon - qname);
+    if ((pl == 2 && strncmp(qname, "xs", 2) == 0) ||
+        (pl == 3 && strncmp(qname, "xsd", 3) == 0)) {
+        if (pl == 2) return qname;
+        char* dst = xsd_qname_buf[xsd_qname_slot++ & 7];
+        dst[0] = 'x';
+        dst[1] = 's';
+        dst[2] = ':';
+        snprintf(dst + 3, sizeof(xsd_qname_buf[0]) - 3, "%s",
+                 colon + 1);
+        return dst;
+    }
+    /* a foreign prefix maps to a namespace; the name-based tables
+     * resolve by local name */
+    return colon + 1;
+}
 static void xsd_capture_alternatives(struct leptris_xsd_schema* s,
                                      LeptrisElement decl_elem,
                                      XsdElementDecl* d);
@@ -193,12 +224,14 @@ static XsdCm* xsd_cm_parse(struct leptris_xsd_schema* s,
             if (cm) {
                 const char* nm =
                     leptris_element_attribute(e, "name");
-                if (!nm) nm = leptris_element_attribute(e, "ref");
+                if (!nm)
+                    nm = xsd_local_name(
+                        leptris_element_attribute(e, "ref"));
                 cm->name = xsd_strdup(nm);
                 const char* pty =
                     leptris_element_attribute(e, "type");
                 if (pty) {
-                    cm->type = xsd_strdup(pty);
+                    cm->type = xsd_strdup(xsd_local_name(pty));
                 } else if (s && nm) {
                     /* #1592: inline anonymous type on the particle */
                     char synth[512];
@@ -212,8 +245,8 @@ static XsdCm* xsd_cm_parse(struct leptris_xsd_schema* s,
              * forward references need no capture order */
             cm = xsd_cm_new(XSD_CM_GROUP_REF);
             if (cm)
-                cm->name = xsd_strdup(
-                    leptris_element_attribute(e, "ref"));
+                cm->name = xsd_strdup(xsd_local_name(
+                    leptris_element_attribute(e, "ref")));
         } else if (strcmp(local, "any") == 0) {
             cm = xsd_cm_new(XSD_CM_ANY);
             if (cm) {
@@ -273,7 +306,8 @@ static XsdSimple* xsd_capture_simple(LeptrisElement st) {
         if (!local) continue;
         if (strcmp(local, "list") == 0) {
             simple->deriv = XSD_SIMPLE_LIST;
-            const char* it = leptris_element_attribute(e, "itemType");
+            const char* it = xsd_local_name(
+                leptris_element_attribute(e, "itemType"));
             if (it && *it) {
                 simple->item_type = xsd_strdup(it);
             } else {
@@ -346,8 +380,8 @@ static XsdSimple* xsd_capture_simple(LeptrisElement st) {
                 simple->member_defs[simple->member_def_count++] = def;
             }
         } else if (strcmp(local, "restriction") == 0) {
-            simple->base =
-                xsd_strdup(leptris_element_attribute(e, "base"));
+            simple->base = xsd_strdup(xsd_local_name(
+                leptris_element_attribute(e, "base")));
             for (LeptrisNodeRef f = leptris_node_first_child(
                      leptris_element_as_node(e));
                  f; f = leptris_node_next_sibling(f)) {
@@ -694,9 +728,16 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                         /* same-namespace merges and no-namespace
                          * chameleon includes; foreign-namespace
                          * imports stay lax at this tier */
+                        /* xs:include: same-namespace (or
+                         * chameleon — the no-tns form adopts ours).
+                         * xs:import: foreign namespaces are the
+                         * point — merge regardless (#1626: wml-2010
+                         * shape imports were skipped when the
+                         * compiler had its own targetNamespace). */
+                        int same_ns = subroot && (!tns || !s->target_ns ||
+                                                  strcmp(tns, s->target_ns) == 0);
                         if (subroot &&
-                            (!tns || !s->target_ns ||
-                             strcmp(tns, s->target_ns) == 0)) {
+                            (strcmp(local, "import") == 0 || same_ns)) {
                             s->include_depth++;
                             xsd_capture_root(s, subroot);
                             s->include_depth--;
@@ -719,7 +760,7 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                     (XsdElementDecl*)calloc(1, sizeof(*d));
                 if (d) {
                     d->name = xsd_strdup(nm);
-                    d->type = xsd_strdup(ty);
+                    d->type = xsd_strdup(xsd_local_name(ty));
                     xsd_capture_alternatives(s, (LeptrisElement)n, d);
                     d->fixed = xsd_strdup(
                         leptris_element_attribute((LeptrisElement)n,
@@ -789,9 +830,9 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                 XsdAttrDecl* d = (XsdAttrDecl*)calloc(1, sizeof(*d));
                 if (d) {
                     d->name = xsd_strdup(nm);
-                    d->type = xsd_strdup(
+                    d->type = xsd_strdup(xsd_local_name(
                         leptris_element_attribute((LeptrisElement)n,
-                                                  "type"));
+                                                  "type")));
                     d->fixed = xsd_strdup(
                         leptris_element_attribute((LeptrisElement)n,
                                                   "fixed"));
@@ -1141,8 +1182,9 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                 if (!dl || (strcmp(dl, "extension") != 0 &&
                             strcmp(dl, "restriction") != 0))
                     continue;
-                const char* base =
+                const char* base_raw =
                     leptris_element_attribute(dq, "base");
+                const char* base = xsd_local_name(base_raw);
                 XsdCm* base_root =
                     (base && strncmp(base, "xs:", 3) != 0)
                         ? xsd_find_complex(s, base)
@@ -1199,8 +1241,8 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                 if (!dl || (strcmp(dl, "extension") != 0 &&
                             strcmp(dl, "restriction") != 0))
                     continue;
-                const char* base =
-                    leptris_element_attribute(dq, "base");
+                const char* base = xsd_local_name(
+                    leptris_element_attribute(dq, "base"));
                 if (base) {
                     if (strncmp(base, "xs:", 3) == 0) {
                         root->text_type = xsd_strdup(base);
@@ -1434,8 +1476,8 @@ static XsdAttrDecl* xsd_capture_attr_rows(struct leptris_xsd_schema* s,
             if (!d) continue;
             if (an) {
                 d->name = xsd_strdup(an);
-                d->type = xsd_strdup(
-                    leptris_element_attribute(ae, "type"));
+                d->type = xsd_strdup(xsd_local_name(
+                    leptris_element_attribute(ae, "type")));
                 if (!d->type)
                     d->type = xsd_strdup(
                         xsd_inline_attr_type(s, ae, an));
@@ -1444,8 +1486,8 @@ static XsdAttrDecl* xsd_capture_attr_rows(struct leptris_xsd_schema* s,
                 d->required = (use && strcmp(use, "required") == 0);
             } else {
                 /* ref to a top-level attribute declaration */
-                const char* ref =
-                    leptris_element_attribute(ae, "ref");
+                const char* ref = xsd_local_name(
+                    leptris_element_attribute(ae, "ref"));
                 const XsdAttrDecl* src =
                     ref ? xsd_find_top_attr(s, ref) : NULL;
                 if (!src) {
@@ -1465,8 +1507,8 @@ static XsdAttrDecl* xsd_capture_attr_rows(struct leptris_xsd_schema* s,
                 head = d;
             tail = d;
         } else if (strcmp(al, "attributeGroup") == 0) {
-            const char* ref =
-                leptris_element_attribute(ae, "ref");
+            const char* ref = xsd_local_name(
+                leptris_element_attribute(ae, "ref"));
             if (!ref) continue;
             XsdAttrGroupDef* g = s->attr_groups;
             for (; g; g = g->next)

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

@@ -208,12 +208,56 @@ static void validate_children(struct xsd_validator* v,
     }
     int ok = xsd_content_valid(s, model, xsd_target_ns(s), names, uris,
                                n);
-    free(names);
-    free(uris);
-    if (!ok) {
+    if (ok) {
+        free(names);
+        free(uris);
+    } else {
+        /* Name the culprit: libxml2 names the offending child once
+         * and recovers; the unnamed form cascaded ambiguously
+         * (#1626 — 353 errors for one misordered pair). Greedy
+         * linear match against the sequence's particle list;
+         * non-sequence models keep the generic message. */
+        const char* culprit = NULL;
+        if (model->kind == XSD_CM_SEQ) {
+            XsdCm* parts[256];
+            size_t j = 0;
+            for (XsdCm* q = model->first_child; q && j < 256;
+                 q = q->next)
+                parts[j++] = q;
+            size_t pj = 0;
+            for (size_t k2 = 0; k2 < n && !culprit; k2++) {
+                const char* uri = uris ? uris[k2] : NULL;
+                int matched = 0;
+                while (pj < j) {
+                    XsdCm* q = parts[pj];
+                    if (q->name && strcmp(q->name, names[k2]) == 0 &&
+                        (!q->ns ||
+                         (uri && strcmp(uri, q->ns) == 0))) {
+                        matched = 1;
+                        pj++;
+                        break;
+                    }
+                    if (q->min == 0) {
+                        pj++; /* skippable optional: not expected here */
+                        continue;
+                    }
+                    culprit = names[k2]; /* expected q, found this */
+                    break;
+                }
+                if (!matched && !culprit) culprit = names[k2];
+            }
+        }
         const char* local = NULL;
         leptris_element_expanded_name(elem, &local, NULL, NULL);
-        verrf(v, "element", local, "children do not match the content model");
+        char msg[256];
+        snprintf(msg, sizeof(msg),
+                 culprit
+                     ? "children do not match the content model (at '%s')"
+                     : "children do not match the content model",
+                 culprit ? culprit : "");
+        verrf(v, "element", local, msg);
+        free(names);
+        free(uris);
     }
     /* recurse: a global declaration governs the child when one
      * exists; otherwise the parent's particle declaration does

data/vendor-src/libleptris/test/abi/test_descriptor.cpp

@@ -2163,15 +2163,21 @@ TEST(Plan408, ResultBuildFeedsSerialize) {
     leptris_plan_row_op ops[] = {
         {LEPTRIS_PLAN_OP_ELEMENT, 0, UINT32_MAX, NULL, NULL, 0},
         {LEPTRIS_PLAN_OP_ATTR, 0, UINT32_MAX, "id", "7", 1},
-        {LEPTRIS_PLAN_OP_SCALAR, 0, 0, NULL, "first", 5},
+        {LEPTRIS_PLAN_OP_SCALAR, 0, 0, NULL, "alpha", 5},
+        {LEPTRIS_PLAN_OP_SCALAR, 0, 0, NULL, "beta", 4},
+        {LEPTRIS_PLAN_OP_SCALAR, 0, 0, NULL, "gamma", 5},
         {LEPTRIS_PLAN_OP_END, 0, UINT32_MAX, NULL, NULL, 0},
     };
     LeptrisPlanResult r =
-        leptris_plan_result_build(plan, ops, 4, &st);
+        leptris_plan_result_build(plan, ops, 6, &st);
     ASSERT_NE(r, nullptr);
     char* out = leptris_plan_serialize(plan, r, &st);
     ASSERT_NE(out, nullptr);
-    EXPECT_STREQ(out, "<b id=\"7\"><p>first</p></b>");
+    /* #1625: multi-member order is the OP order on every platform
+     * (position ties fell to unstable qsort and reversed members
+     * on Windows) */
+    EXPECT_STREQ(out,
+                 "<b id=\"7\"><p>alpha</p><p>beta</p><p>gamma</p></b>");
     leptris_free_string(out);
     leptris_plan_result_free(r);
     leptris_plan_free(plan);

data/vendor-src/libleptris/test/parser/test_parser.cpp

@@ -233,6 +233,36 @@ TEST(ParserConfigurableDepth, LowerCapRejectsShallowerNesting) {
     leptris_set_max_depth(0);
 }
 
+/* leptris#1577: the open-tag guard honors the configured max depth
+ * while the parser's depth stacks were fixed at DP_MAX_DEPTH (256) —
+ * any document deeper than 256 under a raised cap wrote past the
+ * stacks (layout-dependent state corruption). The stacks now size to
+ * the cap; a 600-deep document must parse and walk cleanly. */
+TEST(ParserConfigurableDepth, DeepDocumentUnderRaisedCap) {
+    leptris_set_max_depth(1024);
+    std::string xml;
+    for (int i = 0; i < 600; i++) xml += "<d>";
+    xml += 'x';
+    for (int i = 0; i < 600; i++) xml += "</d>";
+
+    LeptrisStatus st;
+    LeptrisDocument doc = leptris_parse_string(xml.data(), xml.size(), &st);
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement root = leptris_document_root(doc);
+    ASSERT_NE(root, nullptr);
+
+    /* Walk to the spine bottom: 600 opens must survive intact. */
+    int depth_seen = 0;
+    LeptrisElement e = root;
+    while (e) {
+        depth_seen++;
+        e = leptris_element_first_child_any(e);
+    }
+    EXPECT_EQ(depth_seen, 600);  /* the spine: 600 nested <d> */
+    leptris_document_free(doc);
+    leptris_set_max_depth(0);
+}
+
 TEST(ParserConfigurableDepth, GetReturnsEffectiveValue) {
     leptris_set_max_depth(0);
     EXPECT_EQ(leptris_get_max_depth(), 256);

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

@@ -1499,3 +1499,128 @@ TEST(XsdValidate, UndeclaredAttributeIsStrictUnlessAnyAttribute) {
 }
 
 }  // namespace
+
+// ---- #1626: cross-ns imports, prefixed refs, error cascade -----
+namespace {
+
+/* 1. cross-namespace xs:import registers its declarations when the
+ * compiling schema carries its own targetNamespace (the wml-2010
+ * shape). Chameleon/same-ns worked; foreign imports were skipped. */
+TEST(XsdImport1626, CrossNamespaceImportRegisters) {
+    std::string dir = ::testing::TempDir();
+    FILE* f1 = fopen((dir + "x6shared.xsd").c_str(), "wb");
+    ASSERT_NE(f1, nullptr);
+    const char* shared =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " xmlns:w=\"urn:shared\""
+        " targetNamespace=\"urn:shared\">"
+        "<xs:complexType name=\"CT_Border\">"
+        "<xs:attribute name=\"val\" type=\"xs:token\"/>"
+        "</xs:complexType>"
+        "</xs:schema>";
+    fwrite(shared, 1, strlen(shared), f1);
+    fclose(f1);
+    FILE* f2 = fopen((dir + "x6main.xsd").c_str(), "wb");
+    ASSERT_NE(f2, nullptr);
+    /* the importing schema has ITS OWN target namespace and
+     * references the imported type through the shared prefix */
+    const char* mainx =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " xmlns:w=\"urn:shared\""
+        " targetNamespace=\"urn:main\">"
+        "<xs:import namespace=\"urn:shared\""
+        " schemaLocation=\"x6shared.xsd\"/>"
+        "<xs:element name=\"b\">"
+        "<xs:complexType>"
+        "<xs:attribute name=\"id\" type=\"xs:integer\"/>"
+        "<xs:attribute name=\"bd\" type=\"w:CT_Border\"/>"
+        "</xs:complexType>"
+        "</xs:element>"
+        "</xs:schema>";
+    fwrite(mainx, 1, strlen(mainx), f2);
+    fclose(f2);
+
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile_file((dir + "x6main.xsd").c_str(), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    /* the imported type resolves: the attribute types */
+    LeptrisDocument d = leptris_parse_string(
+        "<b id=\"1\" bd=\"x\"/>", strlen("<b id=\"1\" bd=\"x\"/>"), &st);
+    ASSERT_NE(d, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, d), 1);
+    leptris_document_free(d);
+    leptris_xsd_free(s);
+    remove((dir + "x6shared.xsd").c_str());
+    remove((dir + "x6main.xsd").c_str());
+}
+
+/* 3. prefixed type refs resolve by local name (uniword's
+ * default-xmlns spelling always worked; the w: spelling did not) */
+TEST(XsdImport1626, PrefixedTypeRefsResolve) {
+    const char* x =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " xmlns:w=\"urn:x\" targetNamespace=\"urn:x\">"
+        "<xs:complexType name=\"CT_Border\">"
+        "<xs:attribute name=\"v\" type=\"xs:integer\"/>"
+        "</xs:complexType>"
+        "<xs:complexType name=\"CT_Wrap\">"
+        "<xs:sequence>"
+        "<xs:element name=\"b\" type=\"w:CT_Border\"/>"
+        "</xs:sequence>"
+        "</xs:complexType>"
+        "<xs:element name=\"r\" type=\"w:CT_Wrap\"/>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(x, "<r><b v=\"1\"/></r>"), 1);
+    EXPECT_EQ(validate_doc(x, "<r><b v=\"z\"/></r>"), 0);
+}
+
+/* 2. error amplification: one misordered child reports ONCE, with
+ * the offending child named — not once per ancestor (~175x) */
+TEST(XsdImport1626, MisorderReportsOnceNamed) {
+    const char* x =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:complexType name=\"CT_TblBorders\">"
+        "<xs:sequence>"
+        "<xs:element name=\"top\" type=\"xs:token\"/>"
+        "<xs:element name=\"right\" type=\"xs:token\"/>"
+        "<xs:element name=\"insideH\" type=\"xs:token\"/>"
+        "</xs:sequence>"
+        "</xs:complexType>"
+        "<xs:complexType name=\"CT_TblPr\">"
+        "<xs:sequence>"
+        "<xs:element name=\"borders\" type=\"CT_TblBorders\"/>"
+        "<xs:element name=\"width\" type=\"xs:integer\"/>"
+        "</xs:sequence>"
+        "</xs:complexType>"
+        "<xs:complexType name=\"CT_Tbl\">"
+        "<xs:sequence>"
+        "<xs:element name=\"tblPr\" type=\"CT_TblPr\"/>"
+        "<xs:element name=\"row\" type=\"xs:token\"/>"
+        "</xs:sequence>"
+        "</xs:complexType>"
+        "<xs:element name=\"tbl\" type=\"CT_Tbl\"/>"
+        "</xs:schema>";
+    /* insideH before right: the classic wml minimal case */
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile(x, strlen(x), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    const char* bad =
+        "<tbl><tblPr><borders><top/><insideH/><right/>"
+        "</borders><width>5</width></tblPr><row/></tbl>";
+    LeptrisDocument d = leptris_parse_string(bad, strlen(bad), &st);
+    ASSERT_NE(d, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, d), 0);
+    size_t n = leptris_xsd_error_count(s);
+    EXPECT_LE(n, 3u) << "amplified: " << n << " errors";
+    if (n > 0) {
+        const char* e = leptris_xsd_error_at(s, 0);
+        EXPECT_NE(e, nullptr);
+        EXPECT_NE(strstr(e, "insideH"), nullptr)
+            << "first error names the offending child: " << e;
+    }
+    leptris_document_free(d);
+    leptris_xsd_free(s);
+}
+
+}  // namespace

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.334",
+  "version": "1.9.336",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.334.1
+  version: 1.9.336.0
 platform: ppc64le-linux
 authors:
 - Ribose Inc.