leptris 1.9.255.2-aarch64-linux → 1.9.260.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 583e62637e873d0b31061bbec3c5d349bda4758bb6f726096946eb1253ca2a2e
-  data.tar.gz: 8a0a7157c908c99229aa526a5e94d0c2096ec4104f12a6b052ad5c6e17262d23
+  metadata.gz: 39822128a76bd5e8577fa205e78b12fb8c7d6cd650cd2203119fe4149df7aae6
+  data.tar.gz: 7a1758bf64416c5fa68cb74e87cde097fa5e723545f421034c0eb2d3bb82a9c3
 SHA512:
-  metadata.gz: c6ae63770d8178e4d37686f4f5e112b0fbbdd8a83ee5829c3d6f40735ae0be181ad151376a339d379b97915eb478a580e24b3b09bd666135f0819b6641f59a76
-  data.tar.gz: 6a102e04847a8726457aa291c481951418920f9d4b4e29562695ac851bc3243ce25f31f439fd0125a5e96d5527babaf1b38079d18e5a3cf37269e4ed90b17108
+  metadata.gz: c21d9c66e827d8ea0e5630ede4b1a29605cffa57cc0f9afe031d83d07e7c02105632c651fe3833809156eee93bfc7e2c60e964850262633fc7df23e199936f22
+  data.tar.gz: 407422ade60aa9fec1013685f4f8a27ea7218ff102792b44b08bea1fd326b2018a2e2ac4c918948ce97a83ed0be764dde77442831b70a1925ccc116894049425

data/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to Leptris will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.260.0] - 2026-09-27
+
+### Fixed
+
+- Vendored libleptris 1.9.260 (riding 1.9.256-1.9.260):
+  - xquery: numeric variable predicates are positional, not EBV
+    (v1.9.256); typed-scalar carriers convert in the single-item
+    predicate path (v1.9.259); the bare FLWOR initializer scan
+    terminates at outer clause words (v1.9.260).
+
+### Performance — engine sync
+
+- Lane 18 rounds 1-2 (v1.9.257/258): duplicate-attribute scan via
+  a per-element FNV-1a hash prefilter (was an O(N^2) memcmp walk)
+  and namebp document resolution before the locked root-map
+  lookup — builder append 39.7 -> ~30 ns/child.
+
 ## [1.9.255.0] - 2026-09-26
 
 ### Fixed

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.255"
+LIBLEPTRIS_VERSION = "1.9.260"
 # 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.255.2"
+  VERSION = "1.9.260.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.255
+- libleptris v1.9.260
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,49 @@
 ## [Unreleased]
 
+## [1.9.260] - 2026-09-27
+
+### Fixed
+
+- bare FLWOR initializer scan terminates at outer clause words (xquery)
+
+
+
+## [1.9.259] - 2026-09-26
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Changed
+
+- (describe changes here)
+
+
+## [1.9.258] - 2026-09-26
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Changed
+
+- (describe changes here)
+
+
+## [1.9.257] - 2026-09-26
+
+### Performance
+
+- resolve namebp documents before the locked root-map lookup (dom)
+
+
+
+## [1.9.256] - 2026-09-26
+
+### Fixed
+
+- numeric variable predicates are positional, not EBV (xquery)
+
+
+
 ## [1.9.255] - 2026-09-26
 
 <!-- Edit this section with the actual release notes. -->

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/src/leptris/dom/root_doc_map.c

@@ -414,6 +414,14 @@ struct leptris_document* leptris_element_get_document(LeptrisElement elem) {
         if (!parent) break;
         cur = parent;
     }
