leptris 1.9.391.0-arm-linux → 1.9.394.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ad8a3795b30020ae925fb64a19f9acadbcd26ab10da9283a145be14f6e2dede
-  data.tar.gz: 3838a8f9937409fefcce230eed59d0c6e46c53e069159e00722538ebfb695193
+  metadata.gz: 7d54a035a2117bdcf391aadc439d6abaae328513de9caa797272c9f0c8acd8d4
+  data.tar.gz: c2b64f137218af348ff014653d67378f43440ed567a5339b1b1416e034e50b9e
 SHA512:
-  metadata.gz: d2272eec63c0c2ddd3dab229cc209255b9ac8b4056659985f1195d0e00b175abfa98ffb1ac59f66b2a286ea6293edf201816c7201eac74dfd0ae0d3fcebcee54
-  data.tar.gz: 45f7f2a9af016191fb590dd2c110e150564567799a6e76c62513ffee715e2c78b6d119190e2c4bb36fc697d96b345d59977c33102b25f082dfad4ef21626316b
+  metadata.gz: 38e714a4e0b0390991ede4bb39ebc2c1a9ecffadd9531f3dfcea56ef702618c7c0e0a68b7b546e49abe3a280f82c35b799ee718be28b3086c04e00a10d2174ca
+  data.tar.gz: c48a24d36612528bf8c855cc4841c1a56085ba293b12c7cfaa1a1a6807622dae0ec6a24e1ad9d12e0dfef33598ac0e4380afe01fa188c02b082d2c724c83cb63

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.391"
+LIBLEPTRIS_VERSION = "1.9.394"
 # 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.391.0"
+  VERSION = "1.9.394.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.391
+- libleptris v1.9.394
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,82 @@
 ## [Unreleased]
 
