leptris 1.9.241.0 → 1.9.248.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ad2fa0b842ba466a3264f4bf15b7aef98b02916e54c83faae4a88c3fc56f93a
-  data.tar.gz: 9f013ffbfc83ebc2bd6d848dc6a52518121eb0f51a1f74241c259a7c0e31829c
+  metadata.gz: 1445126f3a7bced66c8ccb08c13e6d61f0a8ffc95f154bb091aedd07e54ef706
+  data.tar.gz: c0c39cf6600337d568dfae5237f650a5b3aa1ebab16b42a648fff456c9d8f050
 SHA512:
-  metadata.gz: 0f0bebfda63c162db6237698ee5e8e4b7639985bf8f64c76f3b88eb436eb9e6ea701d139e976cb6c6b4930bb5e0ed3eba739ef260bd267c006cbc5e708d2b64c
-  data.tar.gz: 113065e13a279548868058dd223b4a62d75b025a88b659a897c83ca35f6142780999c283225cd6463349518c45197cb08c9510ee57b459f5269e9f82ec069cc1
+  metadata.gz: 35a1e9c1637cdfb8d2556d6ce9e10b5fce62b369f5824ae4b9a941026dee156bc54aa5d8dc9d30ba2fe25e8403d096c45449234ed29b422ce5d12febeca9d7ec
+  data.tar.gz: 36a555006ae5e9bb900eaa2f4955c337e4251dbfdd58be20ba91b4825b79de86a6fd8a8b161608c4f71c3d49422d68f3c97e6720e0baceac47e6de7cd0a8e26d

data/CHANGELOG.md

