leptris 1.9.249.0 → 1.9.255.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4945b25ab8d7db217c541ca9a1ae2db6e7cfa3aea67584b7a7520ec0fcbf6e5
-  data.tar.gz: b6a0355bceb4087bca19781de7ca02d1ad5fc35725685fba92e68591c0e5922a
+  metadata.gz: 5d1418101d40d96692273fa9327b6ad4c666a0705beeaa3c1500cdea623d3b83
+  data.tar.gz: f8605c3bd4a6f64e8a2361d4bdb375808665a57ec26f21deaf2d619a7695fa55
 SHA512:
-  metadata.gz: abc9546e36bf7f05cbb384fd84afd2ecbf9442d11f4ad7d9d5f705230096797b24bbf20e4f8542ecaf28746427db98cc1551159701cec6f18b437f751e6592a7
-  data.tar.gz: 13479600b858874e7f4f499eafb70cda0a97ec46f0248b0897e4878ca5a9e8ee84ca5a826cf5e4cccc7e2a27c95b554d6ce33e59a07270225f5a6c13ce5389a0
+  metadata.gz: 83c628648a66102c5a29da7f443761cf35c9b238328b22f9a46a4a43146e8a4b83a993aff7e53f1ca8b325abbe98c9f8c28a255ffb2a040ae050c91b01383a52
+  data.tar.gz: f831136e4a5fe977c2cd6ecc91ffd5e010f278fe0201f644d384ae6e1fa29aa4c887508a660c83fb5d87d38d8104f71e2656eab13876757a48c546e077065804

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.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.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;