+## [1.9.394] - 2026-10-30
+
+### Fixed
+
+- **xs:override loads its base and replaces the overridden components
+  (leptris#1913, PR #1917).** `override` was absent from the
+  declaration gate and the include-family chase, so the base document
+  never loaded and the override body's nested declarations were never
+  captured — the compiled schema had an empty symbol space (decls=0,
+  every instance element "not declared"). Override now chases its
+  schemaLocation like include (same targetNamespace), then captures
+  its own declaration children as a pseudo-root AFTER the base so the
+  head-first lookup ladder sees the replacements; the attributeGroup
+  pre-pass honors a capture-force flag in that body, and the ref-check
+  declaration collector walks the override body too. Witness: base
+  `Doc` replaced by the override's `Doc` — `<doc><b>1</b></doc>`
+  validates, `<doc><a>x</a></doc>` is rejected.
+
+
+
+## [1.9.393] - 2026-10-30
+
+### Added
+
+- **Capability bit for entity-reference nodes (leptris#1904, PR #1915).**
+  `LEPTRIS_PARSE_KEEP_ENTITY_REFS` already parses references as
+  first-class `LEPTRIS_NODE_TYPE_ENTITY_REF` nodes — text segments
+  split around the five built-ins and custom named references
+  (numeric character references stay text, XML 1.0 §4.1) — but
+  nothing advertised it. `LEPTRIS_CAP_ENTITY_REF_NODES` lets a
+  binding probe once and parse with the flag instead of re-scanning
+  expanded text; a spec pins the DOM shape and the
+  string-value / serialization / XPath agreement.
+
+### Fixed
+
+- **XSD 1.1 was inert for every `vc:minVersion`-marked schema
+  (leptris#1910, leptris#1911, PR #1914).** The version detector
+  read only the root's plain `version` attribute; the W3C suite and
+  the binding ecosystem mark 1.1 with `vc:minVersion` in the
+  versioning namespace. With the capture gates off,
+  `xs:alternative` and `xs:assert` compiled to nothing —
+  conditional type assignment applied the declared base type's
+  model in both directions (false rejects and false accepts), and
+  asserts never attached to their types. The detector now honors
+  `version`, `vc:minVersion`, and a `vc:maxVersion="1.0"` pin, and
+  `xs:openContent` interleave/suffix semantics engage with it
+  (leptris#1912's repro validates clean).
+- **Value-comparison keywords accept name-test operands
+  (`w le h`).** The XPath `eq/ne/lt/le/gt/ge` operators only read
+  as operators when the right operand opened with a scalar, paren,
+  variable, or function call — an `xs:assert test="w le h"` failed
+  to compile. Adjacent name tokens are never a valid path
+  continuation, so a bare name-test follower is unambiguously an
+  operand; every path start is now admitted.
+
+
+
+## [1.9.392] - 2026-10-30
+
+### Added
+
+- **Capability descriptor face (leptris#1905, PR #1908).**
+  `leptris_capabilities()` returns a versioned bitset of every face
+  this installed engine serves — the engine-side half of the
+  moxml#504 capability report. Bindings OR it with their own wrapper
+  knowledge instead of maintaining scattered version-gate
+  constants; build-conditional faces (DUCET collation, utf8proc,
+  iconv, AVX2) follow the same `LEPTRIS_HAS_*` macros that gate the
+  sources, so the descriptor cannot drift from the binary it ships
+  in. Contract: bits append, never reorder; the descriptor version
+  gates shape changes. The spec anchors every unconditional bit to
+  its real face symbol — a bit without a linked face fails the
+  build, not the assertion.
+
+
+
 ## [1.9.391] - 2026-10-30
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/README.adoc

@@ -744,6 +744,43 @@ To pin enum values (bindings hard-code these):
 ctest --test-dir build -R HeaderHygiene
 ----
 
+=== Capability descriptor (one call: what does this engine serve?)
+
+Bindings and embedders stop maintaining scattered version-gate
+constants: one call returns a versioned bitset of every face this
+installed engine serves. Build-conditional faces (Unicode
+normalization, iconv, DUCET collation, AVX2) answer honestly for the
+exact library you linked. New capabilities APPEND bits — the
+descriptor version gates shape changes.
+
+[source,c]
+----
+LeptrisCapabilities c = leptris_capabilities();
+if (c.descriptor_version >= 1 && (c.caps & LEPTRIS_CAP_XSD)) {
+    /* xsd compile/validate faces are present */
+}
+----
+
+Entity references: parsing with `LEPTRIS_PARSE_KEEP_ENTITY_REFS`
+yields `LEPTRIS_NODE_TYPE_ENTITY_REF` nodes instead of pre-expanded
+text — segments split around the five built-ins and custom named
+references (numeric character references stay text, per XML 1.0
+§4.1). String-value, serialization, and XPath all see the expanded
+value. Probe `LEPTRIS_CAP_ENTITY_REF_NODES` before relying on the
+mode.
+
+The bits: `LEPTRIS_CAP_PARSE`, `LEPTRIS_CAP_DOM`, `LEPTRIS_CAP_XPATH`,
+`LEPTRIS_CAP_XQUERY`, `LEPTRIS_CAP_DTD`, `LEPTRIS_CAP_SAX`,
+`LEPTRIS_CAP_HTML`, `LEPTRIS_CAP_XINCLUDE`, `LEPTRIS_CAP_DIFF`,
+`LEPTRIS_CAP_DIGEST`, `LEPTRIS_CAP_XSD`, `LEPTRIS_CAP_XSD_SET`,
+`LEPTRIS_CAP_RELAXNG`, `LEPTRIS_CAP_SCHEMATRON`, `LEPTRIS_CAP_XSLT`,
+`LEPTRIS_CAP_DESCRIPTOR`, `LEPTRIS_CAP_NS_SNAPSHOT_BULK`,
+`LEPTRIS_CAP_CHILDREN_BATCH`, `LEPTRIS_CAP_NAME_COMPARE`,
+`LEPTRIS_CAP_VERSION`, and the build-conditional
+`LEPTRIS_CAP_COLLATION_DUCET`, `LEPTRIS_CAP_UNICODE_UTF8PROC`,
+`LEPTRIS_CAP_ENCODING_ICONV`, `LEPTRIS_CAP_SIMD_AVX2`,
+`LEPTRIS_CAP_ENTITY_REF_NODES`.
+
 [#FFI]
 == FFI design
 

data/vendor-src/libleptris/src/include/leptris/types.h

@@ -447,6 +447,58 @@ typedef struct leptris_xpath_compiled* LeptrisXPathCompiled;
  * compiled — apply it to any number of documents, from any threads. */
 typedef struct leptris_xslt* LeptrisXslt;
 
+/* ============================================================================
+ * Capability Descriptor (leptris#1905)
+ * ============================================================================ */
+
+/* What this INSTALLED engine serves — one call, one versioned
+ * bitset. Contract: new capabilities APPEND bits; a bit is never
+ * removed, repurposed, or reordered — that is a descriptor-version
+ * bump. Build-conditional faces (utf8proc/iconv/DUCET/AVX2) answer
+ * honestly for the exact library a consumer linked. Bindings OR
+ * this with their own wrapper knowledge; consumers stop maintaining
+ * scattered version-gate constants. */
+enum {
+    LEPTRIS_CAP_PARSE = 1ULL << 0,
+    LEPTRIS_CAP_DOM = 1ULL << 1,
+    LEPTRIS_CAP_XPATH = 1ULL << 2,
+    LEPTRIS_CAP_XQUERY = 1ULL << 3,
+    LEPTRIS_CAP_DTD = 1ULL << 4,
+    LEPTRIS_CAP_SAX = 1ULL << 5,
+    LEPTRIS_CAP_HTML = 1ULL << 6,
+    LEPTRIS_CAP_XINCLUDE = 1ULL << 7,
+    LEPTRIS_CAP_DIFF = 1ULL << 8,
+    LEPTRIS_CAP_DIGEST = 1ULL << 9,
+    LEPTRIS_CAP_XSD = 1ULL << 10,
+    LEPTRIS_CAP_XSD_SET = 1ULL << 11,
+    LEPTRIS_CAP_RELAXNG = 1ULL << 12,
+    LEPTRIS_CAP_SCHEMATRON = 1ULL << 13,
+    LEPTRIS_CAP_XSLT = 1ULL << 14,
+    LEPTRIS_CAP_DESCRIPTOR = 1ULL << 15,
+    LEPTRIS_CAP_NS_SNAPSHOT_BULK = 1ULL << 16,
+    LEPTRIS_CAP_CHILDREN_BATCH = 1ULL << 17,
+    LEPTRIS_CAP_NAME_COMPARE = 1ULL << 18,
+    LEPTRIS_CAP_VERSION = 1ULL << 19,
+    /* build-conditional */
+    LEPTRIS_CAP_COLLATION_DUCET = 1ULL << 20,
+    LEPTRIS_CAP_UNICODE_UTF8PROC = 1ULL << 21,
+    LEPTRIS_CAP_ENCODING_ICONV = 1ULL << 22,
+    LEPTRIS_CAP_SIMD_AVX2 = 1ULL << 23,
+    /* LEPTRIS_PARSE_KEEP_ENTITY_REFS yields entity references as
+     * first-class ENTITY_REF nodes (segments split around the five
+     * built-ins and custom named references; leptris#1904). */
+    LEPTRIS_CAP_ENTITY_REF_NODES = 1ULL << 24
+};
+
+/* Descriptor shape version: 1. Bump when the STRUCT changes or a
+ * bit is retired (never expected — bits append). */
+#define LEPTRIS_CAPS_DESCRIPTOR_VERSION 1u
+
+typedef struct leptris_capabilities {
+    unsigned long long caps;
+    unsigned descriptor_version;
+} LeptrisCapabilities;
+
 /* ============================================================================
  * Memory Allocation Function Types
  * ============================================================================ */

data/vendor-src/libleptris/src/include/leptris.h

@@ -4230,6 +4230,12 @@ LEPTRIS_API const char* leptris_version(void);
  */
 LEPTRIS_API void leptris_version_components(int* major, int* minor, int* patch);
 
+/* leptris#1905: the capability descriptor — what this installed
+ * engine serves, as a versioned bitset (LEPTRIS_CAP_*). Query once
+ * at attach; new capabilities append bits (the descriptor version
+ * gates shape changes). Thread-safe: pure, allocation-free. */
+LEPTRIS_API LeptrisCapabilities leptris_capabilities(void);
+
 /**
  * Release this thread's libleptris caches
  *

data/vendor-src/libleptris/src/leptris/core.c

@@ -72,6 +72,37 @@ LEPTRIS_API void leptris_version_components(int* major, int* minor, int* patch)
     if (patch) *patch = LEPTRIS_VERSION_PATCH;
 }
 
+/* leptris#1905: the capability descriptor. Unconditional faces are
+ * always compiled into this library; the build-conditional bits
+ * follow the same macros the build system defines for the sources
+ * — the descriptor cannot drift from the binary it ships in. */
+LEPTRIS_API LeptrisCapabilities leptris_capabilities(void) {
+    LeptrisCapabilities c;
+    c.caps = LEPTRIS_CAP_PARSE | LEPTRIS_CAP_DOM | LEPTRIS_CAP_XPATH |
+             LEPTRIS_CAP_XQUERY | LEPTRIS_CAP_DTD | LEPTRIS_CAP_SAX |
+             LEPTRIS_CAP_HTML | LEPTRIS_CAP_XINCLUDE | LEPTRIS_CAP_DIFF |
+             LEPTRIS_CAP_DIGEST | LEPTRIS_CAP_XSD | LEPTRIS_CAP_XSD_SET |
+             LEPTRIS_CAP_RELAXNG | LEPTRIS_CAP_SCHEMATRON |
+             LEPTRIS_CAP_XSLT | LEPTRIS_CAP_DESCRIPTOR |
+             LEPTRIS_CAP_NS_SNAPSHOT_BULK | LEPTRIS_CAP_CHILDREN_BATCH |
+             LEPTRIS_CAP_NAME_COMPARE | LEPTRIS_CAP_VERSION |
+             LEPTRIS_CAP_ENTITY_REF_NODES;
+#if defined(LEPTRIS_HAS_DUCET)
+    c.caps |= LEPTRIS_CAP_COLLATION_DUCET;
+#endif
+#if defined(LEPTRIS_HAS_UTF8PROC)
+    c.caps |= LEPTRIS_CAP_UNICODE_UTF8PROC;
+#endif
+#if defined(LEPTRIS_HAS_ICONV)
+    c.caps |= LEPTRIS_CAP_ENCODING_ICONV;
+#endif
+#if defined(LEPTRIS_HAS_AVX2_BUILD)
+    c.caps |= LEPTRIS_CAP_SIMD_AVX2;
+#endif
+    c.descriptor_version = LEPTRIS_CAPS_DESCRIPTOR_VERSION;
+    return c;
+}
+
 LEPTRIS_API void leptris_thread_cleanup(void) {
     leptris_xpath_drain_thread_caches();
     leptris_root_doc_drain_thread_caches();

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

@@ -643,44 +643,26 @@ static XPathASTNode* parse_string_concat_expr(XPathParser* parser) {
 }
 
 /* True when the token AFTER a bare value-comparison keyword may
- * START an operand. The base list covers scalars/parens; an NCName
- * qualifies ONLY when it opens a function call — a bare NCName
- * follower stays a path step (XPath 1.0 name-test precedence). */
+ * START an operand. Scalars, parens, variables, and (leptris#1910)
+ * every path start: a bare NCName/QName is an element name test in
+ * operand position, and adjacent name tokens are never a valid
+ * path continuation, so the keyword reading is unambiguous
+ * (`w le h` in xs:assert/xs:alternative tests). */
 static int kw_operand_boundary(XPathParser* parser, XPathToken* nx) {
+    (void)parser;
     if (!nx) return 1;
     switch (nx->type) {
         case TOK_EOF: case TOK_RPAREN: case TOK_COMMA:
         case TOK_RBRACE: case TOK_LBRACE: case TOK_NUMBER:
         case TOK_STRING: case TOK_DOLLAR: case TOK_LPAREN:
         case TOK_MINUS: case TOK_PLUS:
+        case TOK_SLASH: case TOK_DOUBLE_SLASH: case TOK_AT:
+        case TOK_DOT: case TOK_DOUBLE_DOT: case TOK_STAR:
             return 1;
         case TOK_QNAME:
-            /* prefixed call: QName '(' — a lone QName stays a path
-             * step (name-test precedence, like NCName). */
-        case TOK_NCNAME: {
-            /* unprefixed call: name '(' ... prefixed call:
-             * name ':' name '(' (the QT3 corpus writes fn:year-...). */
-            XPathToken* nnx =
-                parser->token_pos + 2 < parser->token_count
-                    ? &parser->tokens[parser->token_pos + 2]
-                    : NULL;
-            if (nnx && nnx->type == TOK_LPAREN) return 1;
-            XPathToken* t3 =
-                parser->token_pos + 3 < parser->token_count
-                    ? &parser->tokens[parser->token_pos + 3]
-                    : NULL;
-            XPathToken* t4 =
-                parser->token_pos + 4 < parser->token_count
-                    ? &parser->tokens[parser->token_pos + 4]
-                    : NULL;
-            XPathToken* t5 =
-                parser->token_pos + 5 < parser->token_count
-                    ? &parser->tokens[parser->token_pos + 5]
-                    : NULL;
-            return nnx && nnx->type == TOK_COLON && t3 &&
-                   t3->type == TOK_NCNAME && t4 &&
-                   t4->type == TOK_LPAREN && t5;
-        }
+        case TOK_NCNAME:
+            /* name test, function call, or prefixed call */
+            return 1;
         default:
             return 0;
     }

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

@@ -51,7 +51,11 @@ struct leptris_xsd_schema {
     char* target_ns;
     int version_11;    /* xs:schema @version = "1.1" */
     char* base_dir;    /* schemaLocation resolution (file compile) */
-    int include_depth; /* include/import recursion guard */
+    int include_depth;
+    /* xs:override body capture replaces same-named components: the
+     * attributeGroup pre-pass must re-register defs the base
+     * already captured (leptris#1913). */
+    int capture_force; /* include/import recursion guard */
     /* leptris#1644: already-captured schema units (canonical
      * location per entry) — the include/import DAG is dense and
      * cyclic; without this set every DAG path re-parses and
@@ -679,7 +683,7 @@ static int xsd_is_declaration(const char* local, const char* uri) {
         "element",    "attribute",    "simpleType", "complexType",
         "group",      "attributeGroup", "notation", "include",
         "defaultOpenContent",
-        "import",     "redefine",     NULL
+        "import",     "redefine",     "override", NULL
     };
     for (int i = 0; names[i]; i++)
         if (strcmp(local, names[i]) == 0) return 1;
@@ -1810,7 +1814,8 @@ static void xsd_collect_decls_doc(LeptrisElement root, const char* eff_tns,
         if (!l || !u || strcmp(u, XSD_NS) != 0)
             continue;
         int is_inc = (strcmp(l, "include") == 0 ||
-                      strcmp(l, "redefine") == 0);
+                      strcmp(l, "redefine") == 0 ||
+                      strcmp(l, "override") == 0);
         int is_imp = (strcmp(l, "import") == 0);
         if (!is_inc && !is_imp) continue;
         const char* loc = leptris_element_attribute(c, "schemaLocation");
@@ -1853,6 +1858,13 @@ static void xsd_collect_decls_doc(LeptrisElement root, const char* eff_tns,
             xsd_collect_decls_doc(subroot, eff, sub_base, decls, n, max,
                                   claimed, nclaimed, cmax, depth + 1);
         }
+        /* leptris#1913: an xs:override body's declarations belong
+         * to the symbol space too — walk the override element as a
+         * pseudo-root (it has no include/import children of its
+         * own). */
+        if (strcmp(l, "override") == 0)
+            xsd_collect_decls_doc(c, eff_tns, base_dir, decls, n, max,
+                                  claimed, nclaimed, cmax, depth + 1);
         leptris_document_free(sub);
     }
 }
@@ -1960,8 +1972,24 @@ static LeptrisXsdSchema xsd_compile_impl(const char* xsd_text,
     s->target_ns = xsd_strdup(
         leptris_element_attribute(root, "targetNamespace"));
     {
+        /* XSD 1.1 §4.3 schema versioning: the W3C suite and the
+         * binding ecosystem mark 1.1 with vc:minVersion (the
+         * versioning namespace); the plain version attribute is
+         * the other legal spelling. vc:maxVersion below 1.1 pins
+         * a 1.0 processor target regardless. leptris#1910/#1911:
+         * reading only @version silently compiled asserts and
+         * alternatives away for every vc-marked schema. */
         const char* ver = leptris_element_attribute(root, "version");
-        s->version_11 = (ver && strcmp(ver, "1.1") == 0);
+        const char* vmin = leptris_element_attribute_ns(
+            root, "http://www.w3.org/2001/XMLSchema-versioning",
+            "minVersion");
+        const char* vmax = leptris_element_attribute_ns(
+            root, "http://www.w3.org/2001/XMLSchema-versioning",
+            "maxVersion");
+        int is11 = (ver && strcmp(ver, "1.1") == 0) ||
+                   (vmin && strcmp(vmin, "1.1") == 0);
+        if (vmax && strcmp(vmax, "1.0") == 0) is11 = 0;
+        s->version_11 = is11;
     }
 
     const char* local = NULL;
@@ -2247,7 +2275,8 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
 
         if (strcmp(local, "include") == 0 ||
             strcmp(local, "import") == 0 ||
-            strcmp(local, "redefine") == 0) {
+            strcmp(local, "redefine") == 0 ||
+            strcmp(local, "override") == 0) {
             const char* loc = leptris_element_attribute(
                 (LeptrisElement)n, "schemaLocation");
             if (loc && s->base_dir && s->include_depth < 16) {
@@ -2314,6 +2343,20 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                             if (sub_ns) free(sub_ns);
                             s->target_ns = saved_ns;
                         }
+                        /* leptris#1913 (XSD 1.1 §I.4): the override
+                         * element's OWN declaration children
+                         * replace same-named components of the base
+                         * just captured — capture them AFTER the
+                         * base so the lookup ladder (head-first)
+                         * sees the replacements. */
+                        if (subroot && same_ns &&
+                            strcmp(local, "override") == 0) {
+                            s->include_depth++;
+                            s->capture_force = 1;
+                            xsd_capture_root(s, (LeptrisElement)n);
+                            s->capture_force = 0;
+                            s->include_depth--;
+                        }
                         leptris_document_free(sub);
                     }
                     free(text);
@@ -2448,7 +2491,8 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                 XsdAttrGroupDef* seen = s->attr_groups;
                 for (; seen; seen = seen->next)
                     if (strcmp(seen->name, nm) == 0) break;
-                if (!seen) xsd_capture_attr_group_def(s, (LeptrisElement)n, nm);
+                if (!seen || s->capture_force)
+                    xsd_capture_attr_group_def(s, (LeptrisElement)n, nm);
             }
         } else if (strcmp(local, "group") == 0 && uri && !strcmp(uri, XSD_NS)) {
             const char* nm =

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

@@ -120,11 +120,28 @@ leptris_add_test(test_large_docs parser/test_large_documents.cpp)
 leptris_add_test(test_encoding   parser/test_encoding.cpp)
 leptris_add_test(test_dom        dom/test_dom.cpp)
 leptris_add_test(test_element_children dom/test_element_children.cpp)
+leptris_add_test(test_entity_refs dom/test_entity_refs.cpp)
 leptris_add_test(test_namespace_cache dom/test_namespace_cache.cpp)
 leptris_add_test(test_map_lifecycle dom/test_map_lifecycle.cpp)
 leptris_add_test(test_simd_count parser/test_simd_count.cpp)
 leptris_add_test(test_ws_shape    parser/test_whitespace_shape.cpp)
 leptris_add_test(test_descriptor abi/test_descriptor.cpp)
+leptris_add_test(test_capabilities abi/test_capabilities.cpp)
+# The capability descriptor's build-conditional bits follow the
+# engine's PUBLIC macros, which do not flow through the object
+# aggregation (same mirror as test_qt3 below).
+if(LEPTRIS_ENABLE_DUCET)
+    target_compile_definitions(test_capabilities PRIVATE LEPTRIS_HAS_DUCET=1)
+endif()
+if(LEPTRIS_ENABLE_UTF8PROC)
+    target_compile_definitions(test_capabilities PRIVATE LEPTRIS_HAS_UTF8PROC=1)
+endif()
+if(LEPTRIS_ENABLE_ICONV)
+    target_compile_definitions(test_capabilities PRIVATE LEPTRIS_HAS_ICONV=1)
+endif()
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "(x86_64|AMD64|i[3-6]86)")
+    target_compile_definitions(test_capabilities PRIVATE LEPTRIS_HAS_AVX2_BUILD=1)
+endif()
 leptris_add_test(test_document_children dom/test_document_children.cpp)
 leptris_add_test(test_vtable     dom/test_vtable.cpp)
 leptris_add_test(test_node_surface_parity dom/test_node_surface_parity.cpp)

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

@@ -0,0 +1,112 @@
+// leptris#1905: one call answering what this installed engine
+// serves. The descriptor is a versioned bitset — new capabilities
+// APPEND bits, never reorder or repack (a reorder bumps
+// LEPTRIS_CAPS_DESCRIPTOR_VERSION).
+#include <leptris.h>
+#include <leptris/descriptor.h>
+#include <leptris/dtd.h>
+#include <leptris/html.h>
+#include <leptris/sax/sax.h>
+#include <leptris/xpath/xpath.h>
+#include <leptris/xquery/xquery.h>
+
+#include <gtest/gtest.h>
+
+// Anchor law: each unconditional bit's face symbol is REFERENCED
+// here — a descriptor bit without a real, linked face fails the
+// BUILD of this test, not just the assertion.
+namespace caps_anchors {
+void* const kParse = (void*)&leptris_parse_string;
+void* const kDom = (void*)&leptris_document_root;
+void* const kXpath = (void*)&leptris_xpath_eval;
+void* const kXquery = (void*)&leptris_xquery_eval;
+void* const kDtd = (void*)&leptris_dtd_parse;
+void* const kSax = (void*)&leptris_sax_parse;
+void* const kHtml = (void*)&leptris_parse_html_string;
+void* const kXinclude = (void*)&leptris_xinclude_process;
+void* const kDiff = (void*)&leptris_diff;
+void* const kDigest = (void*)&leptris_node_digest;
+void* const kXsd = (void*)&leptris_xsd_compile;
+void* const kXsdSet = (void*)&leptris_xsd_compile_set;
+void* const kRelaxng = (void*)&leptris_rng_parse;
+void* const kSchematron = (void*)&leptris_schematron_parse;
+void* const kXslt = (void*)&leptris_xslt_parse;
+void* const kDescriptor = (void*)&leptris_plan_result_build_packed;
+void* const kNsSnapshot = (void*)&leptris_element_namespace_declarations_snapshot;
+void* const kChildrenBatch = (void*)&leptris_element_children_batch;
+void* const kNameCompare = (void*)&leptris_node_name_compare;
+void* const kVersion = (void*)&leptris_version;
+void* const kEntityRefs = (void*)&leptris_entity_ref_node_name;
+}  // namespace caps_anchors
+
+TEST(LeptrisCapabilities, DescriptorVersionIsCurrent) {
+    LeptrisCapabilities c = leptris_capabilities();
+    EXPECT_EQ(c.descriptor_version, LEPTRIS_CAPS_DESCRIPTOR_VERSION);
+}
+
+TEST(LeptrisCapabilities, UnconditionalFacesAreSet) {
+    LeptrisCapabilities c = leptris_capabilities();
+    EXPECT_NE(c.caps & LEPTRIS_CAP_PARSE, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_DOM, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_XPATH, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_XQUERY, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_DTD, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_SAX, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_HTML, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_XINCLUDE, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_DIFF, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_DIGEST, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_XSD, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_XSD_SET, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_RELAXNG, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_SCHEMATRON, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_XSLT, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_DESCRIPTOR, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_NS_SNAPSHOT_BULK, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_CHILDREN_BATCH, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_NAME_COMPARE, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_VERSION, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_ENTITY_REF_NODES, 0ULL);
+}
+
+TEST(LeptrisCapabilities, BuildConditionalBitsMatchTheBuild) {
+    LeptrisCapabilities c = leptris_capabilities();
+#if defined(LEPTRIS_HAS_DUCET)
+    EXPECT_NE(c.caps & LEPTRIS_CAP_COLLATION_DUCET, 0ULL);
+#else
+    EXPECT_EQ(c.caps & LEPTRIS_CAP_COLLATION_DUCET, 0ULL);
+#endif
+#if defined(LEPTRIS_HAS_UTF8PROC)
+    EXPECT_NE(c.caps & LEPTRIS_CAP_UNICODE_UTF8PROC, 0ULL);
+#else
+    EXPECT_EQ(c.caps & LEPTRIS_CAP_UNICODE_UTF8PROC, 0ULL);
+#endif
+#if defined(LEPTRIS_HAS_ICONV)
+    EXPECT_NE(c.caps & LEPTRIS_CAP_ENCODING_ICONV, 0ULL);
+#else
+    EXPECT_EQ(c.caps & LEPTRIS_CAP_ENCODING_ICONV, 0ULL);
+#endif
+#if defined(LEPTRIS_HAS_AVX2_BUILD)
+    EXPECT_NE(c.caps & LEPTRIS_CAP_SIMD_AVX2, 0ULL);
+#else
+    EXPECT_EQ(c.caps & LEPTRIS_CAP_SIMD_AVX2, 0ULL);
+#endif
+}
+
+TEST(LeptrisCapabilities, NoUnknownBits) {
+    LeptrisCapabilities c = leptris_capabilities();
+    constexpr unsigned long long kKnown =
+        LEPTRIS_CAP_PARSE | LEPTRIS_CAP_DOM | LEPTRIS_CAP_XPATH |
+        LEPTRIS_CAP_XQUERY | LEPTRIS_CAP_DTD | LEPTRIS_CAP_SAX |
+        LEPTRIS_CAP_HTML | LEPTRIS_CAP_XINCLUDE | LEPTRIS_CAP_DIFF |
+        LEPTRIS_CAP_DIGEST | LEPTRIS_CAP_XSD | LEPTRIS_CAP_XSD_SET |
+        LEPTRIS_CAP_RELAXNG | LEPTRIS_CAP_SCHEMATRON | LEPTRIS_CAP_XSLT |
+        LEPTRIS_CAP_DESCRIPTOR | LEPTRIS_CAP_NS_SNAPSHOT_BULK |
+        LEPTRIS_CAP_CHILDREN_BATCH | LEPTRIS_CAP_NAME_COMPARE |
+        LEPTRIS_CAP_VERSION | LEPTRIS_CAP_COLLATION_DUCET |
+        LEPTRIS_CAP_UNICODE_UTF8PROC | LEPTRIS_CAP_ENCODING_ICONV |
+        LEPTRIS_CAP_SIMD_AVX2 | LEPTRIS_CAP_ENTITY_REF_NODES;
+    EXPECT_EQ(c.caps & ~kKnown, 0ULL)
+        << "an unknown bit is set — the descriptor grew without "
+           "bumping LEPTRIS_CAPS_DESCRIPTOR_VERSION";
+}

data/vendor-src/libleptris/test/dom/test_entity_refs.cpp

@@ -0,0 +1,111 @@
+// leptris#1904: LEPTRIS_PARSE_KEEP_ENTITY_REFS yields entity
+// references as FIRST-CLASS nodes — segments split around the five
+// built-ins and custom named references, numeric character
+// references folded into text (they are character references, not
+// entity references, per XML 1.0 §4.1). The DOM the binding
+// consumes: text / entity-ref / text / ... with string-value,
+// serialization, and XPath walking the expanded value.
+#include <gtest/gtest.h>
+#include <leptris.h>
+#include <cstring>
+#include <string>
+#include <vector>
+
+namespace {
+
+struct ChildInfo {
+    int type;
+    std::string text;
+    std::string name;
+};
+
+std::vector<ChildInfo> children_of(LeptrisElement e) {
+    std::vector<ChildInfo> rows;
+    for (LeptrisNodeRef c = leptris_node_first_child(
+             leptris_element_as_node(e));
+         c; c = leptris_node_next_sibling(c)) {
+        ChildInfo row;
+        row.type = (int)leptris_node_get_type(c);
+        if (row.type == LEPTRIS_NODE_TYPE_TEXT)
+            row.text = leptris_text_node_get_content(c);
+        if (row.type == LEPTRIS_NODE_TYPE_ENTITY_REF)
+            row.name = leptris_entity_ref_node_name(c);
+        rows.push_back(row);
+    }
+    return rows;
+}
+
+}  // namespace
+
+TEST(EntityRefNodes, BuiltinsBecomeNodes) {
+    const char* xml = "<a>x&amp;y&lt;z&gt;w</a>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_KEEP_ENTITY_REFS, &st);
+    ASSERT_NE(doc, (LeptrisDocument)0);
+    LeptrisElement a = leptris_document_root(doc);
+    std::vector<ChildInfo> kids = children_of(a);
+    ASSERT_EQ(kids.size(), 7u);
+    EXPECT_EQ(kids[0].type, (int)LEPTRIS_NODE_TYPE_TEXT);
+    EXPECT_EQ(kids[0].text, "x");
+    EXPECT_EQ(kids[1].type, (int)LEPTRIS_NODE_TYPE_ENTITY_REF);
+    EXPECT_EQ(kids[1].name, "amp");
+    EXPECT_EQ(kids[2].text, "y");
+    EXPECT_EQ(kids[3].name, "lt");
+    EXPECT_EQ(kids[4].text, "z");
+    EXPECT_EQ(kids[5].name, "gt");
+    EXPECT_EQ(kids[6].text, "w");
+    leptris_document_free(doc);
+}
+
+TEST(EntityRefNodes, NumericCharacterRefsStayText) {
+    /* XML 1.0 §4.1: character references are NOT entity references. */
+    const char* xml = "<a>&#65;&#x42;</a>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_KEEP_ENTITY_REFS, &st);
+    ASSERT_NE(doc, (LeptrisDocument)0);
+    LeptrisElement a = leptris_document_root(doc);
+    std::vector<ChildInfo> kids = children_of(a);
+    ASSERT_EQ(kids.size(), 1u);
+    EXPECT_EQ(kids[0].type, (int)LEPTRIS_NODE_TYPE_TEXT);
+    EXPECT_EQ(kids[0].text, "AB");
+    leptris_document_free(doc);
+}
+
+TEST(EntityRefNodes, StringValueSerializationAndXPathAgree) {
+    const char* xml = "<a>x&amp;y&lt;z</a>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_KEEP_ENTITY_REFS, &st);
+    ASSERT_NE(doc, (LeptrisDocument)0);
+    LeptrisElement a = leptris_document_root(doc);
+    EXPECT_STREQ(leptris_element_text(a), "x&y<z");
+    char* ser = leptris_document_serialize(doc, NULL);
+    ASSERT_NE(ser, nullptr);
+    EXPECT_STREQ(ser, "<a>x&amp;y&lt;z</a>");
+    leptris_free_string(ser);
+    LeptrisXPathResult r = leptris_xpath_eval(doc, NULL, "string(/a)");
+    ASSERT_NE(r, nullptr);
+    char* sv = leptris_xpath_result_string(r);
+    EXPECT_STREQ(sv, "x&y<z");
+    leptris_free_string(sv);
+    leptris_xpath_result_free(r);
+    leptris_document_free(doc);
+}
+
+TEST(EntityRefNodes, CustomNamedRefsAreNodes) {
+    const char* xml =
+        "<!DOCTYPE r [<!ENTITY foo \"x\">]><r>a&foo;b</r>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_KEEP_ENTITY_REFS, &st);
+    ASSERT_NE(doc, (LeptrisDocument)0);
+    LeptrisElement r = leptris_document_root(doc);
+    std::vector<ChildInfo> kids = children_of(r);
+    ASSERT_EQ(kids.size(), 3u);
+    EXPECT_EQ(kids[1].type, (int)LEPTRIS_NODE_TYPE_ENTITY_REF);
+    EXPECT_EQ(kids[1].name, "foo");
+    EXPECT_STREQ(leptris_element_text(r), "axb");
+    leptris_document_free(doc);
+}

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

@@ -3887,3 +3887,119 @@ TEST(XsdCrossNs, RealWmlChainCompilesDeclarations) {
         << " err=" << (err ? err : "(clean)");
     leptris_xsd_free(s);
 }
+
+/* leptris#1911: vc:minVersion="1.1" marks the schema as XSD 1.1
+ * (the W3C suite and moxml both use the versioning namespace; the
+ * plain version attribute is the other legal spelling). The
+ * alternative's test selects the type — validation must run the
+ * SELECTED type's content model, in both directions. */
+TEST(Xsd11Gate, CtaSelectsAlternativeType) {
+    const char xsd[] =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " vc:minVersion=\"1.1\""
+        " xmlns:vc=\"http://www.w3.org/2001/XMLSchema-versioning\">"
+        "<xs:element name=\"shape\" type=\"Shape\">"
+        "<xs:alternative test=\"@kind='circle'\" type=\"Circle\"/>"
+        "</xs:element>"
+        "<xs:complexType name=\"Shape\" abstract=\"true\">"
+        "<xs:attribute name=\"kind\" type=\"xs:string\"/>"
+        "</xs:complexType>"
+        "<xs:complexType name=\"Circle\">"
+        "<xs:complexContent><xs:extension base=\"Shape\">"
+        "<xs:sequence><xs:element name=\"r\" type=\"xs:integer\"/>"
+        "</xs:sequence></xs:extension></xs:complexContent>"
+        "</xs:complexType></xs:schema>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile(xsd, strlen(xsd), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    ASSERT_EQ(st, LEPTRIS_OK) << leptris_xsd_error(s);
+    EXPECT_STREQ(leptris_xsd_version(s), "1.1")
+        << "vc:minVersion must gate the 1.1 feature set";
+    EXPECT_EQ(validate_compiled(s,
+                "<shape kind=\"circle\"><r>4</r></shape>"),
+              1)
+        << "the selected Circle type admits <r>: "
+        << leptris_xsd_error(s);
+    EXPECT_EQ(validate_compiled(s, "<shape kind=\"circle\"/>"), 0)
+        << "the selected Circle type REQUIRES <r>";
+    leptris_xsd_free(s);
+}
+
+/* leptris#1910: an xs:assert in a vc:minVersion="1.1" schema must
+ * be evaluated — a violating instance produces an assertion row. */
+TEST(Xsd11Gate, AssertIsEvaluated) {
+    const char xsd[] =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " vc:minVersion=\"1.1\""
+        " xmlns:vc=\"http://www.w3.org/2001/XMLSchema-versioning\">"
+        "<xs:element name=\"size\">"
+        "<xs:complexType><xs:sequence>"
+        "<xs:element name=\"w\" type=\"xs:integer\"/>"
+        "<xs:element name=\"h\" type=\"xs:integer\"/>"
+        "</xs:sequence><xs:assert test=\"w le h\"/></xs:complexType>"
+        "</xs:element></xs:schema>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile(xsd, strlen(xsd), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    ASSERT_EQ(st, LEPTRIS_OK) << leptris_xsd_error(s);
+    EXPECT_EQ(validate_compiled(s, "<size><w>3</w><h>5</h></size>"), 1)
+        << "satisfying assert must stay valid: "
+        << leptris_xsd_error(s);
+    EXPECT_EQ(validate_compiled(s, "<size><w>9</w><h>5</h></size>"), 0)
+        << "violating assert must produce a finding";
+    leptris_xsd_free(s);
+}
+
+/* leptris#1913: xs:override (XSD 1.1 Structures §I.4) — the base
+ * document's declarations load (xs:override is an include-family
+ * chase), then the override body's same-named declarations REPLACE
+ * them. Previously override was absent from the chase condition:
+ * the base never loaded and the body's nested declarations were
+ * never captured — an empty symbol space (decls=0). */
+TEST(Xsd11Gate, OverrideLoadsBaseAndReplacesComponents) {
+    const char* base =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"urn:b\" xmlns=\"urn:b\""
+        " elementFormDefault=\"qualified\">"
+        "<xs:element name=\"doc\" type=\"Doc\"/>"
+        "<xs:complexType name=\"Doc\">"
+        "<xs:sequence><xs:element name=\"a\" type=\"xs:string\"/>"
+        "</xs:sequence></xs:complexType></xs:schema>";
+    const char* ovr =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"urn:b\" xmlns=\"urn:b\""
+        " elementFormDefault=\"qualified\" vc:minVersion=\"1.1\""
+        " xmlns:vc=\"http://www.w3.org/2001/XMLSchema-versioning\">"
+        "<xs:override schemaLocation=\"ovr1913_base.xsd\">"
+        "<xs:complexType name=\"Doc\">"
+        "<xs:sequence><xs:element name=\"b\" type=\"xs:integer\"/>"
+        "</xs:sequence></xs:complexType>"
+        "</xs:override></xs:schema>";
+    const char* dir = std::getenv("TMPDIR");
+    std::string tmp = dir ? dir : "/tmp";
+    std::string base_path = tmp + "/ovr1913_base.xsd";
+    std::string ovr_path = tmp + "/ovr1913_ovr.xsd";
+    {
+        std::ofstream f(base_path);
+        f << base;
+    }
+    {
+        std::ofstream f(ovr_path);
+        f << ovr;
+    }
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile_file(ovr_path.c_str(), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    ASSERT_EQ(st, LEPTRIS_OK) << leptris_xsd_error(s);
+    EXPECT_GT(leptris_xsd_declaration_count(s), 0u)
+        << "override must not produce an empty symbol space";
+    EXPECT_EQ(validate_compiled(s, "<doc xmlns=\"urn:b\"><b>1</b></doc>"),
+              1)
+        << "the overridden Doc admits <b>: " << leptris_xsd_error(s);
+    EXPECT_EQ(validate_compiled(s, "<doc xmlns=\"urn:b\"><a>x</a></doc>"),
+              0)
+        << "the overridden Doc no longer admits <a>";
+    std::remove(base_path.c_str());
+    std::remove(ovr_path.c_str());
+    leptris_xsd_free(s);
+}

data/vendor-src/libleptris/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.391",
+  "version": "1.9.394",
   "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.391.0
+  version: 1.9.394.0
 platform: arm-linux
 authors:
 - Ribose Inc.
@@ -744,6 +744,7 @@ files:
 - vendor-src/libleptris/src/man/libleptris.5.adoc
 - vendor-src/libleptris/test/CMakeLists.txt
 - vendor-src/libleptris/test/README.md
+- vendor-src/libleptris/test/abi/test_capabilities.cpp
 - vendor-src/libleptris/test/abi/test_descriptor.cpp
 - vendor-src/libleptris/test/abi/test_doctype_api.cpp
 - vendor-src/libleptris/test/abi/test_dom_deep_copy.cpp
@@ -782,6 +783,7 @@ files:
 - vendor-src/libleptris/test/dom/test_document_children.cpp
 - vendor-src/libleptris/test/dom/test_dom.cpp
 - vendor-src/libleptris/test/dom/test_element_children.cpp
+- vendor-src/libleptris/test/dom/test_entity_refs.cpp
 - vendor-src/libleptris/test/dom/test_map_lifecycle.cpp
 - vendor-src/libleptris/test/dom/test_namespace_cache.cpp
 - vendor-src/libleptris/test/dom/test_node_surface_parity.cpp