leptris 1.9.241.0 → 1.9.242.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ad2fa0b842ba466a3264f4bf15b7aef98b02916e54c83faae4a88c3fc56f93a
-  data.tar.gz: 9f013ffbfc83ebc2bd6d848dc6a52518121eb0f51a1f74241c259a7c0e31829c
+  metadata.gz: 4de40885119a37c57132fe2a16bb048198afa93b8e4077f8c3b4d428e176c753
+  data.tar.gz: 55353281eb7cd09b749905b35172a40d1be65821758ddffcac687fe77df44e52
 SHA512:
-  metadata.gz: 0f0bebfda63c162db6237698ee5e8e4b7639985bf8f64c76f3b88eb436eb9e6ea701d139e976cb6c6b4930bb5e0ed3eba739ef260bd267c006cbc5e708d2b64c
-  data.tar.gz: 113065e13a279548868058dd223b4a62d75b025a88b659a897c83ca35f6142780999c283225cd6463349518c45197cb08c9510ee57b459f5269e9f82ec069cc1
+  metadata.gz: 62f07379ee5b97c1695845e7afd61eb0b1135171eb558feb7f8def8789d86488348c9f14616a67124cfbed8f4608c7f1d0af90793e37d54da755669687777f2e
+  data.tar.gz: e086c44b5d76e6e557c19c37cde928c7337e633f20dde340bf46e9ee3c95dd5c2285ea8c51ee5ca9a04a81b04e2f7b2cc605779268bb1c586240c4e58d6524cb

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.246"
 # 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.242.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.246
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,50 @@
 ## [Unreleased]
 
+## [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.246
     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/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. */

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

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

@@ -764,6 +764,71 @@ static int de_node_equal(LeptrisNodeRef a, LeptrisNodeRef b) {
     return ca == NULL && cb == NULL;
 }
 
+/* Direct-ctor strings compare as trees when the lexical forms
+ * differ: attribute order is insignificant to deep-equality
+ * (fn-deep-equal-maps-11), and the tree path also inherits the
+ * comment/PI-insignificance rule. Unparseable markup compares
+ * lexically (both sides then fail identically -> false). */
+static int de_markup_equal_n(const char* a, size_t al,
+                             const char* b, size_t bl) {
+    char* xa = (char*)malloc(al + 1);
+    char* xb = (char*)malloc(bl + 1);
+    int eq = 0;
+    if (xa && xb) {
+        memcpy(xa, a, al); xa[al] = 0;
+        memcpy(xb, b, bl); xb[bl] = 0;
+        LeptrisStatus sa = LEPTRIS_OK, sb = LEPTRIS_OK;
+        LeptrisDocument da = leptris_parse_string(xa, al, &sa);
+        LeptrisDocument db = leptris_parse_string(xb, bl, &sb);
+        if (da && db) {
+            LeptrisElement ra = leptris_document_root(da);
+            LeptrisElement rb = leptris_document_root(db);
+            eq = ra && rb &&
+                 de_node_equal((LeptrisNodeRef)ra, (LeptrisNodeRef)rb);
+        }
+        if (da) leptris_document_free(da);
+        if (db) leptris_document_free(db);
+    }
+    free(xa);
+    free(xb);
+    return eq;
+}
+
+/* Map carriers ("\x03MAP" + ("\x02" key "\x01" value)*; entries are
+ * canonically key-sorted at construction) compare entry-wise:
+ * keys lexically, values with the markup fallback. Segment bytes
+ * (\x02/\x01) cannot occur in XML content, so end-scan is safe. */
+static int de_map_equal(const char* a, const char* b) {
+    a += 4;
+    b += 4;
+    while (*a && *b) {
+        if (*a != '\x02' || *b != '\x02') return 0;
+        a++;
+        b++;
+        const char* ka = a;
+        while (*a && *a != '\x01') a++;
+        const char* kb = b;
+        while (*b && *b != '\x01') b++;
+        if (*a != '\x01' || *b != '\x01') return 0;
+        if (a - ka != b - kb || memcmp(ka, kb, (size_t)(a - ka)) != 0)
+            return 0;
+        a++;
+        b++;
+        const char* va = a;
+        while (*a && *a != '\x02') a++;
+        const char* vb = b;
+        while (*b && *b != '\x02') b++;
+        if (a - va != b - vb ||
+            memcmp(va, vb, (size_t)(a - va)) != 0) {
+            if (va[0] != '<' || vb[0] != '<') return 0;
+            if (!de_markup_equal_n(va, (size_t)(a - va),
+                                   vb, (size_t)(b - vb)))
+                return 0;
+        }
+    }
+    return *a == 0 && *b == 0;
+}
+
 /* One comparable item: kind 0 = node, 1 = number, 2 = string,
  * 3 = boolean. Synthetic sequence members carry the "\x03N" numeric
  * marker (stripped here); other synthetic text is a string. */
