leptris 1.9.237.1 → 1.9.239.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4a6496fa19cc082a96e6edf44f894b398bc66fe4c8052f0588f4727696fdf59
-  data.tar.gz: a4e5d44004b67e65bd14accd3546c5bbba3e31afe4c83f6b936b572c5f13bb41
+  metadata.gz: a9988358313da5babf4756d5a3393ff7a805eaabb0a6c04a240bf75173f8248b
+  data.tar.gz: 80ddb8c442105e7afad9a1cc40e010f670e115f61e295978157182889a6f2c6e
 SHA512:
-  metadata.gz: b38d741b87da2cf151dfc6eacaa349aa8cb5db6705a868d7b0e37ca0f0c32e0960db5529ac12e473eec214f418131cf978513988ad85e8a2a8ddf0fe1da82521
-  data.tar.gz: 6bff172e3608680967013be47594142fd1ca6ad82c12a7e546b8dbaf1e8898aa294dca06b8a90cf65cdef7714559371b160dc901eddc076fe21bf6d45d5efba4
+  metadata.gz: 194a8513e590353c118ff58cac0700789337ce254d8b138e5818a228134f75a5d40f2e4a54cbd8045900182bdb25ea8ca706efe5731e6ae0b3b086d16842f59a
+  data.tar.gz: 887dbf39367b2cf2397a493c59d2bb569212acefd4a11f8c1bcd5cbc167640d254e03f4099a71b11c3a9c5f19dcf7c1c75bc4831b6aee1b2533c3cf1f9c3a790

data/CHANGELOG.md