+    /* Lane 18 P2: resolve the namebp backpointer BEFORE the locked
+     * map. Fast-path-created roots (mut_elem_carve) carry the doc
+     * statelessly in the name slot and never register, so the map
+     * below always misses for them — the append/builder loop paid
+     * the mutex on every call to reach the same answer. The namebp
+     * value is stamped at create and cannot go stale. */
+    if (cur->name && leptris_elem_has_namebp(cur))
+        return leptris_elem_namebp_doc(cur);
     /* Locked bucket walk with an UNDER-THE-LOCK generation
      * snapshot: a death that acquires the lock after we release
      * bumps the global generation past our snapshot, so the primed

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

@@ -1004,7 +1004,8 @@ struct leptris_xpath_result* evaluate_expr(XPathContext* ctx, XPathASTNode* ast)
                     ctx->context_position = 1;
                     ctx->context_size = 1;
                     struct leptris_xpath_result* pr =
-                        evaluate_expr(ctx, pred);
+                        leptris_pred_scalar_convert(
+                            evaluate_expr(ctx, pred));
                     ctx->context_node = old_node;
                     ctx->context_position = old_pos;
                     ctx->context_size = old_size;

data/vendor-src/libleptris/src/leptris/xpath/evaluator_internal.h

@@ -76,6 +76,11 @@ struct leptris_xpath_result* evaluate_expr(XPathContext* ctx, XPathASTNode* ast)
 /* Marker-aware atomic eq over raw item strings (evaluator_operators.c). */
 int leptris_atom_seq_eq_n(const char* a, const char* b, int nan_equal);
 
+/* Typed-scalar carrier conversion for predicates (evaluator_path.c):
+ * takes ownership; single numeric-marker carriers become NUMBER. */
+struct leptris_xpath_result* leptris_pred_scalar_convert(
+    struct leptris_xpath_result* r);
+
 /* xs:time lexical -> timezone-normalized seconds (cycle = mod 86400
  * for equality; linear = unbounded for ordering); either out may be
  * NULL. Returns 0 when s is not a time lexical. */

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

@@ -281,6 +281,34 @@ int matches_node_test(XPathContext* ctx, LeptrisNode* node, XPathASTNode* test)
 /* Helper: Evaluate a single predicate for a node in-place
  * Returns 1 if node matches predicate, 0 otherwise
  */
