leptris 1.9.331.0 → 1.9.334.0

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

@@ -8,6 +8,7 @@
  * accumulate in the schema-owned error list — the RNG accessor
  * pattern: validate returns 1/0, errors enumerate every miss.
  */
+#include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -50,6 +51,7 @@ static void verr(struct leptris_xsd_schema* s, const char* fmt,
                  const char* a, const char* b);
 struct xsd_validator {
     struct leptris_xsd_schema* s;
+    LeptrisDocument doc; /* the instance (assertion evaluation) */
     struct xsd_error* errors;
     struct xsd_error* tail;
     size_t count;
@@ -86,16 +88,20 @@ static void verrf(struct xsd_validator* v, const char* what,
 
 /* ---- lexical helpers ---------------------------------------------- */
 
+static int simple_is_numeric(struct leptris_xsd_schema* s,
+                             const XsdSimple* st);
+
 static int text_valid(struct xsd_validator* v,
                       struct leptris_xsd_schema* s, const char* type,
                       const char* lexical, const char* what,
-                      const char* name) {
+                      const char* name, LeptrisElement elem) {
     if (!type) return 1;
     int r;
+    const XsdSimple* st = NULL;
     if (strncmp(type, "xs:", 3) == 0)
         r = xsd_builtin_valid(type, lexical);
     else {
-        const XsdSimple* st = xsd_find_simple_pub(s, type);
+        st = xsd_find_simple_pub(s, type);
         if (!st) return 1; /* unresolved: accept */
         r = xsd_simple_valid_chain(s, st, lexical);
     }
@@ -103,6 +109,59 @@ static int text_valid(struct xsd_validator* v,
         verrf(v, what, name, "lexical value does not match its type");
         return 0;
     }
+    /* XSD 1.1 xs:assertion facet (document validation only):
+     * $value binds the lexical — numeric lexicals bind bare,
+     * everything else as a string — and the context is the
+     * owning element. */
+    if (st && st->assertion && elem && v->doc) {
+        XsdSimple* mut = (XsdSimple*)st;
+        if (!mut->assertion_tried) {
+            mut->assertion_tried = 1;
+            if (xsd_schema_version_11(s)) {
+                /* eval_params binds DECLARED external variables —
+                 * the test compiles under a $value declaration */
+                char wrapped[1024];
+                int w = snprintf(wrapped, sizeof(wrapped),
+                                 "declare variable $value external; %s",
+                                 mut->assertion);
+                if (w > 0 && (size_t)w < sizeof(wrapped))
+                    mut->assertion_q =
+                        leptris_xquery_parse(wrapped, (size_t)w);
+            }
+        }
+        if (mut->assertion_q) {
+            char sel[256];
+            int numeric =
+                simple_is_numeric(s, st) && *lexical &&
+                strspn(lexical, "0123456789.+-eE") == strlen(lexical);
+            if (numeric)
+                snprintf(sel, sizeof(sel), "%s", lexical);
+            else {
+                size_t w = 0;
+                sel[w++] = '\'';
+                for (const char* p = lexical; *p && w < sizeof(sel) - 3;
+                     p++) {
+                    if (*p == '\'') sel[w++] = '\'';
+                    sel[w++] = *p;
+                }
+                sel[w++] = '\'';
+                sel[w] = 0;
+            }
+            const char* names[1] = {"value"};
+            const char* sels[1] = {sel};
+            LeptrisXPathResult r2 = leptris_xquery_eval_params(
+                mut->assertion_q, v->doc, elem, names, sels, 1);
+            int ebv = 0;
+            if (r2) {
+                ebv = leptris_xpath_result_boolean(r2);
+                leptris_xpath_result_free(r2);
+            }
+            if (!ebv) {
+                verrf(v, what, name, "assertion failed");
+                return 0;
+            }
+        }
+    }
     return 1;
 }
 
@@ -201,6 +260,59 @@ static void validate_children(struct xsd_validator* v,
     }
 }
 
+/* $value binds typed: a numeric-derived simple type binds the
+ * lexical as a number literal, everything else as a string — the
+ * TYPE decides, not the lexical's shape ("5" under xs:string is
+ * the string '5'). */
+static int numeric_builtin(const char* b) {
+    static const char* nums[] = {
+        "xs:integer",  "xs:decimal",     "xs:double", "xs:float",
+        "xs:int",      "xs:long",        "xs:short",  "xs:byte",
+        "xs:nonNegativeInteger", "xs:positiveInteger",
+        "xs:negativeInteger",    "xs:nonPositiveInteger",
+        "xs:unsignedLong",       "xs:unsignedInt",
+        "xs:unsignedShort",      "xs:unsignedByte", NULL};
+    for (int i = 0; nums[i]; i++)
+        if (strcmp(b, nums[i]) == 0) return 1;
+    return 0;
+}
+
+static int simple_is_numeric(struct leptris_xsd_schema* s,
+                             const XsdSimple* st) {
+    for (int d = 0; st && d < 32; d++) {
+        if (!st->base) return 0;
+        if (strncmp(st->base, "xs:", 3) == 0)
+            return numeric_builtin(st->base);
+        st = xsd_find_simple_pub(s, st->base);
+    }
+    return 0;
+}
+
+/* xs:anyAttribute grammar: ##any (or an absent attribute),
+ * ##other, ##targetNamespace, ##local, or a space-separated URI
+ * list. */
+static int any_attr_matches(const char* grammar, const char* uri,
+                            const char* target_ns) {
+    if (!grammar || strcmp(grammar, "##any") == 0) return 1;
+    if (strcmp(grammar, "##other") == 0)
+        return uri && target_ns && strcmp(uri, target_ns) != 0;
+    if (strcmp(grammar, "##targetNamespace") == 0)
+        return uri && target_ns && strcmp(uri, target_ns) == 0;
+    if (strcmp(grammar, "##local") == 0) return uri == NULL;
+    /* URI list */
+    const char* p = grammar;
+    while (*p) {
+        while (*p == ' ' || *p == '\t') p++;
+        if (!*p) break;
+        const char* start = p;
+        while (*p && *p != ' ' && *p != '\t') p++;
+        size_t len = (size_t)(p - start);
+        if (uri && strlen(uri) == len && strncmp(uri, start, len) == 0)
+            return 1;
+    }
+    return 0;
+}
+
 static void validate_attributes(struct xsd_validator* v,
                                 struct leptris_xsd_schema* s,
                                 LeptrisElement elem,
@@ -231,11 +343,37 @@ static void validate_attributes(struct xsd_validator* v,
                 verrf(v, "attribute", a->name, "required but absent");
             continue;
         }
-        text_valid(v, s, a->type, val, "attribute", a->name);
+        text_valid(v, s, a->type, val, "attribute", a->name, elem);
         if (a->fixed && strcmp(val, a->fixed) != 0)
             verrf(v, "attribute", a->name,
                   "value does not match the fixed value");
     }
+    /* strict: every instance attribute must be declared (or pass
+     * the type's xs:anyAttribute grammar). Namespace declarations
+     * are not attributes. */
+    for (LeptrisAttribute at = leptris_element_first_attribute(elem);
+         at; at = leptris_attribute_next(at)) {
+        const char* qn = leptris_attribute_get_name(at);
+        if (!qn || strncmp(qn, "xmlns", 5) == 0) continue;
+        const char* colon = strchr(qn, ':');
+        const char* local = colon ? colon + 1 : qn;
+        int declared = 0;
+        for (XsdAttrDecl* a = ta->attrs; a && !declared; a = a->next)
+            if (strcmp(a->name, local) == 0 ||
+                strcmp(a->name, qn) == 0)
+                declared = 1;
+        if (declared) continue;
+        if (ta->any_attr_ns) {
+            /* namespace of the attribute: engine-side attributes
+             * carry their uri through the expanded form */
+            const char* auri =
+                leptris_attribute_namespace_uri(at);
+            if (any_attr_matches(ta->any_attr_ns, auri,
+                                 xsd_target_ns(s)))
+                continue;
+        }
+        verrf(v, "attribute", local, "not declared (strict)");
+    }
 }
 
 static void validate_element(struct xsd_validator* v,
@@ -246,16 +384,39 @@ static void validate_element(struct xsd_validator* v,
     leptris_element_expanded_name(elem, &local, &prefix, &uri);
     if (!local) return;
     const XsdElementDecl* d = xsd_find_element(s, local);
-    if (!d) return; /* undeclared: lax at this depth (strict later) */
+    if (!d) {
+        /* strict: the instance uses an element the schema never
+         * declared (a local particle would have typed it) */
+        verrf(v, "element", local, "not declared (strict)");
+        return;
+    }
 
-    if (!d->type) return; /* anyType */
+    /* XSD 1.1: the first alternative whose test passes types the
+     * element for this instance (context = the element). */
+    const char* eff_type = d->type;
+    for (XsdAlternative* alt = d->alternatives; alt; alt = alt->next) {
+        int ebv = 0;
+        if (alt->compiled && v->doc) {
+            LeptrisXPathResult r =
+                leptris_xquery_eval(alt->compiled, v->doc, elem);
+            if (r) {
+                ebv = leptris_xpath_result_boolean(r);
+                leptris_xpath_result_free(r);
+            }
+        }
+        if (ebv) {
+            eff_type = alt->type;
+            break;
+        }
+    }
+    if (!eff_type) return; /* anyType */
     if (d->fixed) {
         const char* text = leptris_element_text(elem);
         if (text && *text && strcmp(text, d->fixed) != 0)
             verrf(v, "element", local,
                   "content does not match the fixed value");
     }
-    validate_local(v, s, elem, local, d->type);
+    validate_local(v, s, elem, local, eff_type);
 }
 
 /* Validate one element against a type name that comes from a
@@ -270,11 +431,27 @@ static void validate_local(struct xsd_validator* v,
     if (ct) {
         validate_attributes(v, s, elem, xsd_find_type_attrs(s, type));
         validate_children(v, s, elem, ct);
+        /* XSD 1.1: the type's xs:assert list — context is the
+         * element; evaluation errors are failures */
+        for (XsdAssert* a = ct->asserts; a; a = a->next) {
+            int ebv = 0;
+            if (a->compiled && v->doc) {
+                LeptrisXPathResult r =
+                    leptris_xquery_eval(a->compiled, v->doc, elem);
+                if (r) {
+                    ebv = leptris_xpath_result_boolean(r);
+                    leptris_xpath_result_free(r);
+                }
+            }
+            if (!ebv)
+                verrf(v, "assertion", local, a->test ? a->test
+                                                     : "(invalid)");
+        }
         if (ct->text_type) {
             const char* text = leptris_element_text(elem);
             if (text && *text)
                 text_valid(v, s, ct->text_type, text, "element",
-                           local);
+                           local, elem);
         }
         return;
     }
