leptris 1.9.232.1-arm-linux → 1.9.237.1-arm-linux

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

@@ -332,7 +332,11 @@ int xpath_result_matches_type(struct leptris_xpath_result* v,
             const char* mc =
                 (tag == (int)LEPTRIS_NODE_TEXT && n)
                     ? ((XPathTextNode*)n)->content : NULL;
-            int is_num_member = mc && mc[0] == '\x03' && mc[1] == 'N';
+            int is_num_member = mc && mc[0] == '\x03' &&
+                                (mc[1] == 'N' ||
+                                 (mc[1] == 'F' &&
+                                  !((mc[2] == 'N' && mc[3] == '\x02') ||
+                                    mc[2] == 'R')));
             if (strcmp(base, "item()") == 0) {
                 /* every member is an item */
             } else if (strcmp(base, "node()") == 0) {
@@ -2131,7 +2135,11 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                         (tag == (int)LEPTRIS_NODE_TEXT && n)
                             ? ((XPathTextNode*)n)->content : NULL;
                     int is_num_member = mc && mc[0] == '\x03' &&
-                                        mc[1] == 'N';
+                                        (mc[1] == 'N' ||
+                                         (mc[1] == 'F' &&
+                                          !((mc[2] == 'N' &&
+                                             mc[3] == '\x02') ||
+                                            mc[2] == 'R')));
                     if (strcmp(base, "item()") == 0) {
                         /* every member is an item */
                     } else if (strcmp(base, "node()") == 0) {
@@ -2281,17 +2289,43 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                 if (item->type == XPATH_RESULT_NUMBER) {
                     /* "\x03N" marks numeric members for per-member
                      * type checks (instance of); get_node_text
-                     * strips it for string consumers. */
+                     * strips it for string consumers. "F" carries
+                     * xs:float members (float32-exact values) so
+                     * eq-based functions apply float promotion. */
                     size_t pl = piece ? strlen(piece) : 0;
                     char* marked = (char*)malloc(pl + 3);
                     if (marked) {
-                        marked[0] = '\x03'; marked[1] = 'N';
+                        marked[0] = '\x03';
+                        marked[1] = (item->atomic_type &&
+                                     strcmp(item->atomic_type,
+                                            "xs:float") == 0)
+                                        ? 'F'
+                                    : (item->atomic_type &&
+                                       strcmp(item->atomic_type,
+                                              "xs:decimal") == 0)
+                                        ? 'D' : 'N';
                         if (pl) memcpy(marked + 2, piece, pl);
                         marked[2 + pl] = 0;
                         XPathTextNode* tn = synth_text(marked, pl + 2);
                         free(marked);
                         if (tn) xpath_nodeset_add(out, tn);
                     }
+                } else if (item->type == XPATH_RESULT_BOOLEAN) {
+                    /* "\x03B" marks boolean members so EBV
+                     * round-trips (a false boolean must stay falsy
+                     * after subsequence/remove round-trips). */
+                    const char* bp =
+                        item->value.boolean_value ? "true" : "false";
+                    char* marked = (char*)malloc(strlen(bp) + 3);
+                    if (marked) {
+                        marked[0] = '\x03';
+                        marked[1] = 'B';
+                        strcpy(marked + 2, bp);
+                        XPathTextNode* tn =
+                            synth_text(marked, strlen(bp) + 2);
+                        free(marked);
+                        if (tn) xpath_nodeset_add(out, tn);
+                    }
                 } else {
                     XPathTextNode* tn =
                         synth_text(piece ? piece : "",

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

@@ -231,7 +231,11 @@ 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 += 2;
+            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;
             return leptris_strdup(c);
         }
 

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

@@ -732,14 +732,35 @@ static int de_node_equal(LeptrisNodeRef a, LeptrisNodeRef b) {
         default:
             return 0;
     }
-    /* Element children: pairwise, in order. */
+    /* Element children: pairwise, in order. F&O 3.0: comment and
+     * processing-instruction children are not significant to
+     * deep-equality (cbcl-deep-equal-001: PI vs comment under the
+     * same element compares equal). */
     LeptrisNodeRef ca = leptris_node_first_child(a);
     LeptrisNodeRef cb = leptris_node_first_child(b);
     while (ca && cb) {
+        int tca = leptris_node_get_type(ca);
+        int tcb = leptris_node_get_type(cb);
+        if (tca == LEPTRIS_NODE_TYPE_COMMENT ||
+            tca == LEPTRIS_NODE_TYPE_PI) {
+            ca = leptris_node_next_sibling(ca);
+            continue;
+        }
+        if (tcb == LEPTRIS_NODE_TYPE_COMMENT ||
+            tcb == LEPTRIS_NODE_TYPE_PI) {
+            cb = leptris_node_next_sibling(cb);
+            continue;
+        }
         if (!de_node_equal(ca, cb)) return 0;
         ca = leptris_node_next_sibling(ca);
         cb = leptris_node_next_sibling(cb);
     }
+    while (ca && (leptris_node_get_type(ca) == LEPTRIS_NODE_TYPE_COMMENT ||
+                  leptris_node_get_type(ca) == LEPTRIS_NODE_TYPE_PI))
+        ca = leptris_node_next_sibling(ca);
+    while (cb && (leptris_node_get_type(cb) == LEPTRIS_NODE_TYPE_COMMENT ||
+                  leptris_node_get_type(cb) == LEPTRIS_NODE_TYPE_PI))
+        cb = leptris_node_next_sibling(cb);
     return ca == NULL && cb == NULL;
 }
 
@@ -752,8 +773,29 @@ typedef struct {
     char* str;            /* owned for synthetic items */
     const char* borrow;   /* document-lifetime text */
     LeptrisNodeRef node;
+    /* Typed-atom tag from the result (interned literal, not owned);
+     * NULL for the untyped/string class. */
+    const char* type;
 } DeItem;
 
+/* Numeric promotion rank: xs:decimal(1) < xs:float(2) <= the
+ * double carrier (untyped numerics, xs:double, integers — integers
+ * are int64-exact in the double carrier for eq purposes). */
+static int de_num_rank(const char* t) {
+    if (!t) return 3;
+    if (strcmp(t, "xs:float") == 0) return 2;
+    if (strcmp(t, "xs:decimal") == 0) return 1;
+    return 3;
+}
+
+/* The untyped/string equivalence class: plain ctor/lexical strings,
+ * xs:string, xs:anyURI, xs:untypedAtomic all compare by codepoint. */
+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;
+}
+
 static void de_item_clear(DeItem* it) {
     if (it->str) LEPTRIS_FREE(it->str);
     it->str = NULL;
@@ -767,12 +809,28 @@ static int de_item_equal(DeItem* a, DeItem* b) {
             /* deep-equal is atomic-eq based: NaN compares equal to
              * NaN (F&O 17.4.1 — unlike the eq operator). */
             if (isnan(a->num) && isnan(b->num)) return 1;
-            return a->num == b->num;
+            /* Numeric promotion by rank: the lower side converts to
+             * the higher (decimal->float rounds; float->double is
+             * exact). xs:float rounds at construction, so the plain
+             * compare against a double is the exact widening
+             * (float(1.01) ne double(1.01)) while decimal vs float
+             * rounds the decimal (mix-args-017 true). */
+            int ra = de_num_rank(a->type);
+            int rb = de_num_rank(b->type);
+            double xa = a->num, xb = b->num;
+            if (rb == 2 && ra < 2) xa = (double)(float)xa;
+            else if (ra == 2 && rb < 2) xb = (double)(float)xb;
+            return xa == xb;
         }
         case 2: {
             const char* as = a->str ? a->str : (a->borrow ? a->borrow : "");
             const char* bs = b->str ? b->str : (b->borrow ? b->borrow : "");
-            return strcmp(as, bs) == 0;
+            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) &&
+                strcmp(a->type, b->type) == 0)
+                return strcmp(as, bs) == 0;
+            return 0;   /* typed (xs:date...) vs anything else */
         }
         default: return a->num == b->num;   /* booleans as 0/1 */
     }
