leptris 1.9.210.1-arm-linux → 1.9.216.0-arm-linux

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,123 @@
 ## [Unreleased]
 
+## [1.9.216] - 2026-09-21
+
+### Fixed
+
+- **#1242** — generation-checked root→document memo. The TLS
+  last-hit memo was keyed on the root's address alone; the iterparse
+  yield path primed it with a subtree the consumer frees, and the
+  allocator recycled that address for the NEXT document's root —
+  the stale pair resolved all-NULL attribute reads and
+  `set_root`'s "element belongs to a different document" false
+  positive. Every map mutation now bumps a generation counter; a
+  memo hit requires the prime-time generation to match, so
+  invalidation is deterministic instead of allocator luck. The
+  transform steady state the #682 lever targets still hits (one
+  pointer compare); TDD-covered by
+  `DomBasics.RootDocMemoDiesOnAnyMapMutationAfterPrime`.
+
+
+
+## [1.9.215] - 2026-09-21
+
+### Added — XQuery order-by (QT3 OrderByClause 138/205)
+
+- Expression-level `order by` on FLWOR: string-typed keys compare by
+  codepoint (`collation`-shaped strmode mask), repeated `order by`
+  clauses chain as sequential stable sorts keyed by clause index.
+- libxml2 number-spelling parity stays pinned for XPath 1.0/XSLT;
+  XQuery gets its own channel (integral plain ≤1e18, plain
+  fractions ≥1e-18, INF/-INF) selected at eval entry.
+- `/a/b/string()` fn-step rehang + `//` twin root-match fast path
+  (#692); base-uri declaration support.
+
+### Fixed
+
+- ASAN chain from the orderby gate: deep-copy owned head nodesets
+  in `evaluate_location_path`; `set_nodeset` frees a prior nodeset
+  instead of leaking; tuple rebind clones attr/ns; variable lookup
+  deep-copies owned attributes/namespaces.
+
+
+
+## [1.9.214] - 2026-09-21
+
+### Added — QT3 lane-15 core: switch / group-by / if (lever 6 stage-2)
+
+Two batches close the lane-15 expression families:
+
+- **fn-items (#1268)**: `fn:function-name` / `fn:function-arity` gated on the vendored sets; `fn:function-name` returns the lexical QName verbatim (no `fn:` prefixing).
+- **lane-15 core (#1270)**: `prod/SwitchExpr` (16), `prod/GroupByClause` (20, works-mod + docvar externals) and `prod/IfExpr` (24) — every adopted case agrees; full suite 1640/1640.
+
+Engine fixes the corpus drove:
+
+- **group by**: bare `$k` grouping variables, comma-separated multi-spec grouping on the key tuple, optional `as SequenceType`/`collation` specs, WHERE-after-GROUP-BY filtering the grouped tuples.
+- **ctor-enclosed FLWOR** (`<out>{ for … group by … }</out>`): the ctor is hoisted and wraps the result sequence once.
+- **node lifetime**: attribute/namespace nodes in FLWOR tuples and LET bindings are cloned and tuple-owned (group-by keys dangled after unbind and read empty); external-variable selects evaluate on the query context so `parse-xml()` documents stay anchored.
+- **constructors**: nested direct ctors inside enclosed expressions splice recursively; `text{(a,b,c)}` joins atomics with spaces; 0-arity `string()` is kind-aware for attribute/text contexts; fn steps (`E/string()`) map per member after a filter expr; the `!` map no longer frees its left nodeset before mapping.
+- **`prefix:*` vs multiply**: the NCNAME+STAR token pair is disambiguated from the source text (`k * 2` mis-parsed as `k:*`).
+- multi-case `switch` (`case A case B return R`); `xs:float` registered; two `%lld` 32-bit-long print fixes (xsl:number, month-shift seconds).
+
+
+
+## [1.9.213] - 2026-09-21
+
+### Added — the op:date and yearMonth families (#1182, lever 6)
+
+- **op-date arithmetic (#1265)**: date/time/dateTime +/- dayTimeDuration — 6 QT3 sets, 128/128. Shared lexical shifter (`leptris_dt_shift`), time arithmetic wrapping the day, ISO date-shaped string comparisons. Fixed two corpus-caught bugs: zoned times misclassified as dateTimes, and dateTime results printing the input's seconds instead of the shifted instant's.
+- **yearMonthDuration family (#1266)**: 11 QT3 sets, 264/264 — months arithmetic (PnYnM canonical, llrint tie rule), month-end clamping for date/dateTime shifts (leap-aware), negative-year printing. The lt/gt sets rode the existing months comparison hook untouched.
+
+Both batches survived the 32-bit-long portability classes (MSVC/ILP32): int64-range instant math and every %lld argument now use long long — the CI legs caught three occurrences of the width/specifier mismatch family.
+
+## [1.9.212] - 2026-09-21
+
+### Added — the QT3 date/time family (lever 6 stage-2, #1182)
+
+Three corpus-driven batches land the date/time surface with the
+W3C QT3 suite as the gate:
+
+- **Extractors (#1261)**: 12 vendored test-sets (300/300) —
+  year/month/day-from-date{,Time}, hours/minutes/seconds-from-
+  {time,dateTime} — plus five language fixes: function-call
+  operands for eq/ne/lt/le/gt/ge (unprefixed and fn:-prefixed),
+  the `idiv` operator, unary `+`, the timezone scan in date
+  parsing (zoned values were treated as naive), and the
+  empty-sequence/fractional-seconds extractor contracts.
+- **Timezone + RFC 5322 (#1262)**: 5 sets (90/90) —
+  timezone-from-* accessors and fn:parse-ietf-date (both lexical
+  orders, obsolete US zones, verbatim fractions). The QT3 harness
+  grew inline param environments and external-declaration
+  prepending.
+- **op:dayTimeDuration value model (#1263)**: 8 sets (287/287) —
+  duration arithmetic (+, -, *, div), comparisons, min/max over
+  duration sequences, canonical formatting, FODT0002 range errors
+  (including a fixed fortified-runtime abort on giant values), and
+  adjust-* attaching the implicit timezone to naive values.
+
+## [1.9.211] - 2026-09-20
+
+### Performance
+
+- **Interleaved parse lane, slices 1-3a (#1258).** The first
+  pugixml-style interleaved rewrite landed behind
+  `LEPTRIS_INTERLEAVED=1` (opt-in; every input outside the covered
+  surface bails to the classic parser before any state). The lane
+  streams `IlRec`/`IlAttr` records with buffer-relative views, then
+  replays the classic public stores in one linear post-pass:
+  sentinel-discipline scans (no per-byte bounds tests; fused 48-byte
+  quote/'&'/whitespace probes with SIMD tails), upfront stream
+  capacity from the input size, and element/attribute names as
+  NUL'd views into the parse scratch (no per-name copies). Parity is
+  gated by a dedicated spec plus running the FULL test suite with
+  the lane forced on: 1633/1633 identical. `LEPTRIS_IL_STATS=1`
+  prints an engagement canary for diagnosing whether the lane ran.
+- **XSLT append-tail memo (#1259).** `out_append_child` keeps a
+  validated single-slot (parent, last-child) hint and feeds
+  `leptris_element_append_child_tail` — result-tree placement no
+  longer re-walks sibling chains (the hottest dispatch-heavy
+  profile leaf, ~17% of samples).
+
 ## [1.9.210] - 2026-09-20
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/TODO.max-perf/00-INDEX.md

@@ -24,3 +24,7 @@ Next portability gate: s390x big-endian (#1194, PR #1202).
 The node-layout fork (row 4 successor, owner green-lit 2026-09-20):
 TODO.max-perf/node-layout-fork.md — 5 slices, addresses #1222 +
 #1179 residual + #1238 parse side.
+
+The interleaved-parse rewrite (owner-directed 2026-09-20):
+TODO.max-perf/interleaved-parse.md — the #1222 step-change; slices 0-4,
+each CI-benchmark-gated.

data/vendor-src/libleptris/TODO.max-perf/interleaved-parse.md

@@ -0,0 +1,67 @@
+# The interleaved-parse rewrite (the pugixml-class lane)
+
+Status: PLAN (2026-09-20, owner directive). Supersedes the fork's
+remaining slices for the XML parse path. Target: close the #1222
+large-document gap (pugixml 2-5.9x ahead on CI) at the SOURCE.
+
+## Why the current lane can't get there
+
+The no-LTO dissection (2026-09-20) shows direct_parse is at its
+representation optimum: fused 48B probe + SIMD value scan, packed
+attr tail, O(1) wiring, offset edges, root-only registration. The
+remaining per-item cost is the representation itself: per-attr
+40B struct stores inline in the parse loop, the scratch
+NUL-terminate/restore dance, per-element ns/line bookkeeping, and
+the O(K) dup-detection walk.
+
+## The pugixml model (what we're adopting)
+
+One immutable input (already ours, #1125) + ONE node region + ONE
+stream region. The parse loop ONLY appends to streams; nothing is
+finalized inline:
+
+1. **SOA attr streams** — per element, attrs land in parallel
+   arrays: name_off[4B] / value_off[4B] / len8[len pairs] into the
+   string stream. ~12-16B per attr, sequential stores, no structs
+   built during parse.
+2. **Length-based views everywhere** — names and values are
+   (offset, len) into the pristine buffer. NO NUL-termination, NO
+   scratch mutation, NO restore pass (the current lane's biggest
+   hidden cost).
+3. **Element records as pure data** — a 32-48B record per element
+   (name view, first_attr index, parent/first/next indices, line)
+   bump-carved from the node region (doc_block, slice 1 landed).
+4. **Deferred passes** — dup detection, ns stamping, hash
+   sentinel: all become ONE linear post-pass sweep over the
+   streams (cache-sequential), building the public
+   leptris_attribute structs. The public API, DOM semantics, and
+   every consumer see IDENTICAL trees.
+
+## Slices (one PR each, CI-benchmark-gated)
+
+0. **A/B harness**: bench_parse_ab in benchmarks/ — the attr/text
+   shapes at 1.5/5/13MB, leptris vs pugixml vs libxml2, run by the
+   CI Benchmark legs on QUIET runners (the local Mac under load
+   343 produced 46-85 MB/s phantom numbers — measurements gate on
+   CI only). PR with this plan.
+1. **The dp_il lane skeleton** (flag off): streams + records +
+   post-pass building the public tree for well-formed, DTD-free
+   input. Gate: parity specs byte-identical to the current lane;
+   CI A/B numbers recorded.
+2. **Tokenizer port**: the SIMD scan helpers onto the stream
+   appends. Gate: attr shape ≤1.5x pugixml, text ≤1.25x on CI.
+3. **Feature coverage**: DTD/entity/namespace/CDATA/PI routes
+   through the lane (fall back to the classic lane per-feature,
+   never wrong). Gate: full ctest + html5lib-style parity for the
+   XML suite (W3C + libxml2 corpus green).
+4. **Default flip**: LEPTRIS_PARSE_INTERLEAVED=1 default, classic
+   lane behind an env escape hatch. Gate: all 24 CI legs + a
+   release cut with the CI A/B table in the notes.
+
+## Invariants (non-negotiable)
+
+- Public API/ABI unchanged; every existing spec passes unmodified.
+- The classic lane stays until slice 4 ships AND one full release
+  runs clean.
+- Zero-copy views remain primary; the pristine buffer is never
+  mutated by the interleaved lane.

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

@@ -232,6 +232,19 @@ leptris_add_benchmark(bench_xslt_subtree_copy xslt/bench_subtree_copy.c utils.c)
 # ----------------------------------------------------------------------------
 leptris_add_benchmark(bench_iterparse   sax/bench_iterparse.c)
 
+# Interleaved-parse gate (#1222): leptris vs pugixml on identical
+# fixtures, run by the CI Benchmark legs (quiet runners).
+if(PUGIXML_AVAILABLE)
+    leptris_add_benchmark(bench_parse_ab CXX parse/bench_parse_ab.cpp)
+    target_compile_definitions(bench_parse_ab PRIVATE HAVE_PUGIXML=1)
+    if(PUGIXML_TARGET)
+        target_link_libraries(bench_parse_ab PRIVATE ${PUGIXML_TARGET})
+    else()
+        target_include_directories(bench_parse_ab PRIVATE ${PUGIXML_INCLUDE_DIR})
+        target_link_libraries(bench_parse_ab PRIVATE ${PUGIXML_LIBRARY})
+    endif()
+endif()
+
 # ----------------------------------------------------------------------------
 # SAX benchmarks (leptris vs libxml2).  TODO 101.
 # ----------------------------------------------------------------------------

data/vendor-src/libleptris/benchmarks/parse/bench_parse_ab.cpp

@@ -0,0 +1,83 @@
+/* bench_parse_ab.cpp — the interleaved-parse lane's gate (#1222).
+ *
+ * Same fixtures, sizes, and shapes for leptris and pugixml,
+ * best-of-5 each. The CI Benchmark legs run this on quiet
+ * runners; the interleaved lane's slices are gated on THESE
+ * numbers, never a loaded dev machine (2026-09-20: a Mac at load
+ * 340 measured a 472 MB/s build at 46-85).
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "leptris.h"
+#ifdef HAVE_PUGIXML
+#include "pugixml.hpp"
+using namespace pugi;
+#endif
+
+static double now_us(void) {
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return ts.tv_sec * 1e6 + ts.tv_nsec / 1e3;
+}
+
+static size_t gen(char* out, size_t target, int text_shape) {
+    size_t len = 0;
+    len += (size_t)sprintf(out + len, "<root>");
+    int i = 0;
+    if (text_shape) {
+        while (len < target)
+            len += (size_t)sprintf(out + len,
+                "<p>The quick brown fox jumps over the lazy dog %d.</p>", i++);
+    } else {
+        while (len < target)
+            len += (size_t)sprintf(out + len,
+                "<item id=\"%d\" class=\"c%d\" state=\"on\" ref=\"%d\">v %d</item>",
+                i, i % 7, i * 3, i++);
+    }
+    len += (size_t)sprintf(out + len, "</root>");
+    return len;
+}
+
+int main(void) {
+    const size_t sizes[3] = {1500 * 1024, 5000 * 1024, 13000 * 1024};
+    const char* names[2] = {"attr", "text"};
+    printf("%-6s %9s %12s %12s\n", "shape", "bytes", "leptris", "pugixml");
+    for (int s = 0; s < 2; s++) {
+        for (size_t si = 0; si < 3; si++) {
+            char* doc = (char*)malloc(sizes[si] + 2048);
+            if (!doc) return 1;
+            size_t len = gen(doc, sizes[si], s);
+            double best = 1e18;
+            for (int r = 0; r < 5; r++) {
+                double a = now_us();
+                LeptrisStatus st = LEPTRIS_OK;
+                LeptrisDocument d = leptris_parse_string(doc, len, &st);
+                double b = now_us();
+                if (!d) { printf("PARSE FAILED\n"); return 1; }
+                leptris_document_free(d);
+                if (b - a < best) best = b - a;
+            }
+            double mbps = len / 1048576.0 / (best / 1e6);
+#ifdef HAVE_PUGIXML
+            double pbest = 1e18;
+            for (int r = 0; r < 5; r++) {
+                double a = now_us();
+                xml_document xdoc;
+                xml_parse_result res = xdoc.load_buffer(doc, len);
+                double b = now_us();
+                if (!res) { printf("PUGIXML FAILED: %s\n", res.description()); return 1; }
+                if (b - a < pbest) pbest = b - a;
+            }
+            double pmbps = len / 1048576.0 / (pbest / 1e6);
+            printf("%-6s %9zu %10.1f %10.1f  MB/s  (pugixml %.2fx)\n",
+                   names[s], len, mbps, pmbps, pmbps / mbps);
+#else
+            printf("%-6s %9zu %10.1f %10s\n", names[s], len, mbps, "-");
+#endif
+            free(doc);
+        }
+    }
+    return 0;
+}

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

@@ -62,6 +62,13 @@ typedef enum {
 #define LEPTRIS_PLAN_FLAG_ORDERED 0x2u       /* matches within a row keep document order (default) */
 #define LEPTRIS_PLAN_FLAG_CDATA 0x4u         /* CDATA sections count as text runs */
 #define LEPTRIS_PLAN_FLAG_NS_LENIENT 0x8u    /* #754: bind out-of-namespace children anyway */
+/* #1273: when set, the walk ALSO emits unmatched sibling non-element
+ * nodes (text runs / comments / PIs) as SCALAR values with
+ * `position` and `node_kind` populated, so ordered/mixed-content
+ * hosts can rebuild `element_order` without re-parsing the source.
+ * Document-order identity already covers element children; the
+ * spine closes the gap for runs between matched elements. */
+#define LEPTRIS_PLAN_FLAG_EMIT_ORDER_SPINE 0x10u
 
 /* Namespace matching form for binding an element. */
 typedef enum {
@@ -70,10 +77,24 @@ typedef enum {
     LEPTRIS_PLAN_NS_ANY = 2
 } LeptrisPlanNsForm;
 
+typedef struct {
+    const char* wire_name; /* XML attribute name as it appears on the wire */
+    const char* expected_value; /* string-equal match (non-nil); host-owned */
+} leptris_attr_predicate;
+
 typedef struct {
     const char* wire_name; /* XML attribute name as it appears on the wire */
     uint8_t kind;          /* LeptrisPlanKind: SCALAR | COLLECTION | CALLBACK */
     uint8_t type_tag;      /* host-defined; echoed back verbatim */
+    /* #1272: filter rows to require every (attr_name, expected_value)
+     * pair (AND across pairs). Multiple rows with the same wire_name
+     * and different predicates partition the match space
+     * (exclusive — first matching row wins per occurrence, no
+     * double-capture). Trailing additive field; `predicate_count = 0`
+     * preserves historical behavior. Strings deep-copied at build. */
+    uint16_t predicate_count;
+    uint16_t pad_pred;
+    const leptris_attr_predicate* predicates;
 } leptris_attr_plan;
 
 typedef struct {
@@ -91,6 +112,11 @@ typedef struct {
     uint8_t ns_form;       /* LeptrisPlanNsForm */
     uint8_t pad0;
     const char* ns_uri;    /* LEPTRIS_PLAN_NS_EXACT only */
+    /* #1272: element-side predicates. Same semantics as attr_predicate
+     * (AND across pairs, exclusive same-name rows). */
+    uint16_t predicate_count;
+    uint16_t pad_pred;
+    const leptris_attr_predicate* predicates;
 } leptris_child_plan;
 
 typedef struct {
@@ -168,6 +194,14 @@ LEPTRIS_API const char* leptris_plan_value_string(const LeptrisPlanResult v);
 LEPTRIS_API size_t leptris_plan_value_length(const LeptrisPlanResult v);
 /* CALLBACK: document byte offset of the source node (0 unknown). */
 LEPTRIS_API size_t leptris_plan_value_position(const LeptrisPlanResult v);
+/* #1273: LEPTRIS_NODE_TYPE_* of the value's source node, or 0 for
+ * ELEMENT/COLLECTION wrappers and synthesized text. */
+LEPTRIS_API uint8_t leptris_plan_value_node_kind(const LeptrisPlanResult v);
+/* #1273: dense sibling rank inside the producing element (0 if
+ * unranked). Useful when byte offsets are 0 (mutated docs) or
+ * when hosts sort by document order without byte-offset helpers. */
+LEPTRIS_API uint32_t leptris_plan_value_order_index(
+    const LeptrisPlanResult v);
 /* ELEMENT: child-value count. COLLECTION: item count. */
 LEPTRIS_API size_t leptris_plan_value_count(const LeptrisPlanResult v);
 /* ELEMENT child value / COLLECTION item at i; NULL out of range. */
@@ -177,6 +211,30 @@ LEPTRIS_API LeptrisPlanResult leptris_plan_value_at(const LeptrisPlanResult v,
 LEPTRIS_API const char* leptris_plan_value_attribute(const LeptrisPlanResult v,
                                                      const char* wire_name);
 
+/* #1269a in-pass type execution (#1269a): for SCALAR/RAW values
+ * whose producing row carried type_tag in {1=int, 2=float, 3=bool},
+ * the walk parses the string once and stores typed values. The str
+ * field is always populated for backward compatibility. Accessors
+ * return 0 on success (matches type) and non-zero on parse failure
+ * (host may fall back to `string`). NULL in or non-numeric value is
+ * a failure. */
+LEPTRIS_API int leptris_plan_value_int(const LeptrisPlanResult v,
+                                       int64_t* out);
+LEPTRIS_API int leptris_plan_value_float(const LeptrisPlanResult v,
+                                         double* out);
+/* `true` / `1` (case-insensitive) -> 1, `false` / `0` -> 0, anything
+ * else leaves *out untouched and returns non-zero. */
+LEPTRIS_API int leptris_plan_value_bool(const LeptrisPlanResult v, int* out);
+
+/* #1269b fused parse+walk entry. v1 = parse_string + walk(root) +
+ * free(doc) — byte-parity with Descriptor#materialize. Returns the
+ * same result type as leptris_plan_walk; status reports
+ * LEPTRIS_ERROR_PARSE on syntax error. NULL doc / plan / status
+ * handled. The caller still owns plan lifetime. */
+LEPTRIS_API LeptrisPlanResult leptris_plan_materialize(
+    const char* source, size_t source_len,
+    LeptrisPlan plan, LeptrisStatus* status);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -1846,6 +1846,36 @@ LEPTRIS_API const char* leptris_attribute_get_name(LeptrisAttribute attr);
  */
 LEPTRIS_API const char* leptris_attribute_get_value(LeptrisElement elem, LeptrisAttribute attr);
 
+/**
+ * Bulk attribute read face (#1254): one C pass per element returns
+ * names, values, AND attribute handles in parallel — the shape
+ * bindings need to replace the 4-calls-per-attribute chain
+ * (first / get_name / get_value / next) with a single dispatch.
+ *
+ * Names and values are the element's canonical attribute list in
+ * source order (xmlns declarations excluded — they live in the
+ * separate namespace channel, matching
+ * leptris_element_first_attribute). Handles let mutation-capable
+ * consumers keep native attribute references; pass NULL for any
+ * column to skip it.
+ *
+ * @param elem Element
+ * @param out_names Output array of name strings, or NULL to skip
+ * @param out_values Output array of value strings (parallel), or
+ *                   NULL to skip
+ * @param out_attrs Output array of attribute handles (parallel), or
+ *                  NULL to skip
+ * @param max_count Capacity of the non-NULL output arrays
+ * @return The total attribute count (min(total, max_count) copied)
+ *
+ * Memory: Strings and handles are owned by the element/document.
+ * Do not free separately. Handles stay valid until the attribute
+ * is removed or the document is freed.
+ */
+LEPTRIS_API size_t leptris_element_attribute_pairs(
+    LeptrisElement elem, const char** out_names, const char** out_values,
+    LeptrisAttribute* out_attrs, size_t max_count);
+
 /**
  * Get number of child elements
  *