leptris 1.9.334.0-ppc64le-linux → 1.9.335.0-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c687c6b5c09c8f7ec7bd48a26c197318f6f2a396680075a39f2cbfe445eb9c8
-  data.tar.gz: 458aac071ab017d4bc2192bb9e1ac2c2c003edf631a058a16eb5446d1051e4f1
+  metadata.gz: a28806b919f8a4a8c3afff49f972713477e6c48aba6290ce988ec494a5564907
+  data.tar.gz: b3c61e5b3304608da316db83dfc3e2e911fc5914bf8fca78ed4ad8a1889a47ba
 SHA512:
-  metadata.gz: f3cacf66947185632eda797cc645d036978912e5acb10726a83c615db019ced9ffe6146411321ee47ffdb521f64d25f7f9789af7dd1938c2d7809bbf260a522d
-  data.tar.gz: 4efeebf09318e7c65ef475fc3fc05c44fa7597226fd8f087f26acac28d50b3a79c76fc574ff2937aa2436d2c16ac30aa5f9769813358e005f3a757701afd9c46
+  metadata.gz: c8275ee8cc2269f43a68aa94eb19722de3ed04aa0c8309d263c97bda37d05cea06b96092b01bc389d646a89f84f330e7630a1b4712082798a8e3af5806318297
+  data.tar.gz: 491b13abf8b1e1d60b2e9aeca96ba41e847eaf308b3ba367488c215bd1d071d9bf74136915a50759ece0c6a068f670e9aea04563265041efae5d6c378951f57f

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## [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
+
+- **The attach paths stop minting FFI::Pointer wrappers per node
+  (#408 Ask 1)**: every native fast path read the canonical
+  Integer address through `c_ptr.address` — lazily materializing
+  a Pointer per node handed to one C call — instead of the
+  `c_address` twin. The FFI-fallback append paths route through
+  `leptris_element_add_child_addr` (both sides as Integers; same
+  status contract). Measured on the object-mode build(500):
+  FFI::Pointer allocations 1002 → 2 (the document/root wrappers
+  that genuinely need one), ~4% CPU off the build row under
+  load. Ask 2's face (`Descriptor#build_result`) shipped in
+  1.9.334.0.
+
 ## [1.9.334.0] - 2026-10-10
 
 ### Added — engine sync (libleptris 1.9.332-1.9.334)

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.335"
 # 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.0"
+  VERSION = "1.9.335.0"
 end

data/lib/leptris/xml/element.rb

@@ -386,7 +386,7 @@ class Leptris::XML::Element < Leptris::XML::Node
     # build appends.
     return true unless node.is_a?(Leptris::XML::Element)
     return false unless defined?(Leptris::XML::NATIVE_FAST)
-    !Leptris::XML::Native.ns_lift_needed?(node.c_ptr.address)
+    !Leptris::XML::Native.ns_lift_needed?(node.c_address)
   end
 
   # A node is foreign to +document+ when it belongs to another one
@@ -445,7 +445,7 @@ class Leptris::XML::Element < Leptris::XML::Node
     end
     if native_fast_children?
       unless Leptris::XML::Native.insert_binding_child(
-        @document, @c_address, node.c_ptr.address, 1).nil?
+        @document, @c_address, node.c_address, 1).nil?
         return node
       end
     end
@@ -478,7 +478,7 @@ class Leptris::XML::Element < Leptris::XML::Node
     end
     if native_fast_children?
       unless Leptris::XML::Native.insert_binding_child(
-        @document, @c_address, node.c_ptr.address, 2).nil?
+        @document, @c_address, node.c_address, 2).nil?
         return node
       end
     end
@@ -511,7 +511,7 @@ class Leptris::XML::Element < Leptris::XML::Node
     end
     if native_fast_children?
       unless Leptris::XML::Native.insert_binding_child(
-        @document, @c_address, node.c_ptr.address, 3).nil?
+        @document, @c_address, node.c_address, 3).nil?
         return node
       end
     end
@@ -556,7 +556,7 @@ class Leptris::XML::Element < Leptris::XML::Node
     end
     cross = nodes.any? { |n| Leptris::XML::Element.foreign_to?(n, @document) }
     if native_fast_children?
-      addrs = nodes.map { |n| n.c_ptr.address }
+      addrs = nodes.map { |n| n.c_address }
       done = Leptris::XML::Native.append_binding_children(
         @document, @c_address, addrs)
       done = 0 unless done.is_a?(Integer)