@@ -789,11 +854,18 @@ static int de_num_rank(const char* t) {
 }
 
 /* The untyped/string equivalence class: plain ctor/lexical strings,
- * xs:string, xs:anyURI, xs:untypedAtomic all compare by codepoint. */
+ * xs:string, xs:anyURI, xs:untypedAtomic — and the types DERIVED
+ * from xs:string, which all compare by codepoint
+ * (K2-SeqDeepEqualFunc-35: "a" = xs:NCName("a")). */
 static int de_str_class(const char* t) {
-    return !t || strcmp(t, "xs:string") == 0 ||
-           strcmp(t, "xs:anyURI") == 0 ||
-           strcmp(t, "xs:untypedAtomic") == 0;
+    if (!t) return 1;
+    static const char* const k_derived[] = {
+        "xs:string", "xs:anyURI", "xs:untypedAtomic", "xs:NCName",
+        "xs:Name", "xs:token", "xs:normalizedString", "xs:language",
+        "xs:NMTOKEN", "xs:ID", "xs:IDREF", "xs:ENTITY"};
+    for (size_t i = 0; i < sizeof(k_derived) / sizeof(*k_derived); i++)
+        if (strcmp(t, k_derived[i]) == 0) return 1;
+    return 0;
 }
 
 static void de_item_clear(DeItem* it) {
@@ -825,13 +897,36 @@ static int de_item_equal(DeItem* a, DeItem* b) {
         case 2: {
             const char* as = a->str ? a->str : (a->borrow ? a->borrow : "");
             const char* bs = b->str ? b->str : (b->borrow ? b->borrow : "");
-            if (de_str_class(a->type) && de_str_class(b->type))
-                return strcmp(as, bs) == 0;
+            if (de_str_class(a->type) && de_str_class(b->type)) {
+                if (strncmp(as, "\x03MAP", 4) == 0 &&
+                    strncmp(bs, "\x03MAP", 4) == 0)
+                    return de_map_equal(as, bs);
+                if (strcmp(as, bs) == 0) return 1;
+                return as[0] == '<' && bs[0] == '<' &&
+                       de_markup_equal_n(as, strlen(as), bs, strlen(bs));
+            }
             if (!de_str_class(a->type) && !de_str_class(b->type) &&
                 strcmp(a->type, b->type) == 0)
                 return strcmp(as, bs) == 0;
             return 0;   /* typed (xs:date...) vs anything else */
         }
+        case 4: {
+            /* Attribute ctor carriers: name segment (after "\x03A",
+             * before "\x01") and value segment must both match. */
+            const char* as = a->str ? a->str : (a->borrow ? a->borrow : "");
+            const char* bs = b->str ? b->str : (b->borrow ? b->borrow : "");
+            const char* ase = strchr(as, '\x01');
+            const char* bse = strchr(bs, '\x01');
+            if (!ase || !bse) return 0;
+            if ((size_t)(ase - as) != (size_t)(bse - bs) ||
+                memcmp(as, bs, (size_t)(ase - as)) != 0)
+                return 0;
+            ase++;
+            bse++;
+            if (strcmp(ase, bse) == 0) return 1;
+            return ase[0] == '<' && bse[0] == '<' &&
+                   de_markup_equal_n(ase, strlen(ase), bse, strlen(bse));
+        }
         default: return a->num == b->num;   /* booleans as 0/1 */
     }
 }
@@ -857,6 +952,11 @@ static size_t de_collect(struct leptris_xpath_result* r, DeItem* out,
                 if (c[0] == '\x03' && c[1] == 'B') {
                     out[i].kind = 3;
                     out[i].num = c[2] == 't' ? 1 : 0;
+                } else if (c[0] == '\x03' && c[1] == 'A') {
+                    /* attribute ctor carrier: kind 4 compares
+                     * name + value (K2-SeqDeepEqualFunc-25/31/32) */
+                    out[i].kind = 4;
+                    out[i].borrow = c;
                 } else if (c[0] == '\x03' &&
                     (c[1] == 'N' || c[1] == 'D' ||
                      (c[1] == 'F' &&