@@ -5,6 +5,22 @@ 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.248.0] - 2026-09-26
+
+### Fixed
+
+- Vendored libleptris 1.9.248 (riding 1.9.247 + 1.9.248):
+  - xpath: filtering a non-nodeset base treats the atom as a
+    one-item sequence — `(1)[1]` keeps the atom and `(1)[1] + 1`
+    is 2 (was an unconditional empty nodeset).
+  - html: the document arena span is sized from the input once
+    (#1218) — borrowed pointers stay in the int32 compact range,
+    removing ~776k overflow-table inserts on a 2.6 MB parse;
+    measured 31.4 -> 50.9 MB/s (+62%) on the table-rows corpus.
+- Restores the naming lockstep: the previous release vendored
+  engine 1.9.246 under the version 1.9.242.0; version.rb now
+  matches the vendored engine semver again.
+
 ## [1.9.241.0] - 2026-09-25
 
 ### 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.241"
+LIBLEPTRIS_VERSION = "1.9.248"
 # 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.241.0"
+  VERSION = "1.9.248.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.241
+- libleptris v1.9.248
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,66 @@
 ## [Unreleased]
 
+## [1.9.248] - 2026-09-26
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Changed
+
+- (describe changes here)
+
+
+## [1.9.247] - 2026-09-26
+
+### Fixed
+
+- filter on a non-nodeset base treats the atom as a one-item sequence (xpath)
+
+## [1.9.246] - 2026-09-25
+
+### Added
+
+- exact decimal lexical carrier (xquery)
+
+
+
+## [1.9.245] - 2026-09-25
+
+### Added
+
+- array:remove + NaN subsequence 2-arg adoption (xquery)
+- attribute ctor carriers + derived-string deep-equal class (xquery)
+
+
+
+## [1.9.244] - 2026-09-25
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Changed
+
+- (describe changes here)
+
+
+## [1.9.243] - 2026-09-25
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Changed
+
+- (describe changes here)
+
+
+## [1.9.242] - 2026-09-25
+
+### Added
+
+- QT3 maps/arrays slice — empty-aggregate arity guard + canonical map order (xquery)
+
+
+
 ## [1.9.241] - 2026-09-25
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -2290,6 +2290,23 @@ int leptris_il_scan(char* s, size_t len, int drop_ws, IlCtx* c,
             j = (size_t)(vend - s) + 1;
             IlAttr a = { (uint32_t)a0, (uint32_t)al,
                          (uint32_t)v0, (uint32_t)vl, aws };
+            /* XML 1.0 §3.1: duplicate attributes are a fatal error —
+             * the classic lane reports "Attribute %s redefined" and
+             * the SAX callback path records an ERROR event, but the
+             * record table has no error channel. A dup-containing
+             * document is therefore outside the scannable subset:
+             * bail so callers fall back to the callback path (#281,
+             * leptris-ruby#331 adoption). Same-element prior attrs
+             * are the contiguous range [r.first_attr, nattr). */
+            if (acount > 0) {
+                for (uint32_t k = r.first_attr; k < (uint32_t)c->nattr;
+                     k++) {
+                    const IlAttr* p = &c->attrs[k];
+                    if (p->name_len == (uint32_t)al &&
+                        memcmp(s + p->name_off, s + a0, al) == 0)
+                        return 0;
+                }
+            }
             if (!il_push_attr(c, &a)) return 0;
             if (acount == 0) r.first_attr = (uint32_t)(c->nattr - 1);
             acount++;

data/vendor-src/libleptris/src/leptris/html/html_parse.c

@@ -5453,8 +5453,17 @@ static LeptrisDocument html_parse_shared(
         if (status) *status = LEPTRIS_ERROR_NULL_ARG;
         return NULL;
     }
+    /* #1218: size the arena span from the input up front — the
+     * HTML tree expands ~8x (nodes + attributes + the owned input
+     * copy), and an undersized span spills later allocations into
+     * extension blocks in a different malloc region, pushing every
+     * borrowed pointer out of the int32 compact range (measured
+     * 776k overflow-table inserts on the 2.6 MB table shape). */
+    extern struct leptris_document* leptris_document_create_with_arena_size(
+        size_t arena_size);
     struct leptris_document* doc =
-        (struct leptris_document*)leptris_document_create();
+        (struct leptris_document*)leptris_document_create_with_arena_size(
+            len * 10 + (1u << 18));
     if (!doc) {
         if (status) *status = LEPTRIS_ERROR_MEMORY;
         return NULL;

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

@@ -173,7 +173,17 @@ void leptris_parse_options_init(leptris_parse_options* opts) {
  * pool-allocated (TODO 154) zeroed struct, strict mode inherited
  * from the thread-local setting, standalone unset (-1).
  */
-LEPTRIS_API LeptrisDocument leptris_document_create(void) {
+/* #1218: parse entry points that know their input size reserve the
+ * arena span ONCE at content-derived scale — an undersized span
+ * overflows into tracked extension blocks, which malloc places in a
+ * different region (measured 105 TB away on macOS, ~5.5 GB from the
+ * span). Every borrowed pointer (text runs, element names, attribute
+ * strings) then exceeds the int32 compact range and pays an
+ * overflow-table insert per field plus a hash lookup per decode for
+ * the REST of the parse. Sized spans keep the whole parse in one
+ * contiguous region. */
+struct leptris_document* leptris_document_create_with_arena_size(
+    size_t arena_size) {
     extern LeptrisMemoryPool* leptris_pool_create_arena_backed(
         LeptrisArena*, int);
     extern void* leptris_pool_alloc(LeptrisMemoryPool* pool, size_t size);
@@ -185,7 +195,7 @@ LEPTRIS_API LeptrisDocument leptris_document_create(void) {
      * documents take the same arena-backed pool the parser uses
      * (overflow extends via tracked blocks; the pool's page
      * machinery no longer runs for documents). */
-    LeptrisArena* arena = leptris_arena_create(64 * 1024);
+    LeptrisArena* arena = leptris_arena_create(arena_size);
     if (!arena) return NULL;
     LeptrisMemoryPool* pool = leptris_pool_create_arena_backed(arena, 1);
     if (!pool) {
@@ -210,6 +220,10 @@ LEPTRIS_API LeptrisDocument leptris_document_create(void) {
     return doc;
 }
 
+LEPTRIS_API LeptrisDocument leptris_document_create(void) {
+    return leptris_document_create_with_arena_size(64 * 1024);
+}
+
 LEPTRIS_API LeptrisDocument leptris_document_create_html(void) {
     struct leptris_document* doc = leptris_document_create();
     if (doc) doc->html_mode = 1;

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

@@ -659,6 +659,12 @@ struct leptris_xpath_result {
      * round-trip E form instead of the libxml2-parity XPath
      * spelling. Cleared in result_new (free-list recycle). */
     int xq_spelling;
+    /* Canonical decimal lexical: set by the xs:decimal ctor — the
+     * double carrier cannot hold 30 significant digits, so
+     * eq-based functions (distinct-values, index-of, deep-equal)
+     * key on the canonical form instead (decimal-lex slice). OWNED
+     * — freed in result_free, cleared in result_new (recycle). */
+    char* decimal_lex;
 };
 
 /* Namespace mapping for XPath context (v0.8.0) */

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

@@ -744,6 +744,7 @@ struct leptris_xpath_result* xpath_result_new(XPathResultType type) {
     result->is_int = 0;   /* free-list recycling would leak it */
     result->atomic_type = NULL;
     result->xq_spelling = 0;
+    result->decimal_lex = NULL;   /* free-list recycling would leak it */
 
     /* Initialize union based on type. XPATH_RESULT_CACHED is the
      * free-list sentinel — a fresh result never carries it. */
@@ -773,6 +774,11 @@ void xpath_result_free(struct leptris_xpath_result* result) {
      * no-op, never a second payload release. */
     if (result->type == XPATH_RESULT_CACHED) return;
 
+    if (result->decimal_lex) {
+        LEPTRIS_FREE(result->decimal_lex);
+        result->decimal_lex = NULL;
+    }
+
     /* Release the payload through locals: after this block the
      * union slot is dead, and parking the free-list next-pointer
      * into it cannot alias the memory just released. */
@@ -979,8 +985,48 @@ struct leptris_xpath_result* evaluate_expr(XPathContext* ctx, XPathASTNode* ast)
             if (!base) return NULL;
             if (base->type != XPATH_RESULT_NODESET ||
                 !base->value.nodeset_value) {
+                /* Non-nodeset base: the atom is a one-item sequence
+                 * — (1)[1] keeps it, (1)[true()] keeps it, (1)[2]
+                 * empties (the old code returned empty
+                 * unconditionally). The predicate sees position 1
+                 * of 1; the context node stays the outer one. */
+                int keep = 1;
+                for (size_t p = 1; p < ast->child_count && keep; p++) {
+                    XPathASTNode* pred = ast->children[p];
+                    if (pred->type == XPATH_AST_NUMBER) {
+                        keep = pred->number_value == 1.0;
+                        continue;
+                    }
+                    LeptrisElement old_node = ctx->context_node;
+                    size_t old_pos = ctx->context_position;
+                    size_t old_size = ctx->context_size;
+                    void* old_pred = ctx->current_predicate_node;
+                    ctx->context_position = 1;
+                    ctx->context_size = 1;
+                    struct leptris_xpath_result* pr =
+                        evaluate_expr(ctx, pred);
+                    ctx->context_node = old_node;
+                    ctx->context_position = old_pos;
+                    ctx->context_size = old_size;
+                    ctx->current_predicate_node = old_pred;
+                    if (!pr) {
+                        keep = 0;
+                        continue;
+                    }
+                    if (pr->type == XPATH_RESULT_NUMBER)
+                        keep =
+                            (size_t)pr->value.number_value == 1;
+                    else
+                        keep = xpath_to_boolean(pr) ? 1 : 0;
+                    xpath_result_free(pr);
+                }
+                if (keep) return base;
                 xpath_result_free(base);
-                return xpath_result_new(XPATH_RESULT_NODESET);
+                struct leptris_xpath_result* empty =
+                    xpath_result_new(XPATH_RESULT_NODESET);
+                if (empty && empty->value.nodeset_value)
+                    empty->value.nodeset_value->is_sequence = 1;
+                return empty;
             }
             if (ast->child_count > 1) {
                 apply_predicates(ctx, base->value.nodeset_value,

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

@@ -418,7 +418,9 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
         op0 != XPATH_OP_ELEMENT_CTOR &&
         op0 != XPATH_OP_ATTRIBUTE_CTOR &&
         op0 != XPATH_OP_TEXT_CTOR &&
-        op0 != XPATH_OP_DOCUMENT_CTOR)
+        op0 != XPATH_OP_DOCUMENT_CTOR &&
+        op0 != XPATH_OP_ARRAY_CONSTRUCTOR &&
+        op0 != XPATH_OP_MAP_CONSTRUCTOR)
         return NULL;
 
     XPathOperatorType op = (XPathOperatorType)ast->number_value;
@@ -1597,6 +1599,38 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                 if (v) xpath_result_free(v);
             }
             if (!s) s = leptris_strdup("");
+            if (op == XPATH_OP_ATTRIBUTE_CTOR) {
+                /* Top-level attribute ctor keeps its name: one
+                 * synthetic member carrying "\x03A" name "\x01"
+                 * value — deep-equal compares name+value
+                 * (K2-SeqDeepEqualFunc-25/31/32), string consumers
+                 * strip to the value. \x01 cannot occur in XML
+                 * content. */
+                const char* an = ast->value ? ast->value : "";
+                size_t alen = strlen(an), vlen = strlen(s);
+                size_t clen = alen + vlen + 3;
+                char* carrier = (char*)malloc(clen + 1);
+                if (!carrier) { free(s); return NULL; }
+                carrier[0] = '\x03';
+                carrier[1] = 'A';
+                memcpy(carrier + 2, an, alen);
+                carrier[2 + alen] = '\x01';
+                memcpy(carrier + 3 + alen, s, vlen + 1);
+                free(s);
+                XPathNodeSet* ns = xpath_nodeset_new();
+                if (!ns) { free(carrier); return NULL; }
+                ns->owns_synthetic_text = 1;
+                ns->is_sequence = 1;
+                XPathTextNode* tn = synth_text(carrier, clen);
+                free(carrier);
+                if (!tn) { xpath_nodeset_free(ns); return NULL; }
+                xpath_nodeset_add(ns, tn);
+                struct leptris_xpath_result* out =
+                    xpath_result_new(XPATH_RESULT_NODESET);
+                if (!out) { xpath_nodeset_free(ns); return NULL; }
+                out->value.nodeset_value = ns;
+                return out;
+            }
             struct leptris_xpath_result* out =
                 xpath_result_new(XPATH_RESULT_STRING);
             if (!out) { free(s); return NULL; }
@@ -1903,6 +1937,81 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
             free(v);
         }
         buf[len] = '\0';
+        /* Canonical entry order: sort by key so deep-equal and the
+         * serialized carrier are key-order-insensitive (maps-4:
+         * {1:a, 2:b} = {2:b, 1:a}); map iteration order is
+         * implementation-defined in XQuery. */
+        {
+            size_t body_len = len - 4;   /* past "\x03MAP" */
+            char* body = buf + 4;
+            size_t count = 0;
+            for (size_t i = 0; i < body_len; i++)
+                if (body[i] == '\x02') count++;
+            if (count > 1) {
+                char** keys = (char**)malloc(count * sizeof(char*));
+                size_t* klens = (size_t*)malloc(count * sizeof(size_t));
+                char** vals = (char**)malloc(count * sizeof(char*));
+                size_t* vlens = (size_t*)malloc(count * sizeof(size_t));
+                if (keys && klens && vals && vlens) {
+                    size_t n = 0, p = 0;
+                    while (p < body_len) {
+                        if (body[p] != '\x02') { p++; continue; }
+                        p++;
+                        size_t ks = p;
+                        while (p < body_len && body[p] != '\x01') p++;
+                        keys[n] = body + ks;
+                        klens[n] = p - ks;
+                        p++;
+                        size_t vs = p;
+                        while (p < body_len && body[p] != '\x02') p++;
+                        vals[n] = body + vs;
+                        vlens[n] = p - vs;
+                        n++;
+                    }
+                    for (size_t a = 1; a < n; a++) {
+                        char* ek = keys[a]; size_t ekl = klens[a];
+                        char* ev = vals[a]; size_t evl = vlens[a];
+                        size_t b2 = a;
+                        while (b2 > 0) {
+                            int c = strncmp(keys[b2 - 1], ek,
+                                            klens[b2 - 1] < ekl
+                                                ? klens[b2 - 1] : ekl);
+                            if (c == 0)
+                                c = klens[b2 - 1] < ekl ? -1
+                                    : klens[b2 - 1] > ekl ? 1 : 0;
+                            if (c <= 0) break;
+                            keys[b2] = keys[b2 - 1];
+                            klens[b2] = klens[b2 - 1];
+                            vals[b2] = vals[b2 - 1];
+                            vlens[b2] = vlens[b2 - 1];
+                            b2--;
+                        }
+                        keys[b2] = ek; klens[b2] = ekl;
+                        vals[b2] = ev; vlens[b2] = evl;
+                    }
+                    /* Sort-order permutes segments in place: write
+                     * through a scratch (a forward write clobbers a
+                     * not-yet-copied source segment). */
+                    char* scratch = (char*)malloc(body_len + 1);
+                    if (scratch) {
+                        size_t w2 = 0;
+                        for (size_t e = 0; e < n; e++) {
+                            scratch[w2++] = '\x02';
+                            memcpy(scratch + w2, keys[e], klens[e]);
+                            w2 += klens[e];
+                            scratch[w2++] = '\x01';
+                            memcpy(scratch + w2, vals[e], vlens[e]);
+                            w2 += vlens[e];
+                        }
+                        memcpy(body, scratch, w2);
+                        len = 4 + w2;
+                        buf[len] = '\0';
+                        free(scratch);
+                    }
+                }
+                free(keys); free(klens); free(vals); free(vlens);
+            }
+        }
         XPathNodeSet* out = xpath_nodeset_new();
         if (!out) { free(buf); return NULL; }
         out->owns_synthetic_text = 1;
@@ -2319,12 +2428,17 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                 is->owns_synthetic_text = 0;
             } else {
                 char* piece =
-                    (ctx->xquery_spelling &&
-                     item->type == XPATH_RESULT_NUMBER &&
-                     !item->is_int)
-                        ? xpath_number_to_string_xq(
-                              item->value.number_value)
-                        : xpath_to_string(item);
+                    item->decimal_lex
+                        ? leptris_strdup(item->decimal_lex)
+                        : (ctx->xquery_spelling &&
+                           item->type == XPATH_RESULT_NUMBER &&
+                           !item->is_int)
+                              ? xpath_number_to_string_xq_typed(
+                                    item->value.number_value,
+                                    item->atomic_type &&
+                                        strcmp(item->atomic_type,
+                                               "xs:float") == 0)
+                              : xpath_to_string(item);
                 if (item->type == XPATH_RESULT_NUMBER) {
                     /* "\x03N" marks numeric members for per-member
                      * type checks (instance of); get_node_text

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

@@ -276,11 +276,18 @@ char* get_node_text(void* node) {
              * per-member type checks (instance of). \x03 is invalid
              * in XML 1.0 text, so it can never collide with real
              * content — strip it for every string consumer. */
-            if (c[0] == '\x03' &&
-                (c[1] == 'N' || c[1] == 'B' || c[1] == 'D' ||
-                 (c[1] == 'F' &&
-                  !((c[2] == 'N' && c[3] == '\x02') || c[2] == 'R'))))
-                c += 2;
+            if (c[0] == '\x03') {
+                if (c[1] == 'A') {
+                    /* attribute ctor carrier: string value is the
+                     * part after the "\x01" separator */
+                    const char* sep = strchr(c, '\x01');
+                    return leptris_strdup(sep ? sep + 1 : "");
+                }
+                if (c[1] == 'N' || c[1] == 'B' || c[1] == 'D' ||
+                    (c[1] == 'F' &&
+                     !((c[2] == 'N' && c[3] == '\x02') || c[2] == 'R')))
+                    c += 2;
+            }
             return leptris_strdup(c);
         }
 
@@ -299,8 +306,30 @@ int xpath_to_boolean(struct leptris_xpath_result* result) {
             return result->value.number_value != 0.0 && !isnan(result->value.number_value);
         case XPATH_RESULT_STRING:
             return result->value.string_value && result->value.string_value[0] != '\0';
-        case XPATH_RESULT_NODESET:
-            return xpath_nodeset_count(result->value.nodeset_value) > 0;
+        case XPATH_RESULT_NODESET: {
+            XPathNodeSet* ns = result->value.nodeset_value;
+            size_t cnt = ns ? xpath_nodeset_count(ns) : 0;
+            /* XQuery sequence EBV: a singleton atomic carries the
+             * item's EBV (fn:remove round-trips a false boolean as
+             * falsy), while XPath node-existence EBV applies to
+             * real nodes and multi-item sequences. */
+            if (!ns || !ns->is_sequence) return cnt > 0;
+            if (cnt != 1) return cnt > 0;
+            void* nd = ns->nodes[0];
+            if (!nd || XPATH_NODE_TYPE(nd) != LEPTRIS_NODE_TEXT)
+                return 1;
+            const char* c = ((XPathTextNode*)nd)->content;
+            if (!c) return 1;
+            if (c[0] == '\x03') {
+                if (c[1] == 'B') return c[2] == 't';
+                if (c[1] == 'N' || c[1] == 'F' || c[1] == 'D') {
+                    double d = strtod(c + 2, NULL);
+                    return d != 0.0 && !isnan(d);
+                }
+                return 1;
+            }
+            return c[0] != '\0';
+        }
         default:
             return 0;
     }