@@ -788,6 +846,7 @@ static size_t de_collect(struct leptris_xpath_result* r, DeItem* out,
             out[i].str = NULL;
             out[i].borrow = NULL;
             out[i].node = NULL;
+            out[i].type = NULL;
             int ty = XPATH_NODE_TYPE(ns->nodes[i]);
             if (ty == LEPTRIS_NODE_TEXT) {
                 /* Synthetic sequence member (tag 8): content rides
@@ -795,8 +854,17 @@ static size_t de_collect(struct leptris_xpath_result* r, DeItem* out,
                  * the "\x03N" marker. */
                 const char* c = ((XPathTextNode*)ns->nodes[i])->content;
                 c = c ? c : "";
-                if (c[0] == '\x03' && c[1] == 'N') {
+                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] == 'N' || c[1] == 'D' ||
+                     (c[1] == 'F' &&
+                      !((c[2] == 'N' && c[3] == '\x02') ||
+                        c[2] == 'R')))) {
                     out[i].kind = 1;
+                    out[i].type = c[1] == 'F' ? "xs:float"
+                                : c[1] == 'D' ? "xs:decimal" : NULL;
                     out[i].num = strtod(c + 2, NULL);
                 } else {
                     out[i].kind = 2;
@@ -816,6 +884,7 @@ static size_t de_collect(struct leptris_xpath_result* r, DeItem* out,
     out[0].str = NULL;
     out[0].borrow = NULL;
     out[0].node = NULL;
+    out[0].type = r->atomic_type;
     if (r->type == XPATH_RESULT_NUMBER) {
         out[0].kind = 1;
         out[0].num = r->value.number_value;
@@ -834,11 +903,21 @@ static struct leptris_xpath_result* xpath_func_deep_equal(XPathContext* context,
     XPathASTNode** args,
     size_t arg_count
 ) {
-    if (arg_count != 2) {
+    if (arg_count < 2 || arg_count > 3) {
         snprintf(context->error_msg, sizeof(context->error_msg),
-                "deep-equal() requires exactly 2 arguments, got %zu", arg_count);
+                "deep-equal() requires 2 or 3 arguments, got %zu", arg_count);
         return NULL;
     }
+    if (arg_count == 3) {
+        /* Collation argument: the default and codepoint URIs (and,
+         * per the QT3 corpus, any URI here) fold to the codepoint
+         * comparison this engine implements; evaluation errors
+         * propagate. */
+        struct leptris_xpath_result* c =
+            xpath_evaluate(context, args[2]);
+        if (!c) return NULL;
+        leptris_xpath_result_free(c);
+    }
 
     struct leptris_xpath_result* a = xpath_evaluate(context, args[0]);
     if (!a) return NULL;
@@ -2729,7 +2808,7 @@ void xpath_function_registry_init_standard(XPathFunctionRegistry* registry) {
     xpath_function_registry_register(registry, "concat", xpath_func_concat, 2, -1);
     xpath_function_registry_register(registry, "starts-with", xpath_func_starts_with, 2, 3);
     xpath_function_registry_register(registry, "ends-with", xpath_func_ends_with, 2, 3);
-    xpath_function_registry_register(registry, "deep-equal", xpath_func_deep_equal, 2, 2);
+    xpath_function_registry_register(registry, "deep-equal", xpath_func_deep_equal, 2, 3);
     xpath_function_registry_register(registry, "contains", xpath_func_contains, 2, 3);
     xpath_function_registry_register(registry, "substring", xpath_func_substring, 2, 3);
     xpath_function_registry_register(registry, "substring-before", xpath_func_substring_before, 2, 3);

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

@@ -133,6 +133,99 @@ static void free_items(char** items, size_t n) {
     free(items);
 }
 
+/* Marker-preserving collect: synthetic members keep their raw
+ * content so the "N" numeric marker survives the round-trip
+ * (get_node_text strips it). deep-equal's kind split then agrees
+ * on both sides of reverse()/etc., and eq-based functions can
+ * apply numeric semantics (NaN never matches, 2.0 == 2). */
+static char** collect_items_raw(XPathContext* ctx, XPathASTNode** args,
+                                size_t n, size_t i, size_t* out_n) {
+    *out_n = 0;
+    struct leptris_xpath_result* r = xpath_evaluate(ctx, args[i]);
+    if (!r) return NULL;
+    char** items = NULL;
+    size_t cnt = 0;
+    if (r->type == XPATH_RESULT_NODESET && r->value.nodeset_value) {
+        XPathNodeSet* ns = r->value.nodeset_value;
+        items = (char**)malloc((ns->count ? ns->count : 1) * sizeof(char*));
+        if (!items) { xpath_result_free(r); return NULL; }
+        for (size_t k = 0; k < ns->count; k++) {
+            void* nd = ns->nodes[k];
+            if (XPATH_NODE_TYPE(nd) == LEPTRIS_NODE_TEXT) {
+                const char* c = ((XPathTextNode*)nd)->content;
+                items[cnt++] = leptris_strdup(c ? c : "");
+            } else {
+                char* t = get_node_text(nd);
+                items[cnt++] = t ? t : leptris_strdup("");
+            }
+        }
+    } else if (r->type == XPATH_RESULT_NUMBER) {
+        char* s = 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; }
+        char* m = (char*)malloc(sl + 3);
+        if (m) {
+            m[0] = '\x03';
+            m[1] = (r->atomic_type &&
+                    strcmp(r->atomic_type, "xs:float") == 0)
+                       ? 'F'
+                   : (r->atomic_type &&
+                      strcmp(r->atomic_type, "xs:decimal") == 0)
+                       ? 'D' : 'N';
+            if (sl) memcpy(m + 2, s, sl);
+            m[2 + sl] = 0;
+        }
+        items[cnt++] = m ? m : leptris_strdup("");
+        free(s);
+    } else {
+        items = (char**)malloc(sizeof(char*));
+        if (!items) { xpath_result_free(r); return NULL; }
+        items[cnt++] = scalar_str(r);
+    }
+    xpath_result_free(r);
+    *out_n = cnt;
+    (void)n;
+    return items;
+}
+
+/* eq-based atomic comparison over raw item strings: both-marked
+ * compares numerically; both-plain compares by codepoint; number
+ * vs string is false. nan_equal: distinct-values dedups NaN with
+ * itself (F&O 3.1), fn:index-of's eq never matches it. 'F' markers
+ * carry xs:float members (float32-exact values); an F vs plain-N
+ * pair promotes the plain side DOWN to float (decimal-vs-float
+ * promotes decimal to float per F&O numeric promotion). */
+static int atom_seq_eq_n(const char* a, const char* b, int nan_equal) {
+    int ka = (a[0] == '\x03' && a[1] == 'N') ? 'N'
+             : (a[0] == '\x03' && a[1] == 'F') ? 'F'
+             : (a[0] == '\x03' && a[1] == 'D') ? 'D'
+             : (a[0] == '\x03' && a[1] == 'B') ? 'B' : 0;
+    int kb = (b[0] == '\x03' && b[1] == 'N') ? 'N'
+             : (b[0] == '\x03' && b[1] == 'F') ? 'F'
+             : (b[0] == '\x03' && b[1] == 'D') ? 'D'
+             : (b[0] == '\x03' && b[1] == 'B') ? 'B' : 0;
+    if (!ka != !kb) return 0;
+    if (ka == 'B' && kb == 'B') return strcmp(a + 2, b + 2) == 0;
+    if (!ka) return strcmp(a, b) == 0;
+    /* xs:decimal eq is exact — the double carrier cannot hold 30
+     * significant digits, so same-type decimals compare lexically
+     * (equal-value canonical decimals share their spelling). */
+    if (ka == 'D' && kb == 'D') return strcmp(a + 2, b + 2) == 0;
+    double da = strtod(a + 2, NULL);
+    double db = strtod(b + 2, NULL);
+    int na = isnan(da), nb = isnan(db);
+    /* NaN eq nothing (distinct-values dedups NaN with itself) */
+    if (na || nb) return na && nb ? nan_equal : 0;
+    if (ka == 'F' && kb != 'F') db = (double)(float)db;
+    else if (kb == 'F' && ka != 'F') da = (double)(float)da;
+    return da == db;
+}
+
+static int atom_seq_eq(const char* a, const char* b) {
+    return atom_seq_eq_n(a, b, 0);
+}
+
 /* Positional helpers (1-based; start may be <= 0, len NaN = to end). */
 static void seq_from_items(struct leptris_xpath_result* seq, char** items,
                            size_t n, long start, long len) {
@@ -192,7 +285,7 @@ static struct leptris_xpath_result* fn_tail(XPathContext* ctx,
 static struct leptris_xpath_result* fn_reverse(XPathContext* ctx,
         XPathASTNode** args, size_t n) {
     size_t cnt;
-    char** items = collect_items(ctx, args, n, 0, &cnt);
+    char** items = collect_items_raw(ctx, args, n, 0, &cnt);
     if (!items) return NULL;
     struct leptris_xpath_result* out = seq_new();
     if (out)
@@ -227,7 +320,7 @@ static struct leptris_xpath_result* fn_unordered(XPathContext* ctx,
 static struct leptris_xpath_result* fn_subsequence(XPathContext* ctx,
         XPathASTNode** args, size_t n) {
     size_t cnt;
-    char** items = collect_items(ctx, args, n, 0, &cnt);
+    char** items = collect_items_raw(ctx, args, n, 0, &cnt);
     if (!items) return NULL;
     struct leptris_xpath_result* sv = xpath_evaluate(ctx, args[1]);
     double sd = sv ? leptris_xpath_result_number(sv) : 0;
@@ -240,16 +333,40 @@ static struct leptris_xpath_result* fn_subsequence(XPathContext* ctx,
     if (sv) leptris_xpath_result_free(sv);
     struct leptris_xpath_result* out = seq_new();
     if (out) {
-        /* F&O: a negative $length yields the empty sequence
-         * (K-SeqSubsequenceFunc-5) — len < 0 is NOT the "to end"
-         * sentinel here. */
-        if (n >= 3 && ld < 0) {
-            free_items(items, cnt);
-            return out;
+        /* F&O window in position space: item p (1-based) is in the
+         * result iff round(start) <= p and, 3-arg form, also
+         * p < round(start) + round(len). NaN compares false ->
+         * empty (cbcl-subsequence-002/003/005). Positions are NOT
+         * clamped to 1 — a negative start with a short length
+         * covers no positive position (cbcl-subsequence-009).
+         * start/len round half toward +infinity like fn:round
+         * (K2-SeqSubsequenceFunc-5: 1.8 -> 2). */
+        double start = (sd != sd) ? 1.0 : floor(sd + 0.5);
+        double len = 0;
+        int has_len = 0;
+        if (n >= 3) {
+            /* NaN length or negative length: empty */
+            if (ld != ld || ld < 0) {
+                free_items(items, cnt);
+                return out;
+            }
+            len = floor(ld + 0.5);
+            has_len = 1;
+        }
+        for (size_t k = 0; k < cnt; k++) {
+            double p = (double)(k + 1);
+            /* The spec's own window: p >= round(start) and, 3-arg
+             * form, p < round(start) + round(len). The sum can be
+             * NaN (-INF + INF) making every comparison false ->
+             * empty (cbcl-subsequence-001), so the membership test
+             * must stay NaN-safe — no early break. The 2-arg form
+             * has no upper bound (cbcl-subsequence-004: start=-INF
+             * selects everything; a sentinel length would collide
+             * with -inf + finite = -inf). */
+            if (!(p >= start)) continue;
+            if (has_len && !(p < start + len)) continue;
+            seq_push_str(out, items[k]);
         }
-        long start = (long)sd;
-        long len = (n >= 3) ? (ld != ld ? -1 : (long)ld) : -1;
-        seq_from_items(out, items, cnt, start, len);
     }
     free_items(items, cnt);
     return out;
@@ -258,7 +375,7 @@ static struct leptris_xpath_result* fn_subsequence(XPathContext* ctx,
 static struct leptris_xpath_result* fn_remove(XPathContext* ctx,
         XPathASTNode** args, size_t n) {
     size_t cnt;
-    char** items = collect_items(ctx, args, n, 0, &cnt);
+    char** items = collect_items_raw(ctx, args, n, 0, &cnt);
     if (!items) return NULL;
     struct leptris_xpath_result* iv = xpath_evaluate(ctx, args[1]);
     long drop = iv ? (long)leptris_xpath_result_number(iv) : 0;
@@ -301,14 +418,54 @@ static struct leptris_xpath_result* fn_insert_before(XPathContext* ctx,
 static struct leptris_xpath_result* fn_index_of(XPathContext* ctx,
         XPathASTNode** args, size_t n) {
     size_t cnt;
-    char** items = collect_items(ctx, args, n, 0, &cnt);
+    char** items = collect_items_raw(ctx, args, n, 0, &cnt);
     if (!items) return NULL;
+    /* Collation argument (3-arg form): accepted, folds to the
+     * codepoint comparison; evaluation errors propagate. */
+    if (n > 2) {
+        struct leptris_xpath_result* c = xpath_evaluate(ctx, args[2]);
+        if (!c) { free_items(items, cnt); return NULL; }
+        leptris_xpath_result_free(c);
+    }
     struct leptris_xpath_result* v = xpath_evaluate(ctx, args[1]);
-    char* needle = v ? scalar_str(v) : NULL;
+    char* needle = NULL;
+    if (v && v->type == XPATH_RESULT_BOOLEAN) {
+        /* B-marked members must match B-marked needles */
+        const char* bp = v->value.boolean_value ? "true" : "false";
+        needle = (char*)malloc(strlen(bp) + 3);
+        if (needle) {
+            needle[0] = '\x03';
+            needle[1] = 'B';
+            strcpy(needle + 2, bp);
+        } else {
+            needle = leptris_strdup("");
+        }
+    } else if (v && v->type == XPATH_RESULT_NUMBER) {
+        char* s = scalar_str(v);
+        size_t sl = s ? strlen(s) : 0;
+        needle = (char*)malloc(sl + 3);
+        if (needle) {
+            needle[0] = '\x03';
+            needle[1] = (v->atomic_type &&
+                         strcmp(v->atomic_type, "xs:float") == 0)
+                            ? 'F'
+                        : (v->atomic_type &&
+                           strcmp(v->atomic_type, "xs:decimal") == 0)
+                            ? 'D' : 'N';
+            if (sl) memcpy(needle + 2, s, sl);
+            needle[2 + sl] = 0;
+        } else {
+            needle = leptris_strdup("");
+        }
+        free(s);
+    } else {
+        needle = v ? scalar_str(v) : NULL;
+    }
     struct leptris_xpath_result* out = seq_new();
     if (out && needle)
         for (size_t k = 0; k < cnt; k++)
-            if (strcmp(items[k], needle) == 0) seq_push_num(out, (double)(k + 1));
+            if (atom_seq_eq(items[k], needle))
+                seq_push_num(out, (double)(k + 1));
     free(needle);
     if (v) leptris_xpath_result_free(v);
     free_items(items, cnt);
@@ -318,14 +475,23 @@ static struct leptris_xpath_result* fn_index_of(XPathContext* ctx,
 static struct leptris_xpath_result* fn_distinct_values(XPathContext* ctx,
         XPathASTNode** args, size_t n) {
     size_t cnt;
-    char** items = collect_items(ctx, args, n, 0, &cnt);
+    char** items = collect_items_raw(ctx, args, n, 0, &cnt);
     if (!items) return NULL;
+    /* 2-arg form: collation accepted (folds to codepoint); errors
+     * propagate. */
+    if (n > 1) {
+        struct leptris_xpath_result* c = xpath_evaluate(ctx, args[1]);
+        if (!c) { free_items(items, cnt); return NULL; }
+        leptris_xpath_result_free(c);
+    }
     struct leptris_xpath_result* out = seq_new();
     if (out)
         for (size_t k = 0; k < cnt; k++) {
             int dup = 0;
             for (size_t j = 0; j < k && !dup; j++)
-                if (strcmp(items[k], items[j]) == 0) dup = 1;
+                if (atom_seq_eq_n(items[k], items[j], 1)) dup = 1;
+            /* first occurrence keeps its original spelling
+             * (distinct-values((1, 2.0, 3, 2)) = 1, 2.0, 3) */
             if (!dup) seq_push_str(out, items[k]);
         }
     free_items(items, cnt);
@@ -2761,7 +2927,36 @@ static struct leptris_xpath_result* fn_xs_integer(XPathContext* ctx,
 }
 static struct leptris_xpath_result* fn_xs_double(XPathContext* ctx,
         XPathASTNode** a, size_t n) {
-    return fn_xs_number_ctor(ctx, a, n, 0);
+    struct leptris_xpath_result* r = fn_xs_number_ctor(ctx, a, n, 0);
+    if (r) r->atomic_type = "xs:double";
+    return r;
+}
+
+static struct leptris_xpath_result* fn_xs_float(XPathContext* ctx,
+        XPathASTNode** a, size_t n) {
+    struct leptris_xpath_result* r = fn_xs_number_ctor(ctx, a, n, 0);
+    if (r) {
+        /* xs:float keeps float32 precision: the value is the float
+         * nearest the lexical form, widened for the double carrier
+         * (deep-equal's widening compare is then exact). */
+        r->value.number_value = (double)((float)r->value.number_value);
+        r->atomic_type = "xs:float";
+    }
+    return r;
+}
+
+static struct leptris_xpath_result* fn_xs_date_t(XPathContext* ctx,
+        XPathASTNode** args, size_t n) {
+    struct leptris_xpath_result* out = fn_passthrough_ctor(ctx, args, n);
+    if (out) out->atomic_type = "xs:date";
+    return out;
+}
+
+static struct leptris_xpath_result* fn_xs_datetime_t(XPathContext* ctx,
+        XPathASTNode** args, size_t n) {
+    struct leptris_xpath_result* out = fn_passthrough_ctor(ctx, args, n);
+    if (out) out->atomic_type = "xs:dateTime";
+    return out;
 }
 
 /* ---- integer-subtype constructors (QT3 fn/concat): the same
@@ -2845,7 +3040,7 @@ XS_INT_SUB(fn_xs_nonneg, 0, LLONG_MAX, "xs:nonNegativeInteger")
 
 /* xs:decimal: an all-integer lexical keeps int64 fidelity
  * (QT3 fn/concatdec2args); fractions ride the double ctor. */
-static struct leptris_xpath_result* fn_xs_decimal(XPathContext* ctx,
+static struct leptris_xpath_result* fn_xs_decimal_impl(XPathContext* ctx,
         XPathASTNode** a, size_t n) {
     struct leptris_xpath_result* r = xpath_evaluate(ctx, a[0]);
     if (!r) return NULL;
@@ -2868,6 +3063,13 @@ static struct leptris_xpath_result* fn_xs_decimal(XPathContext* ctx,
     return fn_xs_number_ctor(ctx, a, n, 0);
 }
 
+static struct leptris_xpath_result* fn_xs_decimal(XPathContext* ctx,
+        XPathASTNode** a, size_t n) {
+    struct leptris_xpath_result* r = fn_xs_decimal_impl(ctx, a, n);
+    if (r) r->atomic_type = "xs:decimal";
+    return r;
+}
+
 static struct leptris_xpath_result* fn_xs_boolean(XPathContext* ctx,
         XPathASTNode** args, size_t n) {
     struct leptris_xpath_result* r = xpath_evaluate(ctx, args[0]);
@@ -5157,8 +5359,8 @@ void xpath_register_fn31(XPathFunctionRegistry* registry) {
     xpath_function_registry_register(registry, "subsequence", fn_subsequence, 2, 3);
     xpath_function_registry_register(registry, "remove", fn_remove, 2, 2);
     xpath_function_registry_register(registry, "insert-before", fn_insert_before, 3, 3);
-    xpath_function_registry_register(registry, "index-of", fn_index_of, 2, 2);
-    xpath_function_registry_register(registry, "distinct-values", fn_distinct_values, 1, 1);
+    xpath_function_registry_register(registry, "index-of", fn_index_of, 2, 3);
+    xpath_function_registry_register(registry, "distinct-values", fn_distinct_values, 1, 2);
     xpath_function_registry_register(registry, "avg", fn_avg, 1, 1);
     xpath_function_registry_register(registry, "min", fn_min, 1, 1);
     xpath_function_registry_register(registry, "max", fn_max, 1, 1);
@@ -5242,13 +5444,13 @@ void xpath_register_fn31(XPathFunctionRegistry* registry) {
     xpath_function_registry_register(registry, "namespace-uri-from-QName", fn_ns_from_qname, 1, 1);
     xpath_function_registry_register(registry, "node-name", fn_node_name, 1, 1);
     /* Dates & durations (05, first slice) — canonical xs: prefix. */
-    xpath_function_registry_register(registry, "xs:date", fn_passthrough_ctor, 1, 1);
+    xpath_function_registry_register(registry, "xs:date", fn_xs_date_t, 1, 1);
     /* Atomic constructors (06) — canonical xs: prefix. */
     xpath_function_registry_register(registry, "xs:string", fn_passthrough_ctor, 1, 1);
     xpath_function_registry_register(registry, "xs:anyURI", fn_passthrough_ctor, 1, 1);
     xpath_function_registry_register(registry, "xs:integer", fn_xs_integer, 1, 1);
     xpath_function_registry_register(registry, "xs:double", fn_xs_double, 1, 1);
-    xpath_function_registry_register(registry, "xs:float", fn_xs_double, 1, 1);
+    xpath_function_registry_register(registry, "xs:float", fn_xs_float, 1, 1);
     xpath_function_registry_register(registry, "xs:decimal", fn_xs_decimal, 1, 1);
     xpath_function_registry_register(registry, "xs:int", fn_xs_int, 1, 1);
     xpath_function_registry_register(registry, "xs:long", fn_xs_long, 1, 1);
@@ -5260,12 +5462,23 @@ void xpath_register_fn31(XPathFunctionRegistry* registry) {
     xpath_function_registry_register(registry, "xs:nonPositiveInteger", fn_xs_nonpos, 1, 1);
     xpath_function_registry_register(registry, "xs:nonNegativeInteger", fn_xs_nonneg, 1, 1);
     xpath_function_registry_register(registry, "xs:boolean", fn_xs_boolean, 1, 1);
-    xpath_function_registry_register(registry, "xs:dateTime", fn_passthrough_ctor, 1, 1);
+    xpath_function_registry_register(registry, "xs:dateTime", fn_xs_datetime_t, 1, 1);
     xpath_function_registry_register(registry, "xs:time", fn_time_ctor, 1, 1);
     xpath_function_registry_register(registry, "xs:duration", fn_passthrough_ctor, 1, 1);
     xpath_function_registry_register(registry, "xs:dayTimeDuration", fn_passthrough_ctor, 1, 1);
     xpath_function_registry_register(registry, "xs:yearMonthDuration", fn_passthrough_ctor, 1, 1);
     xpath_function_registry_register(registry, "xs:QName", fn_passthrough_ctor, 1, 1);
+    /* String-classed and gREG surface (QT3 deep-equal/index-of/
+     * distinct-values families): untypedAtomic is string-equal;
+     * binary/gREG compare by lexical form in this engine. */
+    xpath_function_registry_register(registry, "xs:untypedAtomic", fn_passthrough_ctor, 1, 1);
+    xpath_function_registry_register(registry, "xs:hexBinary", fn_passthrough_ctor, 1, 1);
+    xpath_function_registry_register(registry, "xs:base64Binary", fn_passthrough_ctor, 1, 1);
+    xpath_function_registry_register(registry, "xs:gYear", fn_passthrough_ctor, 1, 1);
+    xpath_function_registry_register(registry, "xs:gYearMonth", fn_passthrough_ctor, 1, 1);
+    xpath_function_registry_register(registry, "xs:gMonthDay", fn_passthrough_ctor, 1, 1);
+    xpath_function_registry_register(registry, "xs:gMonth", fn_passthrough_ctor, 1, 1);
+    xpath_function_registry_register(registry, "xs:gDay", fn_passthrough_ctor, 1, 1);
     xpath_function_registry_register(registry, "implicit-timezone", fn_implicit_tz, 0, 0);
     xpath_function_registry_register(registry, "current-dateTime", fn_current_dt, 0, 0);
     xpath_function_registry_register(registry, "current-date", fn_current_date, 0, 0);

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

@@ -397,7 +397,11 @@ LEPTRIS_API const char* leptris_xpath_result_node_value(
          * per-member type checks — never show it to public
          * consumers. */
         if (text->content && text->content[0] == '\x03' &&
-            text->content[1] == 'N')
+            (text->content[1] == 'N' || text->content[1] == 'B' ||
+             text->content[1] == 'D' ||
+             (text->content[1] == 'F' &&
+              !((text->content[2] == 'N' && text->content[3] == '\x02') ||
+                text->content[2] == 'R'))))
             return text->content + 2;
         return text->content;
     }
@@ -415,6 +419,17 @@ LEPTRIS_API int leptris_xpath_result_boolean(LeptrisXPathResult result) {
         case XPATH_RESULT_STRING:
             return (result->value.string_value && result->value.string_value[0] != '\0') ? 1 : 0;
         case XPATH_RESULT_NODESET:
+            if (result->value.nodeset_value &&
+                result->value.nodeset_value->count == 1) {
+                void* nd = result->value.nodeset_value->nodes[0];
+                if (nd && (int)XPATH_NODE_TYPE(nd) == (int)LEPTRIS_NODE_TEXT) {
+                    XPathTextNode* tn = (XPathTextNode*)nd;
+                    /* "\x03B" boolean members carry their EBV */
+                    if (tn->content && tn->content[0] == '\x03' &&
+                        tn->content[1] == 'B')
+                        return tn->content[2] == 't';
+                }
+            }
             return (result->value.nodeset_value && result->value.nodeset_value->count > 0) ? 1 : 0;
         default:
             return 0;