@@ -698,7 +698,7 @@ class Leptris::XML::Element < Leptris::XML::Node
         # The face raises on failure (TODO.perf/36); Qnil = the
         # child needs the lift — the full path handles it.
         unless Leptris::XML::Native.append_binding_child(
-          @document, @c_address, node_or_markup.c_ptr.address).nil?
+          @document, @c_address, node_or_markup.c_address).nil?
           return node_or_markup
         end
       end
@@ -706,8 +706,11 @@ class Leptris::XML::Element < Leptris::XML::Node
       unless Leptris::XML::Element.skip_adoption_lift?(node_or_markup)
         Leptris::XML::Element.lift_namespaces_for_adoption(node_or_markup, namespaces)
       end
+      # Address-based attach (#408): same status contract, no
+      # FFI::Pointer mint for either side.
       Leptris::XML::FFI.check_status(
-        Leptris::XML::FFI.leptris_element_append_child(c_ptr, node_or_markup.c_ptr))
+        Leptris::XML::FFI.leptris_element_add_child_addr(
+          @c_address, node_or_markup.c_address))
       node_or_markup
     when String
       # TODO.perf/34: one dispatch parses the markup and appends
@@ -732,7 +735,8 @@ class Leptris::XML::Element < Leptris::XML::Node
       added = []
       frag.children.each do |n|
         Leptris::XML::FFI.check_status(
-          Leptris::XML::FFI.leptris_element_append_child(c_ptr, n.c_ptr))
+          Leptris::XML::FFI.leptris_element_add_child_addr(
+            @c_address, n.c_address))
         added << n
       end
       Leptris::XML::NodeSet.new(@document, added)
@@ -753,7 +757,8 @@ class Leptris::XML::Element < Leptris::XML::Node
       Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
     end
     Leptris::XML::FFI.check_status(
-      Leptris::XML::FFI.leptris_element_append_child(c_ptr, node.c_ptr))
+      Leptris::XML::FFI.leptris_element_add_child_addr(
+        @c_address, node.c_address))
     Leptris::XML::Node.invalidate_cross_document!(node, @document)
     remove_from_source_original(node)
     last_installed

data/lib/leptris/xml/native_layer.rb

@@ -27,6 +27,12 @@ begin
   if Gem.win_platform?
     require "leptris/xml/native_#{RUBY_VERSION[/\A\d+\.\d+/].tr('.', '_')}"
   else
+    # #1623: the bundle beside this file must carry a valid
+    # signature before dyld maps it — pre-verify and re-stamp.
+    Leptris.resign_bundle_if_needed(
+      File.expand_path(
+        "native#{RUBY_PLATFORM.include?('darwin') ? '.bundle' : '.so'}",
+        __dir__))
     require "leptris/xml/native"
   end
 rescue LoadError => e

data/lib/leptris.rb

@@ -3,6 +3,23 @@
 require "leptris/version"
 
 module Leptris
+  # leptris#1623: macOS 14.x dyld intermittently SIGKILLs native
+  # bundles whose adhoc signature went stale (post-build byte
+  # rewrites) or is absent (x86_64 links carry none by default).
+  # A kill cannot be rescued — pre-verify and re-stamp BEFORE dyld
+  # ever sees the binary. Adhoc is deterministic and needs no
+  # identity; Developer ID rides owner secrets when wired.
+  def self.resign_bundle_if_needed(path)
+    return false unless path && File.exist?(path)
+    return false unless RUBY_PLATFORM.include?("darwin")
+    return true if system("codesign", "--verify", path.to_s,
+                          out: File::NULL, err: File::NULL)
+    system("codesign", "--force", "--sign", "-", path.to_s,
+           out: File::NULL, err: File::NULL) &&
+      system("codesign", "--verify", path.to_s,
+             out: File::NULL, err: File::NULL)
+  end
+
   autoload :XML, "leptris/xml"
   # One file, three entry constants (HTML/HTML4/HTML5) — each
   # autoload maps so any reference loads the facade.

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.335
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,32 @@
 ## [Unreleased]
 
+## [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.335
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

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/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.335",
   "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.0
+  version: 1.9.335.0
 platform: ppc64le-linux
 authors:
 - Ribose Inc.