@@ -5,6 +5,18 @@ 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.239.0] - 2026-09-25
+
+### Fixed
+
+- Vendored libleptris 1.9.239: XML 1.0 §2.11 end-of-line
+  normalization (#326) — parsed character data normalizes literal
+  CRLF and lone CR to LF before reference expansion (a CR character
+  reference stays CR), and attribute values collapse CRLF to ONE
+  space per §3.3.3. Nokogiri/libxml2 parity restored for any text
+  that ever carried \r\n. CDATA is not normalized. The
+  interleaved-lane hardening lands in the next engine sync.
+
 ## [1.9.237.0] - 2026-09-24
 
 ### Added

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.237"
+LIBLEPTRIS_VERSION = "1.9.239"
 # 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.237.1"
+  VERSION = "1.9.239.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.237
+- libleptris v1.9.239
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,38 @@
 ## [Unreleased]
 
+## [1.9.239] - 2026-09-24
+
+### Added
+
+- xquery: shortest round-trip E notation for the XQuery number
+  spelling. Scientific values print the fewest mantissa digits that
+  read back as the same value — at float precision for xs:float
+  members (`3.4028235E38`, `2E6`, `4.9E-324`,
+  `1.7976931348623157E308`) — in canonical shape: E separator,
+  exponent sign only for negatives, no trailing zeros. The spelling
+  rides NUMBER results that escape an XQuery evaluation; the XPath
+  1.0 surface keeps libxml2 xmlXPathFormatNumber parity.
+
+### Fixed
+
+- QT3 corpus: fn:reverse 57→59, fn:distinct-values 87→89 adopted
+  (the dbl1args/flt1args E-notation pins).
+
+
+
+## [1.9.238] - 2026-09-24
+
+### Added
+
+- xquery: computed `processing-instruction NAME { content }` and
+  `comment { content }` constructors. In the string-level
+  constructor model they serialize to their XML markup
+  (`<?NAME data?>` — empty content drops the data and the separating
+  space — and `<!--content-->`). The comment guard keys on the
+  brace, so the `comment()` node test stays intact.
+
+
+
 ## [1.9.237] - 2026-09-24
 
 <!-- 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.237
+    VERSION 1.9.239
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

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

@@ -346,6 +346,8 @@ static inline int dp_add_attr_inline(DParser* p, LeptrisElement elem,
                                       char* val, size_t val_len,
                                       int has_amp, int has_ws,
                                       const char* name_colon) {
+    /* Live value length — the §2.11 collapse (#326) shrinks it. */
+    size_t vlen = val_len;
     /* Attribute-value normalization (XML 1.0 §3.3.3, issue #576):
      * each literal tab/LF/CR in a CDATA attribute becomes a single
      * space. Character references (	) are ASCII text here —
@@ -355,13 +357,21 @@ static inline int dp_add_attr_inline(DParser* p, LeptrisElement elem,
     if (has_ws) {
         char* norm = (char*)leptris_pool_alloc(p->pool, val_len + 1);
         if (!norm) return -1;
+        /* §2.11 (#326): CRLF is ONE line break — it collapses to a
+         * single space (libxml2/pugixml parity) before the §3.3.3
+         * break-to-space mapping; lone CR likewise. */
+        size_t wl = 0;
         for (size_t i = 0; i < val_len; i++) {
             char ch = val[i];
-            norm[i] = (ch == '\t' || ch == '\n' || ch == '\r')
-                          ? ' ' : ch;
+            if (ch == '\r' && i + 1 < val_len && val[i + 1] == '\n') {
+                i++;
+            }
+            norm[wl++] = (ch == '\t' || ch == '\n' || ch == '\r')
+                             ? ' ' : ch;
         }
-        norm[val_len] = '\0';
+        norm[wl] = '\0';
         val = norm;
+        vlen = wl;
     }
     struct leptris_attribute* attr = p->attr_cursor;
     if (DP_UNLIKELY(attr >= p->attr_end)) {
@@ -373,7 +383,7 @@ static inline int dp_add_attr_inline(DParser* p, LeptrisElement elem,
     }
 
     attr->name_view = leptris_sv_from_ptr(name, name_len);
-    leptris_attr_value_set_heap(attr, leptris_sv_from_ptr(val, val_len));
+    leptris_attr_value_set_heap(attr, leptris_sv_from_ptr(val, vlen));
     /* #1125: the name NUL (at name_end) and the value NUL (at the
      * closing quote) get restored after parse — both views must
      * materialize. The normalized/entity-expanded replacements below
@@ -387,9 +397,9 @@ static inline int dp_add_attr_inline(DParser* p, LeptrisElement elem,
      *   predefined entities lazily on first read.
      * - No '&': nothing to do. */
     unsigned ent = 0;
-    if (val_len > 0 && has_amp) {
+    if (vlen > 0 && has_amp) {
         if (p->dtd) {
-            LeptrisStringView dsv = leptris_sv_from_ptr(val, val_len);
+            LeptrisStringView dsv = leptris_sv_from_ptr(val, vlen);
             char* expanded = leptris_decode_entities_view_with_dtd(
                 &dsv, p->dtd, p->pool);
             if (expanded) {
@@ -1018,6 +1028,46 @@ static inline LeptrisTextNode* dp_text_create(DParser* p,
     return tn;
 }
 
+/* §2.11 End-of-Line Handling (#326): collapse literal CR — CRLF →
+ * LF, lone CR → LF — into a pool-owned NUL-terminated copy. Literal
+ * bytes only: character references (&#xD;) are ASCII text at this
+ * layer and must survive as CR (char refs sit outside §2.11
+ * normalization). out_len receives the collapsed length. NULL on
+ * allocation failure. */
+static char* dp_eol_collapse(LeptrisMemoryPool* pool, const char* s,
+                             size_t len, size_t* out_len) {
+    char* conv = (char*)leptris_pool_alloc(pool, len + 1);
+    if (!conv) return NULL;
+    size_t wl = 0;
+    for (size_t i = 0; i < len; i++) {
+        char ch = s[i];
+        if (ch == '\r') {
+            conv[wl++] = '\n';
+            if (i + 1 < len && s[i + 1] == '\n') i++;
+        } else {
+            conv[wl++] = ch;
+        }
+    }
+    conv[wl] = '\0';
+    *out_len = wl;
+    return conv;
+}
+
+/* §2.11 (#326) text mint for the keep-entity-refs segment paths:
+ * zero-copy when the segment is CR-free, else a pool-owned
+ * collapsed copy (leptris_text_create — ownership differs from the
+ * borrowed carve; callers only stamp line/frozen + wire, both
+ * ownership-agnostic). */
+static inline LeptrisTextNode* dp_text_create_norm(DParser* p,
+                                                   const char* s,
+                                                   size_t len) {
+    if (memchr(s, '\r', len) == NULL) return dp_text_create(p, s, len);
+    size_t wl;
+    char* conv = dp_eol_collapse(p->pool, s, len, &wl);
+    if (!conv) return NULL;
+    return leptris_text_create(conv, wl, p->pool, p->doc);
+}
+
 /* Internal: parse from a writable, NUL-terminated buffer.
  * owns_buffer: 1 = document frees buf on leptris_document_free,
  *              0 = caller owns buf (in-place mode). */
@@ -1329,7 +1379,7 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                  (p.root_chained &&
                   p.dc_tail == (LeptrisNode*)p.root))) {
                 LeptrisTextNode* wtn =
-                    dp_text_create(&p, ws_start, wl);
+                    dp_text_create_norm(&p, ws_start, wl);
                 if (!wtn) goto fail;
                 wtn->base.frozen = 1;
                 dp_doc_child(&p, (LeptrisNode*)wtn);
@@ -1374,6 +1424,10 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
              * entity-free docs. The memchr fallback covers the
              * >48-byte tail region only. */
             int has_amp = 0;
+            /* §2.11 (#326): literal-CR tracking rides the same fused
+             * loop — CR-bearing runs take the pool-copy collapse,
+             * CR-free runs (the norm) keep the zero-copy carve. */
+            int has_cr = 0;
             {
                 const char* q = p.pos;
                 const char* probe_end = p.probe_slack
@@ -1383,12 +1437,14 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                     char ch = *q;
                     if (ch == '<') { lt = (char*)q; goto text_done; }
                     has_amp |= (ch == '&');
+                    has_cr |= (ch == '\r');
                     q++;
                 }
                 if (q >= p.end) goto text_done;
                 lt = (char*)memchr(q, '<', p.end - q);
                 if (!lt) lt = p.end;
                 has_amp |= memchr(q, '&', (size_t)((char*)lt - q)) != NULL;
+                has_cr |= memchr(q, '\r', (size_t)((char*)lt - q)) != NULL;
             }
         text_done:
             p.pos = lt ? lt : p.end;
@@ -1447,7 +1503,7 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                             }
                         }
                         if (!rt) {
-                            rt = dp_text_create(&p, seg, slen);
+                            rt = dp_text_create_norm(&p, seg, slen);
                             if (!rt) goto fail;
                             /* #1285 slice 4: terminate the segment.
                              * The '&' is dead: the walker has passed
@@ -1486,7 +1542,7 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                         }
                     }
                     if (!rt) {
-                        rt = dp_text_create(&p, seg, slen);
+                        rt = dp_text_create_norm(&p, seg, slen);
                         if (!rt) goto fail;
                     }
                     rt->base.line = text_off;
@@ -1505,17 +1561,34 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
              * raw terminated run. Entity-free runs pay one memchr
              * and stay zero-copy. */
             LeptrisTextNode* tn;
+            /* §2.11 (#326): collapse literal CR BEFORE entity decode
+             * — &#xD; expands after normalization and survives as
+             * CR, exactly as the spec orders it. Collapsed runs are
+             * pool-owned copies; CR-free runs keep every existing
+             * path (entity-free stays zero-copy, entity-decode
+             * fallback stays borrowed). */
+            char* collapsed = NULL;
+            size_t clen = tlen;
+            if (has_cr) {
+                collapsed = dp_eol_collapse(pool, text_start, tlen, &clen);
+                if (!collapsed) goto fail;
+            }
             if (has_amp) {
-                LeptrisStringView sv = leptris_sv_from_ptr(text_start, tlen);
+                LeptrisStringView sv = leptris_sv_from_ptr(
+                    collapsed ? collapsed : text_start, clen);
                 char* expanded = p.dtd
                     ? leptris_decode_entities_view_with_dtd(
                           &sv, p.dtd, pool)
                     : leptris_decode_entities_view(&sv, pool);
                 if (expanded) {
                     tn = leptris_text_create(expanded, strlen(expanded), pool, p.doc);
+                } else if (collapsed) {
+                    tn = leptris_text_create(collapsed, clen, pool, p.doc);
                 } else {
                     tn = dp_text_create(&p, text_start, tlen);
                 }
+            } else if (collapsed) {
+                tn = leptris_text_create(collapsed, clen, pool, p.doc);
             } else {
                 tn = dp_text_create(&p, text_start, tlen);
             }
@@ -1773,7 +1846,18 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                 LeptrisCDATANode* cd = (LeptrisCDATANode*)
                     dp_cpi_carve(&p, LEPTRIS_NODE_TYPE_CDATA);
                 if (cd) {
-                    cd->content = start;  /* zero-copy, buf-lifetime */
+                    /* §2.11 (#326): CDATA content is Char data —
+                     * literal CR collapses to LF; CR-free content
+                     * keeps the zero-copy view. */
+                    if (memchr(start, '\r', (size_t)(p.pos - start))) {
+                        size_t wl;
+                        char* conv = dp_eol_collapse(
+                            pool, start, (size_t)(p.pos - start), &wl);
+                        if (!conv) goto fail;
+                        cd->content = conv;
+                    } else {
+                        cd->content = start;  /* zero-copy, buf-lifetime */
+                    }
                 } else {
                     cd = leptris_cdata_create(start, p.pos - start, pool);
                     if (!cd) goto fail;

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

@@ -654,6 +654,11 @@ struct leptris_xpath_result {
      * NULL for the untyped/string class. NOT owned — static
      * literals only. Cleared in result_new (free-list recycle). */
     const char* atomic_type;
+    /* XQuery number spelling: set on NUMBER results that escape an
+     * XQuery evaluation, so result_string renders the shortest
+     * round-trip E form instead of the libxml2-parity XPath
+     * spelling. Cleared in result_new (free-list recycle). */
+    int xq_spelling;
 };
 
 /* Namespace mapping for XPath context (v0.8.0) */
@@ -825,6 +830,11 @@ typedef enum {
      * joined by '\x01' ("*" catches all), children[0] = try body,
      * children[1..] = catch bodies in order. */
     XPATH_OP_DOCUMENT_CTOR,
+    /* processing-instruction NAME { content } and
+     * comment { content } — the string-level ctor model serializes
+     * to the XML markup form (QT3 cbcl-deep-equal-002..004). */
+    XPATH_OP_PI_CTOR,
+    XPATH_OP_COMMENT_CTOR,
     XPATH_OP_TRY,
     /* XQuery 3.0 typeswitch: value = case SequenceTypes joined
      * by '\x01' (a trailing empty entry = the default arm),

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

@@ -743,6 +743,7 @@ struct leptris_xpath_result* xpath_result_new(XPathResultType type) {
     result->type = type;
     result->is_int = 0;   /* free-list recycling would leak it */
     result->atomic_type = NULL;
+    result->xq_spelling = 0;
 
     /* Initialize union based on type. XPATH_RESULT_CACHED is the
      * free-list sentinel — a fresh result never carries it. */

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

@@ -21,6 +21,7 @@ char* xpath_to_string(struct leptris_xpath_result* result);
 char* get_node_text(void* node);
 char* xpath_number_to_string(double number);
 char* xpath_number_to_string_xq(double number);
+char* xpath_number_to_string_xq_typed(double number, int float_prec);
 char* xpath_int_to_string(long long v);
 
 /* From evaluator_operators.c — synthetic sequence members and the

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

@@ -1521,6 +1521,45 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
      * escape &<"', text content escapes &<; raw expression content
      * passes through (a nested constructor's result is already
      * markup; arbitrary-string escaping is a value-model limit). */
+    /* Computed PI/comment constructors (string-level ctor model):
+     * serialize to the XML markup form. PI data is raw (no
+     * entity-escaping in the data position); empty content drops
+     * the data and the separating space. */
+    if (op == XPATH_OP_PI_CTOR || op == XPATH_OP_COMMENT_CTOR) {
+        char* s = NULL;
+        if (ast->child_count >= 1) {
+            struct leptris_xpath_result* v =
+                evaluate_expr(ctx, ast->children[0]);
+            if (v) s = xpath_to_string(v);
+            xpath_result_free(v);
+        }
+        if (!s) s = leptris_strdup("");
+        struct leptris_xpath_result* out =
+            xpath_result_new(XPATH_RESULT_STRING);
+        if (!out) {
+            free(s);
+            return NULL;
+        }
+        const char* target =
+            op == XPATH_OP_PI_CTOR && ast->value ? ast->value : "";
+        size_t tl = strlen(target);
+        size_t dl = strlen(s);
+        char* buf = (char*)malloc(tl + dl + 8);
+        if (!buf) {
+            free(s);
+            xpath_result_free(out);
+            return NULL;
+        }
+        if (op == XPATH_OP_PI_CTOR)
+            snprintf(buf, tl + dl + 8, "<?%s%s%s?>", target,
+                     dl ? " " : "", s);
+        else
+            snprintf(buf, dl + 8, "<!--%s-->", s);
+        out->value.string_value = buf;
+        free(s);
+        return out;
+    }
+
     if (op == XPATH_OP_TEXT_CTOR || op == XPATH_OP_ATTRIBUTE_CTOR ||
         op == XPATH_OP_ELEMENT_CTOR) {
         if (op != XPATH_OP_ELEMENT_CTOR) {

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

@@ -88,6 +88,13 @@ char* xpath_number_to_string(double number) {
  * XsltNumberFormat.MatchesLibxml2 and the libxslt suite), so this
  * spelling is only used where the context sets xquery_spelling. */
 char* xpath_number_to_string_xq(double number) {
+    return xpath_number_to_string_xq_typed(number, 0);
+}
+
+/* float_prec: the value is a float32-widened double — the shortest
+ * round-trip loop reads back at float precision so xs:float spells
+ * "3.4028235E38", not the widened-double digits. */
+char* xpath_number_to_string_xq_typed(double number, int float_prec) {
     if (isnan(number)) return leptris_strdup("NaN");
     if (isinf(number))
         return leptris_strdup(number > 0 ? "INF" : "-INF");
@@ -103,8 +110,31 @@ char* xpath_number_to_string_xq(double number) {
     int size;
     double absolute_value = fabs(number);
     if (absolute_value > 1e18 || absolute_value < 1e-18) {
-        size = (int)snprintf(work, sizeof(work), "%21.14e", number);
-        while (size > 0 && work[size] != 'e') size--;
+        /* Shortest round-trip scientific spelling (Saxon/QT3): the
+         * fewest mantissa digits that read back as the same double,
+         * in canonical form — E separator, exponent sign only for
+         * negatives, no trailing zeros ("1.7976931348623157E308",
+         * "2E6", "4.9E-324"). Returns directly: the shared trim
+         * below must not eat exponent digits. */
+        char mant[64];
+        int prec;
+        for (prec = 1; prec <= 17; prec++) {
+            snprintf(mant, sizeof(mant), "%.*e", prec, number);
+            double back = strtod(mant, NULL);
+            if (float_prec) back = (double)((float)back);
+            if (back == number) break;
+        }
+        char* e = strchr(mant, 'e');
+        if (!e) return leptris_strdup(mant);
+        *e = 0;
+        char* last = mant + strlen(mant);
+        while (last > mant && *(last - 1) == '0') last--;
+        if (last > mant && *(last - 1) == '.') last--;
+        *last = 0;
+        const char* exp = e + 1;
+        if (*exp == '+') exp++;
+        snprintf(work, sizeof(work), "%sE%s", mant, exp);
+        return leptris_strdup(work);
     } else {
         /* Fraction budget: integer digits first, the fraction spends
          * the remaining significant digits (33 places floor for the

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

@@ -160,7 +160,15 @@ static char** collect_items_raw(XPathContext* ctx, XPathASTNode** args,
             }
         }
     } else if (r->type == XPATH_RESULT_NUMBER) {
-        char* s = scalar_str(r);
+        /* XQuery-spelled doubles (shortest round-trip E form) when
+         * the eval is XQuery-flavored — same rule as the sequence
+         * operator's scalar spread. */
+        char* s = (ctx->xquery_spelling && !r->is_int)
+                      ? xpath_number_to_string_xq_typed(
+                            r->value.number_value,
+                            r->atomic_type &&
+                                strcmp(r->atomic_type, "xs:float") == 0)
+                      : scalar_str(r);
         size_t sl = s ? strlen(s) : 0;
         items = (char**)malloc(sizeof(char*));
         if (!items) { free(s); xpath_result_free(r); return NULL; }
@@ -441,7 +449,12 @@ static struct leptris_xpath_result* fn_index_of(XPathContext* ctx,
             needle = leptris_strdup("");
         }
     } else if (v && v->type == XPATH_RESULT_NUMBER) {
-        char* s = scalar_str(v);
+        char* s = (ctx->xquery_spelling && !v->is_int)
+                      ? xpath_number_to_string_xq_typed(
+                            v->value.number_value,
+                            v->atomic_type &&
+                                strcmp(v->atomic_type, "xs:float") == 0)
+                      : scalar_str(v);
         size_t sl = s ? strlen(s) : 0;
         needle = (char*)malloc(sl + 3);
         if (needle) {

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

@@ -1453,6 +1453,76 @@ static XPathASTNode* parse_path_expr(XPathParser* parser) {
             tc->value = leptris_strdup(tests);
             return parse_postfix_ops(parser, tc);
         }
+        /* processing-instruction NAME { content } — the computed
+         * PI constructor. The target is the NCNAME/QNAME; the
+         * optional content serializes as the PI data. */
+        else if (current_token(parser)->type == TOK_NCNAME &&
+                 current_token(parser)->value_len == 22 &&
+                 memcmp(current_token(parser)->value,
+                        "processing-instruction", 22) == 0 &&
+                 next && (next->type == TOK_NCNAME ||
+                          next->type == TOK_QNAME) &&
+                 parser->token_pos + 2 < parser->token_count &&
+                 parser->tokens[parser->token_pos + 2].type ==
+                     TOK_LBRACE) {
+            char name[128];
+            size_t nl = next->value_len;
+            if (nl >= sizeof(name)) return NULL;
+            memcpy(name, next->value, nl);
+            name[nl] = 0;
+            advance_token(parser);
+            advance_token(parser);
+            advance_token(parser);
+            XPathASTNode* pc = ast_node_new(XPATH_AST_OPERATOR);
+            if (!pc) return NULL;
+            pc->number_value = (double)XPATH_OP_PI_CTOR;
+            pc->value = leptris_strdup(name);
+            if (current_token_is(parser, TOK_RBRACE)) {
+                XPathASTNode* empty = ast_node_new(XPATH_AST_OPERATOR);
+                if (!empty) { ast_node_free(pc); return NULL; }
+                empty->number_value = (double)XPATH_OP_SEQUENCE;
+                ast_node_add_child(pc, empty);
+            } else {
+                XPathASTNode* item = parse_expr(parser);
+                if (!item) { ast_node_free(pc); return NULL; }
+                ast_node_add_child(pc, item);
+            }
+            if (!current_token_is(parser, TOK_RBRACE)) {
+                ast_node_free(pc);
+                return NULL;
+            }
+            advance_token(parser);
+            return parse_postfix_ops(parser, pc);
+        }
+        /* comment { content } — the computed comment constructor.
+         * Guarded by the brace so the comment() node test stays
+         * intact. */
+        else if (current_token(parser)->type == TOK_NCNAME &&
+                 next && next->type == TOK_LBRACE &&
+                 current_token(parser)->value_len == 7 &&
+                 memcmp(current_token(parser)->value, "comment", 7) == 0) {
+            advance_token(parser);
+            advance_token(parser);
+            XPathASTNode* cc = ast_node_new(XPATH_AST_OPERATOR);
+            if (!cc) return NULL;
+            cc->number_value = (double)XPATH_OP_COMMENT_CTOR;
+            if (current_token_is(parser, TOK_RBRACE)) {
+                XPathASTNode* empty = ast_node_new(XPATH_AST_OPERATOR);
+                if (!empty) { ast_node_free(cc); return NULL; }
+                empty->number_value = (double)XPATH_OP_SEQUENCE;
+                ast_node_add_child(cc, empty);
+            } else {
+                XPathASTNode* item = parse_expr(parser);
+                if (!item) { ast_node_free(cc); return NULL; }
+                ast_node_add_child(cc, item);
+            }
+            if (!current_token_is(parser, TOK_RBRACE)) {
+                ast_node_free(cc);
+                return NULL;
+            }
+            advance_token(parser);
+            return parse_postfix_ops(parser, cc);
+        }
         else if (current_token(parser)->type == TOK_NCNAME &&
                  next && next->type == TOK_LBRACE &&
                  current_token(parser)->value_len == 4 &&

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

@@ -486,6 +486,13 @@ LEPTRIS_API char* leptris_xpath_result_string(LeptrisXPathResult result) {
         case XPATH_RESULT_BOOLEAN:
             return leptris_strdup(result->value.boolean_value ? "true" : "false");
         case XPATH_RESULT_NUMBER:
+            if (result->xq_spelling) {
+                char* s = xpath_number_to_string_xq_typed(
+                    result->value.number_value,
+                    result->atomic_type &&
+                        strcmp(result->atomic_type, "xs:float") == 0);
+                if (s) return s;
+            }
             if (result->is_int) return xpath_int_to_string(result->int_value);
             return xpath_number_to_string(result->value.number_value);
         case XPATH_RESULT_NODESET:

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

@@ -3168,6 +3168,11 @@ static LeptrisXPathResult xq_eval_impl(
         else
             free(s);
     }
+    /* XQuery number spelling rides the result: NUMBER returns render
+     * via the shortest round-trip E form in result_string (the
+     * libxml2-parity XPath printer stays for the XPath surface). */
+    if (result && result->type == XPATH_RESULT_NUMBER && !result->is_int)
+        result->xq_spelling = 1;
     return result;
 }
 

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

@@ -922,12 +922,10 @@ TEST(Qt3Subset, FnRemove) {
 
 TEST(Qt3Subset, FnReverse) {
     /* Reds are the typed-atom class (NaN/INF/boolean member compare). */
-    run_test_set("fn/reverse.xml", {}, 57, {},
+    run_test_set("fn/reverse.xml", {}, 59, {},
                  {
                    "K2-SeqReverseFunc-1",
                    "K2-SeqReverseFunc-2",
-                   "fn-reversedbl1args-1",
-                   "fn-reversedbl1args-3",
 
                  });
 }
@@ -961,7 +959,7 @@ TEST(Qt3Subset, FnDistinctValues) {
     /* mixed-args-012 (decimal-vs-float dedup) diverges ONLY inside
      * the LTO'd test binary — identical query passes standalone and
      * via the public API; CI's non-LTO/gcc legs are the arbiter. */
-    run_test_set("fn/distinct-values.xml", {}, 87, {},
+    run_test_set("fn/distinct-values.xml", {}, 89, {},
                  {
                    "cbcl-distinct-values-002",
                    "cbcl-distinct-values-002b",
@@ -975,8 +973,6 @@ TEST(Qt3Subset, FnDistinctValues) {
                    "fn-distinct-values-mixed-args-010",
                    "fn-distinct-values-mixed-args-012",
                    "fn-distinct-values-mixed-args-018",
-                   "fn-distinct-valuesdbl1args-1",
-                   "fn-distinct-valuesdbl1args-3",
 
                  });
 }

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

@@ -821,3 +821,84 @@ TEST(XQueryLeaks, RepeatedFunctionDeclarationEvalsDoNotLeak) {
     }
     leptris_document_free(doc);
 }
+
+/* Computed PI and comment constructors (QT3 cbcl-deep-equal-002..004
+ * class): the string-level ctor model serializes them to their XML
+ * markup, so deep-equal compares target+data / comment text. */
+TEST(XQueryCtors, PIConstructor) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string("<e/>", 4, &st);
+    ASSERT_NE(doc, nullptr);
+    struct {
+        const char* q;
+        const char* want;
+    } cases[] = {
+        {"processing-instruction target { \"data\" }", "<?target data?>"},
+        {"processing-instruction target { \"\" }", "<?target?>"},
+        {"processing-instruction target { () }", "<?target?>"},
+    };
+    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(XQueryCtors, CommentConstructor) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string("<e/>", 4, &st);
+    ASSERT_NE(doc, nullptr);
+    const char* cq = "comment { \"hello\" }";
+    LeptrisXQuery xq = leptris_xquery_parse(cq, strlen(cq));
+    ASSERT_NE(xq, nullptr);
+    LeptrisXPathResult r = leptris_xquery_eval(xq, doc, NULL);
+    ASSERT_NE(r, nullptr);
+    char* s = leptris_xpath_result_string(r);
+    ASSERT_NE(s, nullptr);
+    EXPECT_STREQ(s, "<!--hello-->");
+    leptris_free_string(s);
+    leptris_xpath_result_free(r);
+    leptris_xquery_free(xq);
+    leptris_document_free(doc);
+}
+
+TEST(XQueryCtors, PICtorDeepEqualByTargetAndData) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string("<e/>", 4, &st);
+    ASSERT_NE(doc, nullptr);
+    struct {
+        const char* q;
+        bool want;
+    } cases[] = {
+        {"deep-equal(processing-instruction cheese { \"brie\" }, "
+         "processing-instruction cheese { \"brie\" })",
+         true},
+        {"deep-equal(processing-instruction cheese { \"brie\" }, "
+         "processing-instruction cheese { \"stilton\" })",
+         false},
+        {"deep-equal(processing-instruction foo { \"bar\" }, "
+         "processing-instruction bar { \"foo\" })",
+         false},
+    };
+    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 ? "true" : "false") << c.q;
+        leptris_free_string(s);
+        leptris_xpath_result_free(r);
+        leptris_xquery_free(xq);
+    }
+    leptris_document_free(doc);
+}

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.237",
+  "version": "1.9.239",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.237.1
+  version: 1.9.239.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-24 00:00:00.000000000 Z
+date: 2026-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi