leptris 1.9.418.1-ppc64le-linux → 1.9.420.0-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c689812db7e1cb340db6b33aa9b1740d6aa74d0fd4b9f0a31093b4fd7a634b25
-  data.tar.gz: 2ecb0d6953d0ea924e5f19560445c24d8eeaa9da9098f81818d65bd948a37f7b
+  metadata.gz: bfd921282d6b7f1c27ed608e90ecd9e827f597ff5ee17453139d71e59f197a94
+  data.tar.gz: db3496c29df65697e748d121535355399ca2b1732022ebd03493461c1704de11
 SHA512:
-  metadata.gz: bf2be4df8c1fadeb4122f6bfdd47e91bf39f043e5a2b6145f9b597e8027ca4ece5cc0ae6501b0df9f386d8df29d671c68910497af8f436e403b5c0f4b8a2485a
-  data.tar.gz: 3b527998d6aa9b59046d64d6a420ebd51eafade821b3fb454dfc539441038c84efa8fae76b1d52aa914162b82e7d87f2316b74b1445e5918b7002a3b2d372cff
+  metadata.gz: a70bb31f1cfbab7a36a96626e4b3ec578dbfd4e3b9a12d35d487a094356c445fdb2475c8e6d8122eb79bc2bf38f7b6b4856fc406465ea694a086b570a5bc61a9
+  data.tar.gz: 36acd6a66bcd6dc5d78115ef6461d53cddf627d06374f1631c5246affd2cd4b0e96e032d9bace7784a51d511202edb2574306fc24504219652689479c1da1cac

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.418"
+LIBLEPTRIS_VERSION = "1.9.420"
 # 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/ext/leptris/native/native.c

@@ -1681,6 +1681,42 @@ static VALUE nn_set_root(VALUE klass, VALUE document, VALUE element)
     return element;
 }
 
+/* TODO.perf/39(a) (leptris-ruby#622 ask 1): hot readers
+ * parameterized by subclass. Consumers whose wrapper classes SUBCLASS
+ * NativeNode (klass injection, #340) shadow these C methods with
+ * included Ruby modules — every shadowed read pays an
+ * UnboundMethod#bind_call frame (~the whole difference between the
+ * facade's ~331ns reads and the binding's ~160ns seam). This entry
+ * defines the SAME C functions (same bodies, same walk-memos, same
+ * TypedData type) DIRECTLY on the consumer's subclass, so lookup
+ * answers in C with no module shadow in the chain.
+ *
+ * The consumer decides which classes get the hot surface: a
+ * per-document klass map (#340) can route entity-bearing documents
+ * to contract classes and clean documents to hot classes, keeping
+ * any Ruby-side value post-processing exactly where it is still
+ * needed.
+ *
+ * Re-defining a method that already exists on the class replaces it
+ * (Ruby semantics); calling twice is harmless. The class must be the
+ * consumer's NativeNode subclass or NativeNode itself — a non-
+ * TypedData class would crash on first read, so the type is checked
+ * here against the registry. */
+static VALUE nf_define_hot_readers(VALUE self, VALUE klass)
+{
+    (void)self;
+    if (!RB_TYPE_P(klass, T_CLASS))
+        rb_raise(rb_eTypeError, "expected a class");
+    if (klass != c_native_node &&
+        rb_class_inherited_p(klass, c_native_node) != Qtrue)
+        rb_raise(rb_eTypeError,
+                 "the class must subclass Leptris::XML::NativeNode");
+    rb_define_method(klass, "name", nn_name, 0);
+    rb_define_method(klass, "content", nn_content, 0);
+    rb_define_method(klass, "attribute", nn_attribute, 1);
+    return Qtrue;
+}
+
 /* NativeNode surface completion (TODO.perf/05): bulk attribute
  * hash (name => value, one C walk, no per-attr Ruby frames) and
  * the position readers. */
@@ -4350,6 +4386,8 @@ static void leptris_native_setup(void)
                               nf_append_binding_child, 3);
     rb_define_module_function(m_native, "set_binding_attribute",
                               nf_set_binding_attribute, 4);
