leptris 1.9.249.0-arm-linux → 1.9.255.1-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5d9d59022a553eb806991fc47891ebe5e775eae726bb7a4c0987513bd585e41
-  data.tar.gz: 4e5f8c02241089ec82b643489b453f7fd9347db0076bd4134102a84ade71f917
+  metadata.gz: 7b4e0a9650a8476f55d7168393310d84a0f0bc5c4bc68afbcb8da52eb4461b88
+  data.tar.gz: faeaa46310e9c4034055c61971d3129a0beb92e0aed1dfb3fdb316e40c5a9b83
 SHA512:
-  metadata.gz: c69e15c543bf77c4f0bb32bfb012194a08873bbb433832f783ecd652b8b316709a5ee8cc805aae483f2636c467e4d83ab206e3a637ce18e1305e010e6b453a56
-  data.tar.gz: 3b62bb55637f6db12c7c309fa3658a085c928afd4e5939a30c2261f29bb763d2980acf7afaf55c57783af2c0adfc4cba21bcf6939d50db1d7d57116691b1bfc5
+  metadata.gz: 6b96a662e7a06ecb95d7a5545a7c69d91c071738362837a061017ccccf1fd11e56b05594e2a42b15fb1fe6e1c9e10bc5fc34cc3d668dc35c1d580d2694c0bdca
+  data.tar.gz: f8ff48b9d740b085b7945cf5a0a9a2a2ccd9582589a8331e86b7f56d9a4226ce014a642bdb4b1141770b51fa00e92036496dd19d19230b7573e84478778265c0

data/CHANGELOG.md