@@ -284,8 +461,12 @@ static void validate_local(struct xsd_validator* v,
         xsd_find_simple_pub(s, type)) {
         const char* text = leptris_element_text(elem);
         if (text && *text)
-            text_valid(v, s, type, text, "element", local);
+            text_valid(v, s, type, text, "element", local, elem);
+        return;
     }
+    /* neither complex nor simple nor builtin: the schema is
+     * incomplete — loud, never a silent accept (#1615 class) */
+    verrf(v, "element", local, "type not found in the schema");
 }
 
 /* ---- slice 6: identity constraints -------------------------------- */
@@ -509,6 +690,7 @@ void xsd_validator_free(struct xsd_validator* v) {
 
 int xsd_validator_run(struct xsd_validator* v, LeptrisDocument doc) {
     if (!v || !doc) return -1;
+    v->doc = doc; /* XSD 1.1: assertion evaluation context */
     LeptrisElement root = leptris_document_root(doc);
     if (!root) return -1;
     validate_element(v, v->s, root, 0);

data/vendor-src/libleptris/src/leptris/xsd/xsd_internal.h

@@ -5,6 +5,8 @@
 
 #include <stddef.h>
 
+#include "../../include/leptris/xquery/xquery.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -57,6 +59,9 @@ typedef struct xsd_simple {
     long total_digits;
     long fraction_digits;
     char* whitespace; /* "preserve" | "replace" | "collapse" */
+    char* assertion; /* XSD 1.1: the xs:assertion test text */
+    LeptrisXQuery assertion_q; /* compiled lazily at first use */
+    int assertion_tried;       /* lazy-compile guard */
     struct xsd_simple* next;
 } XsdSimple;
 
@@ -65,6 +70,15 @@ typedef struct xsd_simple {
 int xsd_simple_valid_chain(struct leptris_xsd_schema* s,
                            const XsdSimple* t, const char* v);
 
+/* XSD 1.1 (#1075 tier 2): one xs:assert bound to a complexType —
+ * the compiled XPath 2 test plus its source text. Evaluation
+ * errors count as assertion failure. */
+typedef struct xsd_assert {
+    char* test;             /* the wire expression, for reporting */
+    LeptrisXQuery compiled; /* NULL when compilation failed */
+    struct xsd_assert* next;
+} XsdAssert;
+
 /* Content-model node: a particle (element ref / wildcard) or a
  * group (sequence | choice | all). Owned by the schema; freed
  * with the schema. */
@@ -88,8 +102,14 @@ typedef struct xsd_cm {
     struct xsd_cm* first_child; /* group children list */
     struct xsd_cm* next;        /* sibling link within the parent group */
     char* text_type; /* simpleContent wrapper: the text's type ref */
+    XsdAssert* asserts; /* XSD 1.1: the type's xs:assert list */
+    struct xsd_cm* open_any; /* XSD 1.1: xs:openContent wildcard */
+    int oc_mode;        /* 0 none/unset, 1 suffix, 2 interleave */
+    int oc_owned;       /* the wildcard node is this model's own */
 } XsdCm;
 
+
+
 /* A top-level xs:group definition: name + the model its refs
  * splice in (the definition's single sequence/choice/all). */
 typedef struct xsd_group_def {
@@ -98,15 +118,28 @@ typedef struct xsd_group_def {
     struct xsd_group_def* next;
 } XsdGroupDef;
 
+/* XSD 1.1 (xs:schema @version="1.1") gates 1.1 enforcement. */
+int xsd_schema_version_11(struct leptris_xsd_schema* s);
+
 /* Group refs resolve through the schema at NFA-build time —
  * forward references need no capture order. */
 XsdGroupDef* xsd_find_group(struct leptris_xsd_schema* s,
                             const char* name);
 
+/* XSD 1.1 (#1075 tier 2): one xs:alternative on an element
+ * declaration — the test plus the type it selects. */
+typedef struct xsd_alternative {
+    char* test;             /* wire text, for reporting */
+    LeptrisXQuery compiled; /* NULL when compilation failed */
+    char* type;             /* the selected type name */
+    struct xsd_alternative* next;
+} XsdAlternative;
+
 /* A top-level xs:element declaration (slice 3: name + type ref). */
 typedef struct xsd_element_decl {
     char* name;
     char* type;     /* "xs:string"-style builtin or a local type name */
+    XsdAlternative* alternatives; /* XSD 1.1 conditional types */
     char* fixed;    /* fixed element content: text must string-equal it */
     char* sub_head; /* substitutionGroup head (local name after ':') */
     struct xsd_element_decl* next;
@@ -157,6 +190,7 @@ typedef struct xsd_attrgroup_def {
 
 typedef struct xsd_type_attrs {
     char* type_name;
+    char* any_attr_ns; /* xs:anyAttribute grammar (NULL = absent) */
     XsdAttrDecl* attrs;
     struct xsd_type_attrs* next;
 } XsdTypeAttrs;

data/vendor-src/libleptris/test/abi/test_descriptor.cpp

@@ -2131,3 +2131,98 @@ TEST(Plan1586, ExactUriRowStillWinsAndUnqualifiedStillBinds) {
     leptris_document_free(doc);
     leptris_plan_free(plan);
 }
+
+// ---- #408: native result builder + address attach -------------------
+namespace {
+
+/* leptris_plan_result_build: a flat op program produces the same
+ * standalone result tree a walk would — wrappers, ns bindings, kid
+ * order — so leptris_plan_serialize serves standalone
+ * serialization with no DOM mint on the host side. */
+TEST(Plan408, ResultBuildFeedsSerialize) {
+    LeptrisStatus st = LEPTRIS_OK;
+    leptris_child_plan kids[1] = {};
+    kids[0].wire_name = "p";
+    kids[0].kind = LEPTRIS_PLAN_KIND_SCALAR;
+    kids[0].type_tag = 1;
+    kids[0].child_plan_index = -1;
+    leptris_element_plan plans[1] = {};
+    plans[0].element_name = "b";
+    plans[0].ns_form = LEPTRIS_PLAN_NS_ANY;
+    plans[0].child_count = 1;
+    plans[0].child_plans = kids;
+    leptris_plan_spec spec = {};
+    spec.abi_version = leptris_plan_abi_version();
+    spec.plan_count = 1;
+    spec.plans = plans;
+    LeptrisPlan plan = leptris_plan_build(&spec, &st);
+    ASSERT_NE(plan, nullptr);
+
+    /* a SCALAR op IS the row's value (name and binding come from
+     * the plan row) — no ELEMENT wrapper needed for scalar rows */
+    leptris_plan_row_op ops[] = {
+        {LEPTRIS_PLAN_OP_ELEMENT, 0, UINT32_MAX, NULL, NULL, 0},
+        {LEPTRIS_PLAN_OP_ATTR, 0, UINT32_MAX, "id", "7", 1},
+        {LEPTRIS_PLAN_OP_SCALAR, 0, 0, NULL, "first", 5},
+        {LEPTRIS_PLAN_OP_END, 0, UINT32_MAX, NULL, NULL, 0},
+    };
+    LeptrisPlanResult r =
+        leptris_plan_result_build(plan, ops, 4, &st);
+    ASSERT_NE(r, nullptr);
+    char* out = leptris_plan_serialize(plan, r, &st);
+    ASSERT_NE(out, nullptr);
+    EXPECT_STREQ(out, "<b id=\"7\"><p>first</p></b>");
+    leptris_free_string(out);
+    leptris_plan_result_free(r);
+    leptris_plan_free(plan);
+}
+
+TEST(Plan408, ResultBuildRejectsBadPrograms) {
+    LeptrisStatus st = LEPTRIS_OK;
+    leptris_element_plan plans[1] = {};
+    plans[0].element_name = "b";
+    plans[0].ns_form = LEPTRIS_PLAN_NS_ANY;
+    leptris_plan_spec spec = {};
+    spec.abi_version = leptris_plan_abi_version();
+    spec.plan_count = 1;
+    spec.plans = plans;
+    LeptrisPlan plan = leptris_plan_build(&spec, &st);
+    ASSERT_NE(plan, nullptr);
+
+    /* END without an open element */
+    leptris_plan_row_op bad1[] = {
+        {LEPTRIS_PLAN_OP_END, 0, UINT32_MAX, NULL, NULL, 0}};
+    EXPECT_EQ(leptris_plan_result_build(plan, bad1, 1, &st), nullptr);
+    /* unclosed element */
+    leptris_plan_row_op bad2[] = {
+        {LEPTRIS_PLAN_OP_ELEMENT, 0, UINT32_MAX, NULL, NULL, 0}};
+    EXPECT_EQ(leptris_plan_result_build(plan, bad2, 1, &st), nullptr);
+    /* NULL/empty args */
+    EXPECT_EQ(leptris_plan_result_build(NULL, bad2, 1, &st), nullptr);
+    EXPECT_EQ(leptris_plan_result_build(plan, NULL, 0, &st), nullptr);
+    leptris_plan_free(plan);
+}
+
+/* leptris_element_add_child_addr: attach by raw addresses — the
+ * binding's per-node FFI::Pointer mint (#408 ask 1) disappears. */
+TEST(Plan408, AddChildByAddress) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string("<r/>", 4, &st);
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement parent = leptris_document_root(doc);
+    LeptrisElement child = leptris_element_create(doc, "c");
+    ASSERT_NE(child, nullptr);
+    EXPECT_EQ(leptris_element_add_child_addr(
+                  (uintptr_t)parent, (uintptr_t)child),
+              LEPTRIS_OK);
+    EXPECT_EQ(leptris_element_child_count(parent), 1u);
+    LeptrisElement got = leptris_element_first_child_any(parent);
+    ASSERT_NE(got, nullptr);
+    EXPECT_STREQ(leptris_element_name(got), "c");
+    /* NULL-shaped addresses are clean errors */
+    EXPECT_NE(leptris_element_add_child_addr(0, (uintptr_t)child),
+              LEPTRIS_OK);
+    leptris_document_free(doc);
+}
+
+}  // namespace