+    rb_define_module_function(m_native, "define_hot_readers",
+                              nf_define_hot_readers, 1);
     rb_define_module_function(m_native, "insert_binding_child",
                               nf_insert_binding_child, 4);
     rb_define_module_function(m_native, "at_xpath_first",

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.418.1"
+  VERSION = "1.9.420.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.418
+- libleptris v1.9.420
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## [Unreleased]
 
+## [1.9.420] - 2026-11-13
+### Fixed
+
+- **xsd: the element fixed constraint compares in the value space** (leptris-rs#74, W3C stE065/066/096). Union-typed elements' final equality ran strcmp-level lexicals — the accepting member's whitespace semantics never applied. The token family and normalizedString now equate collapse-equal spellings (`fixed="abcd edfgh "` admits `abcd edfgh`, `fixed="ENU "` admits `ENU`), and LIST-typed elements itemize both lexicals on whitespace runs before per-item union comparison (a list of gYear/gMonth/gDay equates single- and double-space item separation). The collapse normalization is factored and shared with the attribute fixed path; preserve-types (xs:string) still compare exactly.
+
+- **xsd: the §4.2.2 redefine hook splices the original attributeGroup** (the engine root of lutaml/moxml#545, W3C attgC035-038). An attributeGroup-redefine body that refs its OWN name means the ORIGINAL group — the name-keyed slot held the redefining body itself, so expanding it looped through the depth guard and the original's members never joined the composition (strict admission false-reports "not declared (strict)"). The rows capture threads the def being expanded; a self-ref resolves to the shadowed def. attgC038's chained double-redefine composes through the same path.
+
+## Tests
+
+- stE065/066/096 + attgC035/036/037/038 vendored from w3c/xsdtests as pins; the union fixed change is falsified by a no-op-collapse mutation (fails exactly the value-space pin, passes the teeth pin — a genuinely different value still fails). Full ctest 2269/2269.
+
+
+
+## [1.9.419] - 2026-11-12
+### Fixed
+
+- **xsd: wildcards ride attributeGroup refs across units** (leptris-rs#72, W3C wildZ013b/c). The #1964 deep capture left two holes: the extension branch still scanned shallow, so a wildcard living inside a REFERENCED attributeGroup under the extension element was invisible (strict admission rejected attributes the composed union admits); and a wildcard found in a group from ANOTHER unit (a namespace-less import) resolved against the CONSUMING schema's targetNamespace instead of its declaring unit's — `##other` flipped meaning across the boundary and the union collapsed to admitting only half the instance's attribute namespaces. The capture now follows refs in the extension branch and carries the declaring group's own unit tns (absent for the import).
+
+- **xsd: a bare `<xs:anyAttribute />` is a live ##any wildcard** (leptris-rs#73, W3C attZ014a/b). Absent @namespace means ##any (the moxml#460 posture) — the capture mapped it to NULL, an invisible wildcard, so wildcard-admitted attributes fell to strict rejection for the wrong reason. With admission live, XSD 1.0's one-ID-per-element rule fires: an element assessed with more than one ID-typed attribute (declared rows AND wildcard-admitted names whose global declaration is ID-derived) is invalid; XSD 1.1 lifted the constraint and reads the same shape valid. The rule is version-gated (`xsd_schema_version_11`).
+
+## Tests
+
+- wildZ013b/c + attZ014a/b fixtures vendored from w3c/xsdtests (msData/wildcards, msData/attribute); attZ014a also pinned under `@version="1.1"` (valid). Falsified: an always-false ID test failed exactly the two 1.0 pins and passed the 1.1 reading.
+
+
+
 ## [1.9.418] - 2026-11-12
 ## Fixed
 

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/TODO.max-perf/15-c-face-vs-pugixml.md

@@ -405,3 +405,109 @@ the loop-body surgery slice — it inherits the region-wrap probe
 
 RANKED CUT #1 therefore moves to the loop-surgery slice with the
 scan-merge as its first step. Nothing ships from the kernel alone.
+
+## Track D addendum 9 — the inline text-scan cut REJECTED by CI (PR #2018, closed)
+
+The ranked-#1 cut (inline 32-byte scalar prefix scan for short text
+runs, kernel for the remainder) went through the full gate: round 1
+caught the restart-at-run-start flaw (the kernel rescanned the
+scalar prefix — every leg regressed), round 2 fixed that (kernel
+from the prefix end) and STILL regressed on all three legs vs the
+A3d baselines (macos -39-46%, ubuntu-arm -26-27%, ubuntu-x86 -37-45%
+vs its AVX2 run). Cause: the bench-class run lengths (33-64B) sit
+exactly where the cut loses — 32 branchy scalar bytes plus a kernel
+pass over a 1-32B remainder exceeds the kernel alone, and runs
+<=32B are too few in these shapes to carry it.
+
+THE MISSING DATUM: the run-length distribution of the real fixtures
+and the scoreboard corpus. The next session's opening instrument =
+a run-length histogram (one counting pass per fixture, reusable),
+which decides whether the scan-merge has a paying window at all —
+and at what threshold. Until then the kernel stands unchanged; the
+PR closed with the full data (three legs, two rounds, CI artifacts).
+
+## Track D addendum 10 — the scan-merge slice CLOSED (PR #2020, closed unmerged)
+
+The 64-byte window (histogram-driven) went through the full gate and
+regressed WORSE than the 32-byte attempt: macos -45/-39/-46%, arm
+-32/-32/-29%, x86 -53/-53/-50% (vs the AVX2 run) — even for runs
+fully inside the window. THE VERDICT: the branchy scalar loop
+(~3-5 ops/byte) loses to the SIMD kernel (~1 op/byte) at every run
+length on every platform; the kernel's per-run fixed cost is small
+next to its per-byte advantage. The scan-merge slice is structurally
+dead — two windows, two full CI runs, one consistent verdict.
+
+THE TEXT-ROW LEVER REDIRECTS to the kernel's own per-byte
+throughput: the text_scan_run NEON kernel processes ~1 byte/op
+while pugixml's scanner sustains 2.1-2.7 GB/s — the Track A scanner
+class. The next concrete candidate: process 32B chunks (NEON
+registers ×2) per iteration instead of 16B, halving the reduction
+frequency; and the parser's text-branch call overhead already
+measures separably (the scalar wrapper at 2.2%).
+
+The histogram instrument (probe/run-histogram) remains in the repo
+history on probe/run-histogram; both rejected cut branches carry
+their full data.
+
+## Track D addendum 11 — the 32B kernel window measured-NEGATIVE (PR #2022, closed unmerged)
+
+The addendum-10 candidate (NEON text_scan_run at 32B windows — two
+uint8x16 registers, term masks OR-combined before ONE vmaxvq, halving
+the horizontal-reduction frequency) passed the full CI suite but the
+CI split was poisoned by fleet variance (x86 +31% on code the diff
+does not touch). The decisive instrument was a same-machine
+interleaved A/B on Apple silicon (Release+LTO, 3 rounds ABBA, pugixml
+side flat ~2370/1800 MB/s across rounds — machine verified stable):
+
+| shape | 16B (main) | 32B (PR) | delta |
+|-------|-----------|----------|-------|
+| 1.5MB | ~1341 MB/s | ~1144 MB/s | −15% |
+| 5MB   | ~1332 MB/s | ~1135 MB/s | −15% |
+| 13MB  | ~1029 MB/s | ~913 MB/s  | −11% |
+
+THE INVARIANT: horizontal-reduction frequency is NOT the binding term
+in text_scan_run on M-series. The accumulator chain is — two extra
+cmpeq+orr per register per window lengthen the dependency chain and
+raise live-register pressure (9+ Q registers) without removing any
+real per-byte work. Widening the window cannot pay; the kernel's
+per-byte op count is already minimal for its contract (first-term
+scan + f1/f2 seen-flags).
+
+TEXT-ROW STATUS after three measured closures (scan-merge 32B,
+scan-merge 64B, kernel-width 32B): the kernel is at its floor. The
+remaining text-row gap to pugixml is the parser's text-branch call
+overhead (the scalar wrapper measures separably at 2.2% — the only
+untried lever in this class), not the kernel.
+
+## Track D addendum 12 — the text-branch call-overhead class CLOSED (measured tie + the bound-vs-run datum)
+
+The named remainder from addendum 11 ("the parser's text-branch call
+overhead, the scalar wrapper at 2.2%") went through the full
+instrumentation pass and closes the class:
+
+1. **The microbench decomposition**: the dispatch entry costs 2-3x the
+   kernel's own work per call (7.1 vs 3.0 ns at 5B, 17.9 vs 6.9 ns at
+   31B) — the fn-pointer defeats thin-LTO and forces the full call ABI
+   plus per-call key re-materialization. A devirtualized cut (arch-
+   direct calls + a <16B scalar fast path) was implemented, pinned,
+   and mutation-falsified — and measured a DOC-LEVEL TIE in interleaved
+   A/B (−0.7/−2.3/−1.4%, inside the noise band). The microbench's
+   variant-B "win" was LTO INLINING the local kernel into the bench
+   loop — a zero-call comparison the real direct-call cut cannot
+   replicate across TUs.
+
+2. **The bound-vs-run instrument datum** (the decisive one): the
+   parser's scan calls pass the REMAINING BUFFER as `len`
+   (`p.end - p.pos`), not the run length — so a length-gated fast path
+   never engages in the parser context (bucket census on the bench
+   text fixture: <16B = 0 of 2.1M calls, 64+ = 99.999%). The
+   run-length histogram that motivated the fast path describes the
+   RUN distribution, which the kernel only knows after scanning.
+
+Disposition after four closures in the call-structure class
+(scan-merge 32B/64B, kernel-width 32B, devirtualization): **the
+text-branch call structure is at its floor.** The remaining text-row
+gap to pugixml is the kernel's per-byte throughput itself — and the
+accumulator chain that binds it was measured at addendum 11. Next
+text-row work, if any, is a kernel redesign (Track A scanner class),
+not call-structure rearrangement.

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

@@ -95,6 +95,10 @@ static XsdCm* xsd_cm_parse(struct leptris_xsd_schema* s,
 static XsdAttrDecl* xsd_capture_attr_rows(struct leptris_xsd_schema* s,
                                           LeptrisElement container,
                                           int depth);
+static XsdAttrDecl* xsd_capture_attr_rows_ex(struct leptris_xsd_schema* s,
+                                             LeptrisElement container,
+                                             int depth,
+                                             const XsdAttrGroupDef* owner);
 XsdCm* xsd_find_complex_ns(struct leptris_xsd_schema* s,
                            const char* type_name, const char* uri);
 extern XsdCm* xsd_find_complex(struct leptris_xsd_schema* s,
@@ -128,9 +132,9 @@ static char* xsd_capture_unit_tns(LeptrisElement e);
 static void xsd_resolve_qname(LeptrisElement e, const char* qname,
                               char* uri, size_t urisz, char* local,
                               size_t localsz);
-static char* xsd_capture_any_attr_ns(LeptrisElement container);
 static char* xsd_capture_any_attr_ns_deep(
-    struct leptris_xsd_schema* s, LeptrisElement container, int depth);
+    struct leptris_xsd_schema* s, LeptrisElement container, int depth,
+    char** out_unit);
 static char* xsd_capture_any_attr_not_qname(LeptrisElement container);
 
 /* #1626: prefixed QName refs (type="w:CT_Border") resolve by local
@@ -3257,13 +3261,26 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                 /* XSD 1.1: asserts nested under the derivation */
                 if (s->version_11)
                     xsd_capture_assert_children(s, dq, root);
-                if (!any_attr_ns)
+                if (!any_attr_ns) {
                     if (!any_attr_unit_ns)
                         any_attr_unit_ns = xsd_capture_unit_tns(dq);
-                    any_attr_ns = xsd_capture_any_attr_ns(dq);
+                    /* leptris-rs#72: the extension's wildcard rides
+                     * attributeGroup refs too — the shallow scan
+                     * misses attgD019/wildZ013 shapes. Cross-unit
+                     * found-groups carry their own tns. */
+                    char* deep_unit = NULL;
+                    any_attr_ns = xsd_capture_any_attr_ns_deep(
+                        s, dq, 0, &deep_unit);
+                    if (any_attr_ns && deep_unit) {
+                        free(any_attr_unit_ns);
+                        any_attr_unit_ns = deep_unit;
+                    } else {
+                        free(deep_unit);
+                    }
                     if (!any_attr_not_qname)
                         any_attr_not_qname =
                             xsd_capture_any_attr_not_qname(dq);
+                }
             }
         } else if (strcmp(local, "simpleContent") == 0) {
             for (LeptrisNodeRef q = leptris_node_first_child(
@@ -3344,8 +3361,19 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
         if (!attrs) attrs = xsd_capture_attr_rows(s, ct, 0);
         if (!any_attr_unit_ns)
             any_attr_unit_ns = xsd_capture_unit_tns(ct);
-        if (!any_attr_ns)
-            any_attr_ns = xsd_capture_any_attr_ns_deep(s, ct, 0);
+        if (!any_attr_ns) {
+            char* deep_unit = NULL;
+            any_attr_ns = xsd_capture_any_attr_ns_deep(s, ct, 0,
+                                                       &deep_unit);
+            if (any_attr_ns && deep_unit) {
+                /* the wildcard lives in a REFERENCED group from
+                 * another unit — its declaring tns wins */
+                free(any_attr_unit_ns);
+                any_attr_unit_ns = deep_unit;
+            } else {
+                free(deep_unit);
+            }
+        }
         if (!any_attr_not_qname)
             any_attr_not_qname = xsd_capture_any_attr_not_qname(ct);
     }
@@ -3455,7 +3483,9 @@ XsdGroupDef* xsd_find_group(struct leptris_xsd_schema* s,
     return NULL;
 }
 
-static const XsdAttrDecl* xsd_find_top_attr(
+/* leptris-rs#73: the global attribute declaration for a local name
+ * (the ID-count pass resolves wildcard-admitted names against it). */
+const XsdAttrDecl* xsd_find_top_attr(
     struct leptris_xsd_schema* s, const char* name) {
     if (!s || !name) return NULL;
     for (XsdAttrDecl* a = s->top_attrs; a; a = a->next)
@@ -3563,6 +3593,13 @@ static const char* xsd_inline_attr_type(
 static XsdAttrDecl* xsd_capture_attr_rows(struct leptris_xsd_schema* s,
                                           LeptrisElement container,
                                           int depth) {
+    return xsd_capture_attr_rows_ex(s, container, depth, NULL);
+}
+
+static XsdAttrDecl* xsd_capture_attr_rows_ex(struct leptris_xsd_schema* s,
+                                             LeptrisElement container,
+                                             int depth,
+                                             const XsdAttrGroupDef* owner) {
     XsdAttrDecl* head = NULL;
     XsdAttrDecl* tail = NULL;
     if (depth > 8) return NULL;
@@ -3635,6 +3672,18 @@ static XsdAttrDecl* xsd_capture_attr_rows(struct leptris_xsd_schema* s,
             XsdAttrGroupDef* g = s->attr_groups;
             for (; g; g = g->next)
                 if (strcmp(g->name, ref) == 0) break;
+            /* XSD 1.0 §4.2.2 redefine hook (moxml#545, attgC035-038):
+             * a body redefining group N refs N to mean the ORIGINAL
+             * group. The name-keyed slot may hold the redefining
+             * body itself — when expanding THAT def and the ref
+             * names it again, take the shadowed def instead, or the
+             * original's members never splice into the composition. */
+            if (g && g == owner) {
+                XsdAttrGroupDef* alt = g->next;
+                for (; alt; alt = alt->next)
+                    if (strcmp(alt->name, g->name) == 0) break;
+                g = alt;
+            }
             if (!g) continue;
             /* leptris#1957: expand lazily through the def's own
              * element when its rows are not captured yet (a group
@@ -3643,7 +3692,8 @@ static XsdAttrDecl* xsd_capture_attr_rows(struct leptris_xsd_schema* s,
              * the cycle guard. */
             XsdAttrDecl* copied =
                 g->attrs ? xsd_copy_attr_rows(g->attrs)
-                         : xsd_capture_attr_rows(s, g->elem, depth + 1);
+                         : xsd_capture_attr_rows_ex(s, g->elem, depth + 1,
+                                                    g);
             if (!copied) continue;
             if (!head)
                 head = copied;
@@ -3686,7 +3736,7 @@ static char* xsd_capture_unit_tns(LeptrisElement e) {
  * (depth-bounded); the group's OWN element is the walk root. */
 static char* xsd_capture_any_attr_ns_deep(
     struct leptris_xsd_schema* s, LeptrisElement container,
-    int depth) {
+    int depth, char** out_unit) {
     if (depth > 8) return NULL;
     for (LeptrisNodeRef ac = leptris_node_first_child(
              leptris_element_as_node(container));
@@ -3697,9 +3747,14 @@ static char* xsd_capture_any_attr_ns_deep(
         const char* al = NULL, *au = NULL;
         leptris_element_expanded_name(ae, &al, NULL, &au);
         if (!al || (au && strcmp(au, XSD_NS) != 0)) continue;
-        if (strcmp(al, "anyAttribute") == 0)
-            return xsd_strdup(
-                leptris_element_attribute(ae, "namespace"));
+        if (strcmp(al, "anyAttribute") == 0) {
+            /* leptris-rs#73: absent @namespace means ##any — a
+             * bare <xs:anyAttribute /> is a live wildcard, not an
+             * invisible one. */
+            const char* ns =
+                leptris_element_attribute(ae, "namespace");
+            return xsd_strdup(ns ? ns : "##any");
+        }
         if (strcmp(al, "attributeGroup") == 0) {
             const char* ref = xsd_local_name(
                 leptris_element_attribute(ae, "ref"));
@@ -3708,31 +3763,26 @@ static char* xsd_capture_any_attr_ns_deep(
             for (; g; g = g->next)
                 if (strcmp(g->name, ref) == 0) break;
             if (g && g->elem) {
-                char* r = xsd_capture_any_attr_ns_deep(s, g->elem,
-                                                       depth + 1);
-                if (r) return r;
+                char* inner_unit = NULL;
+                char* r = xsd_capture_any_attr_ns_deep(
+                    s, g->elem, depth + 1, &inner_unit);
+                if (r) {
+                    /* leptris-rs#72: the wildcard resolves against
+                     * its DECLARING unit's tns — the group's own
+                     * unit ("" for a namespace-less import), which
+                     * may differ from the consuming type's. */
+                    if (out_unit)
+                        *out_unit = inner_unit
+                                        ? inner_unit
+                                        : xsd_capture_unit_tns(g->elem);
+                    return r;
+                }
             }
         }
     }
     return NULL;
 }
 
-static char* xsd_capture_any_attr_ns(LeptrisElement container) {
-    for (LeptrisNodeRef ac = leptris_node_first_child(
-             leptris_element_as_node(container));
-         ac; ac = leptris_node_next_sibling(ac)) {
-        if (leptris_node_get_type(ac) != LEPTRIS_NODE_TYPE_ELEMENT)
-            continue;
-        LeptrisElement ae = (LeptrisElement)ac;
-        const char* al = NULL;
-        leptris_element_expanded_name(ae, &al, NULL, NULL);
-        if (al && strcmp(al, "anyAttribute") == 0)
-            return xsd_strdup(
-                leptris_element_attribute(ae, "namespace"));
-    }
-    return NULL;
-}
-
 /* moxml#460: the anyAttribute's XSD 1.1 @notQName (same walk as the
  * namespace capture). NULL when absent. */
 static char* xsd_capture_any_attr_not_qname(LeptrisElement container) {