+/* Typed-scalar carrier conversion for predicates: the xq driver
+ * binds every variable as a sequence carrier, so a numeric atomic
+ * rides one marked text node. A bare variable predicate must then be
+ * POSITIONAL (number -> position compare), not EBV-of-a-one-item
+ * sequence (cbcl-distinct-values-007). Takes ownership of r; when
+ * converted, the carrier copy is freed through the result and a
+ * fresh NUMBER result returns. NULL propagates. */
+struct leptris_xpath_result* leptris_pred_scalar_convert(
+    struct leptris_xpath_result* r) {
+    if (!r || r->type != XPATH_RESULT_NODESET || !r->value.nodeset_value ||
+        r->value.nodeset_value->count != 1 ||
+        !r->value.nodeset_value->nodes[0] ||
+        XPATH_NODE_TYPE(r->value.nodeset_value->nodes[0]) !=
+            LEPTRIS_NODE_TEXT)
+        return r;
+    const char* c =
+        ((XPathTextNode*)r->value.nodeset_value->nodes[0])->content;
+    if (!c || c[0] != '\x03' ||
+        (c[1] != 'N' && c[1] != 'F' && c[1] != 'D'))
+        return r;
+    double v = strtod(c + 2, NULL);
+    xpath_result_free(r);
+    struct leptris_xpath_result* out =
+        xpath_result_new(XPATH_RESULT_NUMBER);
+    if (out) out->value.number_value = v;
+    return out;
+}
+
 static int evaluate_predicate_for_node(XPathContext* ctx,
                                        void* node,
                                        XPathASTNode* predicate,
@@ -328,6 +356,9 @@ static int evaluate_predicate_for_node(XPathContext* ctx,
     struct leptris_xpath_result* pred_result = evaluate_expr(ctx, predicate);
     int matches = 0;
 
+    pred_result = leptris_pred_scalar_convert(pred_result);
+    if (!pred_result) return 0;
+
     if (pred_result) {
         /* Numeric predicate: matches position */
         if (pred_result->type == XPATH_RESULT_NUMBER) {

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

@@ -173,24 +173,39 @@ static int is_clause_word(const char* w, size_t len) {
 /* Advance over one FLWOR expression segment: stops before a clause
  * keyword at nesting depth 0 (a bare word delimited by whitespace
  * or segment end). */
-static void scan_expr_segment(Scan* s, int stop_at_comma) {
+static void scan_expr_segment(Scan* s, int stop_at_comma,
+                              int allow_bare_flwor) {
     int depth = 0;
+    /* A binding expression that STARTS with for/let is a bare
+     * nested FLWOR (let $x := for ... return ...): its clause
+     * keywords are inert and `return` closes the nesting. Segments
+     * that merely CONTAIN a depth-0 for/let after a complete
+     * expression (for $i in (1,2,3) let ...) keep the old boundary.
+     * allow_bare_flwor arms the check for the first word only. */
+    int flwor_nest = 0;
+    int seen_token = 0;   /* any non-space token consumed yet? */
     while (s->p < s->end) {
         char c = *s->p;
         if (c == '\'' || c == '"') {
             scan_string(s);
+            seen_token = 1;
             continue;
         }
         if (c == '`') {
             s->p++;
             while (s->p < s->end && *s->p != '`') s->p++;
             if (s->p < s->end) s->p++;
+            seen_token = 1;
             continue;
         }
-        if (c == '(' || c == '[' || c == '{') depth++;
+        if (c == '(' || c == '[' || c == '{') {
+            depth++;
+            seen_token = 1;
+        }
         else if (c == ')' || c == ']' || c == '}') {
             if (depth == 0) return;   /* segment boundary */
             depth--;
+            seen_token = 1;
         } else if (c == ',' && depth == 0 && stop_at_comma) {
             return;
         } else if (depth == 0 &&
@@ -202,9 +217,25 @@ static void scan_expr_segment(Scan* s, int stop_at_comma) {
                  * by whitespace/segment end. scan_word does not
                  * advance the cursor — look past the word. */
                 const char* after = w + wl;
-                if (after >= s->end || isspace((unsigned char)*after))
-                    return;
+                int at_boundary =
+                    after >= s->end || isspace((unsigned char)*after);
+                if (at_boundary && !seen_token && allow_bare_flwor &&
+                    (word_is(w, wl, "for") || word_is(w, wl, "let"))) {
+                    flwor_nest = 1;
+                    seen_token = 1;
+                    s->p += wl;
+                    continue;
+                }
+                if (at_boundary && flwor_nest > 0) {
+                    if (word_is(w, wl, "return")) flwor_nest--;
+                    seen_token = 1;
+                    s->p += wl;
+                    continue;
+                }
+                seen_token = 1;
+                if (at_boundary) return;
             }
+            seen_token = 1;
             s->p += wl ? wl : 1;
             continue;
         }
@@ -1424,7 +1455,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                             }
                             s.p = iw + iwl;
                             Scan e = s;
-                            scan_expr_segment(&e, 0);
+                            scan_expr_segment(&e, 0, 0);
                             wc.win.domain = parse_expr_span(s.p, e.p);
                             if (!wc.win.domain) {
                                 xq_clause_partial_free(&wc);
@@ -1471,7 +1502,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                                 if (wwl2 && word_is(ww, wwl2, "when")) {
                                     s.p = ww + wwl2;
                                     Scan se = s;
-                                    scan_expr_segment(&se, 0);
+                                    scan_expr_segment(&se, 0, 0);
                                     wc.win.s_when =
                                         parse_expr_span(s.p, se.p);
                                     if (!wc.win.s_when) {
@@ -1520,7 +1551,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                                     if (wwl2 && word_is(ww, wwl2, "when")) {
                                         s.p = ww + wwl2;
                                         Scan ee = s;
-                                        scan_expr_segment(&ee, 0);
+                                        scan_expr_segment(&ee, 0, 0);
                                         wc.win.e_when =
                                             parse_expr_span(s.p, ee.p);
                                         if (!wc.win.e_when) {
@@ -1616,7 +1647,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                             s.p += 2;
                         }
                         Scan e = s;
-                        scan_expr_segment(&e, 1);
+                        scan_expr_segment(&e, 1, 1);
                         XPathASTNode* expr = parse_expr_span(s.p, e.p);
                         if (!expr) {
                             free(var);
@@ -1649,7 +1680,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                     }
                 } else if (word_is(kw, kwl, "where")) {
                     Scan e = s;
-                    scan_expr_segment(&e, 0);
+                    scan_expr_segment(&e, 0, 0);
                     /* WHERE after GROUP BY filters the GROUPED
                      * tuples (aggregates see the whole group) */
                     XPathASTNode* w_ast = parse_expr_span(s.p, e.p);
@@ -1722,7 +1753,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                             s.p[1] == '=') {
                             s.p += 2;
                             Scan e = s;
-                            scan_expr_segment(&e, 0);
+                            scan_expr_segment(&e, 0, 0);
                             gk = parse_expr_span(s.p, e.p);
                             if (!gk) {
                                 free(gvar);
@@ -1800,7 +1831,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                     for (;;) {
                         scan_ws(&s);
                         Scan e = s;
-                        scan_expr_segment(&e, 1);   /* stop at ',' */
+                        scan_expr_segment(&e, 1, 1);   /* stop at ',' */
                         XPathASTNode* key = parse_expr_span(s.p, e.p);
                         if (!key) {
                             xq_free(q);

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

@@ -160,7 +160,13 @@ TEST(DomBasics, DocumentSetRootRejectsParentedElement) {
 TEST(DomBasics, RootDocMemoClearedWhenRootUnregisters) {
     LeptrisDocument doc = leptris_document_create();
     ASSERT_NE(doc, nullptr);
-    LeptrisElement e = leptris_element_create(doc, "r");
+    /* A >254-char name forces the pool-fallback create: no namebp
+     * backpointer, so the element is MAP-resolved. Lane 18 P2 made
+     * namebp-carrying elements resolve statelessly before the map
+     * (no memo to prime, nothing to invalidate); the unregistration
+     * contract below is about the map-primed memo. */
+    std::string long_name(300, 'x');
+    LeptrisElement e = leptris_element_create(doc, long_name.c_str());
     ASSERT_NE(e, nullptr);
     leptris_root_doc_register(e, doc);
     /* Prime the memo through a resolution. */

data/vendor-src/libleptris/test/xquery/test_qt3.cpp

@@ -983,14 +983,21 @@ TEST(Qt3Subset, FnDistinctValues) {
      * fn-distinct-values-1 (Bugzilla 5183: float must promote UP to
      * double, never the reverse) close with F&O promotion in the
      * dedup comparator. */
-    /* fn-distinct-values-2 adopted: the assert-permutation
-     * harness expands "N to M" range tokens (values were already
-     * engine-correct; the blocker was harness-side). */
-    run_test_set("fn/distinct-values.xml", {}, 98, {},
+    /* cbcl-distinct-values-007: both halves are in (tz-normalized
+     * time equality + typed-scalar predicates) and the query is
+     * correct on macOS, but Linux/ASAN still evaluates
+     * xs:dayTimeDuration("PT0S")[$p] with the at-bound position as
+     * EBV-true (all-Z output) — a narrow platform divergence to
+     * chase separately. */
+    /* cbcl-distinct-values-007 now passes everywhere: BOTH predicate
+     * paths convert typed-scalar carriers (the nodeset-base path via
+     * evaluate_predicate_for_node AND the single-item base path in
+     * the XPATH_AST_PREDICATE handler — xs:dayTimeDuration("PT0S")[$p]
+     * takes the latter). */
+    run_test_set("fn/distinct-values.xml", {}, 99, {},
                  {
                    "cbcl-distinct-values-002",
                    "cbcl-distinct-values-002b",
-                   "cbcl-distinct-values-007",
 
                  });
 }

data/vendor-src/libleptris/test/xquery/test_xquery.cpp

@@ -66,6 +66,27 @@ TEST(XQueryCore, PrologVariableAndFlwor) {
     leptris_document_free(doc);
 }
 
+TEST(XQueryCore, BareFlworInitializer) {
+    /* A binding expression may itself start a FLWOR without
+     * parentheses; the OUTER clause words (let/order by/where/
+     * return) must still terminate the inner scan. Regression
+     * shape from QT3 K2-OrderbyExprWithout. */
+    LeptrisDocument doc = leptris_parse_string("<r/>", 4, nullptr);
+    ASSERT_NE(doc, nullptr);
+    EXPECT_EQ(seq_string(doc,
+        "let $x := for $i in (1,2) return $i * 10 return $x"),
+        "10 20");
+    EXPECT_EQ(seq_string(doc,
+        "for $a in (1, 4, 2) let $i := (1, 3, 2) "
+        "order by $a return $i"),
+        "1 3 2 1 3 2 1 3 2");
+    EXPECT_EQ(seq_string(doc,
+        "for $i in (1, 2, 3) let $s := $i * $i "
+        "where $i > 1 return $s"),
+        "4 9");
+    leptris_document_free(doc);
+}
+
 TEST(XQueryCore, OrderByDescending) {
     LeptrisDocument doc = leptris_parse_string(kBooks, strlen(kBooks),
                                                nullptr);
@@ -1215,6 +1236,52 @@ TEST(XQueryCore, MixedNumericCompare) {
 }
 
 
+TEST(XQueryCore, VarPredicatePositional) {
+    LeptrisDocument doc = leptris_parse_string("<e/>", 4, nullptr);
+    ASSERT_NE(doc, nullptr);
+    struct {
+        const char* q;
+        const char* want;
+    } cases[] = {
+        /* a numeric variable is a POSITIONAL predicate: position()
+         * = $p — not EBV. The xq driver binds vars as sequence
+         * carriers, so the bare-var predicate took the EBV-true
+         * path and kept the whole sequence. */
+        {"let $p := 2 return count((10,20,30)[$p])", "1"},
+        {"let $p := 2 return (10,20,30)[$p]", "20"},
+        {"string-join(for $p in (2,3) return"
+         " string((10,20,30)[$p]), '|')", "20|30"},
+        {"let $p := 2.0 return count((10,20,30)[$p])", "1"},
+        {/* cbcl-distinct-values-007's shape: positional predicate
+         * on a singleton sequence (function-call base) */
+         "let $p := 1 return"
+         " count(xs:dayTimeDuration('PT0S')[$p])", "1"},
+        {/* single-item base path: the XQUERY entry must convert the
+         * carrier in the AST_PREDICATE handler too */
+         "let $p := 2 return"
+         " string(adjust-time-to-timezone(xs:time('12:00:00'),"
+         " (xs:dayTimeDuration('PT0S')[$p])))", "12:00:00"},
+        {"count(distinct-values((xs:time('12:00:00'),"
+         " xs:time('12:00:00'), xs:time('20:00:00'),"
+         " xs:time('01:00:00+12:00'), xs:time('02:00:00+13:00'))))",
+         "3"},
+    };
+    for (auto& c : cases) {
+        LeptrisXQuery xq = leptris_xquery_parse(c.q, strlen(c.q));
+        ASSERT_NE(xq, nullptr) << c.q;
+        LeptrisXPathResult r = leptris_xquery_eval(xq, doc, NULL);
+        ASSERT_NE(r, nullptr) << c.q;
+        char* s = leptris_xpath_result_string(r);
+        ASSERT_NE(s, nullptr) << c.q;
+        EXPECT_STREQ(s, c.want) << c.q;
+        leptris_free_string(s);
+        leptris_xpath_result_free(r);
+        leptris_xquery_free(xq);
+    }
+    leptris_document_free(doc);
+}
+
+
 TEST(XQueryCore, TimeTzEq) {
     LeptrisDocument doc = leptris_parse_string("<e/>", 4, nullptr);
     ASSERT_NE(doc, nullptr);

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.255",
+  "version": "1.9.260",
   "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.255.2
+  version: 1.9.260.0
 platform: aarch64-linux
 authors:
 - Ribose Inc.