@@ -5,6 +5,25 @@ 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.255.0] - 2026-09-26
+
+### Fixed
+
+- Vendored libleptris 1.9.255 (riding 1.9.249-1.9.255, seven
+  engine syncs). Highlights:
+  - xquery: numeric-variable predicates are positional, not EBV —
+    (1)[1] keeps the atom, (1)[1] + 1 = 2 (#1392).
+  - xquery: document{...} materializes a real node (path steps
+    resolve over constructor results), the ! simple map is
+    item-preserving, multi-binding for/quantifier clauses parse,
+    and keyword constructors run the path continuation.
+  - xquery: F&O 3.0 numeric type promotion in value comparisons
+    and dedup (QT3 typed-atom lane) + timezone-normalized
+    xs:time comparison.
+  - html: implied-end pair checks run on tag ids with the tag
+    table gaps fixed (rb/rp/rt/rtc, option/optgroup) — round 2 of
+    the #1218 parse profile.
+
 ## [1.9.248.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.248"
+LIBLEPTRIS_VERSION = "1.9.255"
 # 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.249.0"
+  VERSION = "1.9.255.1"
 end

data/lib/leptris/xml/plan_value.rb

@@ -31,33 +31,33 @@ class Leptris::XML::PlanValue
   end
 
   def kind
-    inc_crossing
+    @counter[0] += 1
     VALUE_KINDS.fetch(Leptris::XML::FFI.leptris_plan_value_kind(@ptr))
   end
 
   # wire_name of the plan row that produced this value.
   def name
-    inc_crossing
+    @counter[0] += 1
     Leptris::XML::FFI.leptris_plan_value_name(@ptr)
   end
 
   # Host type_tag echoed verbatim (0 when the row had none).
   def type_tag
-    inc_crossing
+    @counter[0] += 1
     Leptris::XML::FFI.leptris_plan_value_type_tag(@ptr)
   end
 
   # #1273: LEPTRIS_NODE_TYPE_* of this value's source node (0 for
   # ELEMENT/COLLECTION wrappers and synthesized text).
   def node_kind
-    inc_crossing
+    @counter[0] += 1
     Leptris::XML::FFI.leptris_plan_value_node_kind(@ptr)
   end
 
   # #1273: dense sibling rank inside the producing element (0 if
   # unranked) — document-order identity without byte offsets.
   def order_index
-    inc_crossing
+    @counter[0] += 1
     Leptris::XML::FFI.leptris_plan_value_order_index(@ptr)
   end
 
@@ -85,26 +85,26 @@ class Leptris::XML::PlanValue
 
   # SCALAR / RAW / CALLBACK string value.
   def string_value
-    inc_crossing
+    @counter[0] += 1
     Leptris::XML::FFI.leptris_plan_value_string(@ptr)
   end
 
   # CALLBACK: document byte offset of the source node (0 unknown).
   def position
-    inc_crossing
+    @counter[0] += 1
     Leptris::XML::FFI.leptris_plan_value_position(@ptr)
   end
 
   # ELEMENT: child-value count. COLLECTION: item count.
   def count
-    inc_crossing
+    @counter[0] += 1
     Leptris::XML::FFI.leptris_plan_value_count(@ptr)
   end
 
   # ELEMENT child value / COLLECTION item at +i+ (nil out of
   # range). Borrowed: the owning root must stay alive.
   def at(i)
-    inc_crossing
+    @counter[0] += 1
     ptr = Leptris::XML::FFI.leptris_plan_value_at(@ptr, i)
     return nil if ptr.null?
     child_plan = child_plan_for_position(ptr)
@@ -114,7 +114,7 @@ class Leptris::XML::PlanValue
 
   # ELEMENT: attribute value by wire_name (nil when absent).
   def attribute(wire_name)
-    inc_crossing
+    @counter[0] += 1
     Leptris::XML::FFI.leptris_plan_value_attribute(@ptr, wire_name.to_s)
   end
 
@@ -149,7 +149,7 @@ class Leptris::XML::PlanValue
   # (0 when absent). Collection rows appear as Arrays; callbacks
   # are emitted as +{value:, position:, type_tag:}+ like #to_ruby.
   def as_kwarg_hash
-    inc_crossing # the kind probe + name + type_tag are one logical fetch
+    @counter[0] += 1 # the kind probe + name + type_tag are one logical fetch
     case kind
     when :element
       {
@@ -194,9 +194,6 @@ class Leptris::XML::PlanValue
 
   private
 
-  def inc_crossing
-    @counter[0] += 1
-  end
 
   def kwarg_attributes
     ((@plan && @plan[:attributes]) || []).each_with_object({}) do |row, result|
@@ -290,7 +287,7 @@ class Leptris::XML::PlanValue
     rows = @plan[:children] || []
     row = rows.size == 1 ? rows.first : nil
     unless row
-      inc_crossing
+      @counter[0] += 1
       child_name = Leptris::XML::FFI.leptris_plan_value_name(ptr)
       row = rows.find { |r| r[:name] == child_name }
     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.248
+- libleptris v1.9.255
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,63 @@
 ## [Unreleased]
 
+## [1.9.255] - 2026-09-26
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Changed
+
+- (describe changes here)
+
+
+## [1.9.254] - 2026-09-26
+
+### Added
+
+- timezone-normalized xs:time comparison and ordering (xquery)
+
+
+
+## [1.9.253] - 2026-09-26
+
+### Fixed
+
+- F&O numeric promotion in value comparison and distinct-values (xquery)
+
+
+
+## [1.9.252] - 2026-09-26
+
+### Added
+
+- multi-binding for/quantifier clauses (xquery)
+
+
+
+## [1.9.251] - 2026-09-26
+
+### Added
+
+- document{} materializes a node; simple map preserves items (xquery)
+
+
+
+## [1.9.250] - 2026-09-26
+
+### Fixed
+
+- keyword ctors run the path continuation (document{...}/M) (xquery)
+
+
+
+## [1.9.249] - 2026-09-26
+
+### Performance
+
+- classify implied-end pairs on tag ids (#1218) (html)
+
+
+
 ## [1.9.248] - 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.248
+    VERSION 1.9.255
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

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

@@ -211,6 +211,21 @@ endif()
 leptris_add_benchmark(bench_serialize        serialization/bench_leptris_serialize.c)
 leptris_add_benchmark(bench_modify_leptris    modification/bench_leptris_modify.c)
 
+# Lane 18 (#1179): append + attr-parse vs pugixml (the lane bar is
+# <=1x on both shapes). Needs C++ (pugixml.hpp) and the pugixml
+# target; skipped when the dependency is absent.
+if(PUGIXML_AVAILABLE)
+    add_executable(bench_append_attr_pugixml
+                   modification/bench_append_attr_pugixml.cpp)
+    target_link_libraries(bench_append_attr_pugixml PRIVATE leptris::leptris)
+    if(PUGIXML_TARGET)
+        target_link_libraries(bench_append_attr_pugixml PRIVATE ${PUGIXML_TARGET})
+    else()
+        target_include_directories(bench_append_attr_pugixml PRIVATE ${PUGIXML_INCLUDE_DIR})
+        target_link_libraries(bench_append_attr_pugixml PRIVATE ${PUGIXML_LIBRARY})
+    endif()
+endif()
+
 # XSLT release scorecard (TODO.xslt-full/13, #682): the transform
 # fixtures the perf lane gates on — best-of protocol, never mean.
 leptris_add_benchmark(bench_xslt_dispatch     xslt/bench_dispatch.c utils.c)

data/vendor-src/libleptris/benchmarks/modification/bench_append_attr_pugixml.cpp

@@ -0,0 +1,79 @@
+// bench_append_attr_pugixml — Lane 18 (#1179): DOM append and
+// attr-parse throughput vs pugixml. The lane bar is append <=1x and
+// attr-parse <=1x against pugixml on these shapes.
+#include "leptris.h"
+#include "pugixml.hpp"
+#include <chrono>
+#include <cstdio>
+#include <cstring>
+#include <string>
+
+static double now_ns() {
+    return (double)std::chrono::duration_cast<std::chrono::nanoseconds>(
+               std::chrono::steady_clock::now().time_since_epoch())
+        .count();
+}
+
+int main(void) {
+    const int N_APPEND = 200000;
+    const int N_PARSE = 20000;
+
+    /* ---- append: 200k element children on one root ---- */
+    {
+        double t0 = now_ns();
+        LeptrisDocument d = leptris_document_create();
+        LeptrisElement root = leptris_element_create(d, "root");
+        leptris_document_set_root(d, root);
+        for (int i = 0; i < N_APPEND; i++) {
+            LeptrisElement c = leptris_element_create(d, "c");
+            leptris_element_append_child(root, c);
+        }
+        double t1 = now_ns();
+        printf("append leptris  : %8.1f ns/child\n",
+               (t1 - t0) / N_APPEND);
+        leptris_document_free(d);
+    }
+    {
+        double t0 = now_ns();
+        pugi::xml_document d;
+        pugi::xml_node root = d.append_child("root");
+        for (int i = 0; i < N_APPEND; i++)
+            root.append_child("c");
+        double t1 = now_ns();
+        printf("append pugixml  : %8.1f ns/child\n",
+               (t1 - t0) / N_APPEND);
+    }
+
+    /* ---- attr-parse: parse 20k docs, 4 elems x 16 attrs ---- */
+    std::string xml = "<r>";
+    for (int e = 0; e < 4; e++) {
+        xml += "<e";
+        for (int a = 0; a < 16; a++)
+            xml += " a" + std::to_string(a) + "='value-" +
+                   std::to_string(a) + "-xyz'";
+        xml += "/>";
+    }
+    xml += "</r>";
+    {
+        double t0 = now_ns();
+        for (int i = 0; i < N_PARSE; i++) {
+            LeptrisDocument d =
+                leptris_parse_string(xml.data(), xml.size(), NULL);
+            leptris_document_free(d);
+        }
+        double t1 = now_ns();
+        printf("attrparse leptris: %7.1f ns/doc (%zu bytes)\n",
+               (t1 - t0) / N_PARSE, xml.size());
+    }
+    {
+        double t0 = now_ns();
+        for (int i = 0; i < N_PARSE; i++) {
+            pugi::xml_document d;
+            d.load_buffer((void*)xml.data(), xml.size());
+        }
+        double t1 = now_ns();
+        printf("attrparse pugixml: %7.1f ns/doc\n",
+               (t1 - t0) / N_PARSE);
+    }
+    return 0;
+}

data/vendor-src/libleptris/src/leptris/flat/direct_parse.c

@@ -108,6 +108,13 @@ typedef struct {
      * (the element cache line only needs touching twice per tag). */
     struct leptris_attribute* attr_cursor;
     struct leptris_attribute* attr_end;
+    /* #1200 round 2: per-element attr-name hash prefilter — the
+     * dup scan compares uint32 hashes (uint32 loop, no pointer
+     * chasing) and only walks the attr chain with memcmp on a hash
+     * hit. Pool-backed growth; reset per element. */
+    uint32_t* attr_dup_hashes;
+    size_t attr_dup_count;
+    size_t attr_dup_cap;
     /* Bulk text-node block (round 8): leptris_text_create_borrowed
      * is an out-of-line call per text node — pool_alloc alone costs
      * more than the field stores. Same carve pattern as the elem and
@@ -454,20 +461,56 @@ static inline int dp_add_attr_inline(DParser* p, LeptrisElement elem,
      * (libxml2 recover semantics, and the digest's first-wins
      * becomes official); the duplicate never enters the chain, it
      * costs its already-carved slot. */
-    if (elem->first_attribute_off != 0) {
+    {
+        uint32_t dh = 2166136261u;
+        for (size_t i = 0; i < name_len; i++) {
+            dh ^= (unsigned char)name[i];
+            dh *= 16777619u;
+        }
         int dup = 0;
-        for (struct leptris_attribute* a =
-                 (struct leptris_attribute*)((char*)elem +
-                                             elem->first_attribute_off);
-             a; a = leptris_attr_next(a)) {
-            if (a->name_view.length == attr->name_view.length &&
-                a->name_view.data[0] == attr->name_view.data[0] &&
-                memcmp(a->name_view.data, attr->name_view.data,
-                       attr->name_view.length) == 0) {
-                dup = 1;
+        int cand = 0;
+        for (size_t i = 0; i < p->attr_dup_count; i++) {
+            if (p->attr_dup_hashes[i] == dh) {
+                cand = 1;
                 break;
             }
         }
+        if (cand && elem->first_attribute_off != 0) {
+            /* hash hit: confirm against the real chain (collision
+             * or genuine duplicate) */
+            for (struct leptris_attribute* a =
+                     (struct leptris_attribute*)(
+                         (char*)elem + elem->first_attribute_off);
+                 a; a = leptris_attr_next(a)) {
+                if (a->name_view.length ==
+                        attr->name_view.length &&
+                    a->name_view.data[0] ==
+                        attr->name_view.data[0] &&
+                    memcmp(a->name_view.data, attr->name_view.data,
+                           attr->name_view.length) == 0) {
+                    dup = 1;
+                    break;
+                }
+            }
+        }
+        if (!dup) {
+            if (p->attr_dup_count == p->attr_dup_cap) {
+                size_t nc = p->attr_dup_cap ? p->attr_dup_cap * 2
+                                            : 16;
+                uint32_t* nh = (uint32_t*)leptris_pool_alloc(
+                    p->pool, nc * sizeof(uint32_t));
+                if (nh) {
+                    if (p->attr_dup_count)
+                        memcpy(nh, p->attr_dup_hashes,
+                               p->attr_dup_count *
+                                   sizeof(uint32_t));
+                    p->attr_dup_hashes = nh;
+                    p->attr_dup_cap = nc;
+                }
+            }
+            if (p->attr_dup_count < p->attr_dup_cap)
+                p->attr_dup_hashes[p->attr_dup_count++] = dh;
+        }
         if (dup) {
             if (p->doc) {
                 extern struct LeptrisDiag* leptris_diag_emit(
@@ -489,6 +532,7 @@ static inline int dp_add_attr_inline(DParser* p, LeptrisElement elem,
              * the raw-attr registration so BOTH surfaces agree. */
             return 1;
         }
+        if (elem->first_attribute_off != 0) {
         /* Cache should always be valid mid-parse. Fall back to walk
          * only if cache is NULL (defensive — shouldn't happen). */
         struct leptris_attribute* tail = p->current_elem_last_attr;
@@ -506,6 +550,7 @@ static inline int dp_add_attr_inline(DParser* p, LeptrisElement elem,
          * offset is ever needed. */
         elem->first_attribute_off =
             (int32_t)((char*)attr - (char*)elem);
+        }
     }
     p->current_elem_last_attr = attr;
     p->cur_attr_count++;
@@ -723,6 +768,7 @@ static int dp_parse_attrs(DParser* p, LeptrisElement elem) {
     p->current_elem_last_ns = NULL;
     p->raw_last = NULL;
     p->cur_attr_count = 0;
+    p->attr_dup_count = 0;   /* hash array + cap persist across elements */
     /* Sentinel-terminated (parse endgame, third application): buf[len]
      * is NUL and NUL fails every classification below — not '>', not
      * '/', not '=' , not a quote, not IS_NAME_START. Each former
@@ -1333,6 +1379,9 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
     p.attr_capacity = attr_capacity;
     p.attr_cursor = attr_block;
     p.attr_end = attr_block + attr_capacity;
+    p.attr_dup_hashes = NULL;
+    p.attr_dup_count = 0;
+    p.attr_dup_cap = 0;
     p.text_cursor = text_block;
     p.text_end = text_block + lt_count;
     p.cpi_cursor = cpi_block;