leptris 1.9.320.0-arm-linux → 1.9.321.0-arm-linux

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

@@ -0,0 +1,232 @@
+/* xsd/content_model.c — #1075 slice 3: content-model evaluation.
+ *
+ * The compiled model tree lowers into a Thompson NFA (epsilon +
+ * symbol transitions, occurrence bounds via counting copies and a
+ * loop for unbounded) and the child sequence is consumed by
+ * simulating the live state set — linear in children x states, no
+ * backtracking blowup on nested choices.
+ *
+ * Namespace filters (xs:any/@namespace): "##any" (default),
+ * "##other" (not the target namespace, not unqualified),
+ * "##targetNamespace", "##local", or a space-separated URI list.
+ */
+#include <stdlib.h>
+#include <string.h>
+
+#include "xsd_internal.h"
+
+typedef struct {
+    int from;
+    int symbol;      /* -1 = epsilon; else a particle transition */
+    XsdCm* particle; /* symbol owner (element ref or wildcard) */
+    int to;
+} CmTrans;
+
+typedef struct {
+    CmTrans* trans;
+    size_t count, cap;
+    int state_count; /* explicit: state ids are NOT transition ids */
+    int start, accept;
+} CmNfa;
+
+static int nfa_state(CmNfa* n) { return n->state_count++; }
+
+static void nfa_trans(CmNfa* n, int from, int symbol, XsdCm* particle,
+                      int to) {
+    if (n->count == n->cap) {
+        size_t cap = n->cap ? n->cap * 2 : 16;
+        CmTrans* grown = (CmTrans*)realloc(n->trans, cap * sizeof(*grown));
+        if (!grown) return; /* OOM: walk treats the NFA as non-matching */
+        n->trans = grown;
+        n->cap = cap;
+    }
+    n->trans[n->count].from = from;
+    n->trans[n->count].symbol = symbol;
+    n->trans[n->count].particle = particle;
+    n->trans[n->count].to = to;
+    n->count++;
+}
+
+static void cm_build(CmNfa* n, XsdCm* node, int from, int to);
+static void cm_build_occurrence(CmNfa* n, XsdCm* node,
+                               int from, int to);
+
+/* chain the group children: first reads `from`, last writes `to`.
+ * xs:all is evaluated in sequence order for now (its order-free
+ * semantics arrive with slice 4's all-semantics pass). */
+static void cm_build_children(CmNfa* n, XsdCm* node, int from, int to) {
+    XsdCm* c = node->first_child;
+    if (!c) {
+        nfa_trans(n, from, -1, NULL, to);
+        return;
+    }
+    int cursor = from;
+    while (c->next) {
+        int mid = nfa_state(n);
+        cm_build_occurrence(n, c, cursor, mid);
+        cursor = mid;
+        c = c->next;
+    }
+    cm_build_occurrence(n, c, cursor, to);
+}
+
+static void cm_build(CmNfa* n, XsdCm* node, int from, int to) {
+    switch (node->kind) {
+        case XSD_CM_ELEMENT:
+        case XSD_CM_ANY:
+            nfa_trans(n, from, 0, node, to);
+            return;
+        case XSD_CM_SEQ:
+        case XSD_CM_ALL:
+            cm_build_children(n, node, from, to);
+            return;
+        case XSD_CM_CHOICE: {
+            XsdCm* c = node->first_child;
+            if (!c) {
+                nfa_trans(n, from, -1, NULL, to);
+                return;
+            }
+            for (; c; c = c->next) cm_build_occurrence(n, c, from, to);
+            return;
+        }
+    }
+}
+
+/* occurrence bounds: min copies, then (max-min) optionals, or an
+ * epsilon self-loop region for unbounded. */
+static void cm_build_occurrence(CmNfa* n, XsdCm* node, int from, int to) {
+    for (int i = 0; i < node->min; i++) {
+        int mid = nfa_state(n);
+        cm_build(n, node, from, mid);
+        from = mid;
+    }
+    if (node->max < 0) {
+        int loop = nfa_state(n);
+        nfa_trans(n, from, -1, NULL, loop);
+        cm_build(n, node, loop, loop);
+        nfa_trans(n, loop, -1, NULL, to);
+        return;
+    }
+    for (int i = node->min; i < node->max; i++) {
+        nfa_trans(n, from, -1, NULL, to);
+        int mid = nfa_state(n);
+        cm_build(n, node, from, mid);
+        from = mid;
+    }
+    nfa_trans(n, from, -1, NULL, to);
+}
+
+/* ---- namespace filter (xs:any/@namespace) ------------------------ */
+
+static int any_ns_matches(XsdCm* any, const char* uri,
+                          const char* target_ns) {
+    const char* f = any->any_ns ? any->any_ns : "##any";
+    if (strcmp(f, "##any") == 0) return 1;
+    if (strcmp(f, "##local") == 0) return uri == NULL;
+    if (strcmp(f, "##targetNamespace") == 0)
+        return target_ns && uri && strcmp(uri, target_ns) == 0;
+    if (strcmp(f, "##other") == 0)
+        return uri != NULL &&
+               !(target_ns && strcmp(uri, target_ns) == 0);
+    /* space-separated URI list (+##local) */
+    const char* p = f;
+    while (*p) {
+        while (*p == ' ') p++;
+        const char* start = p;
+        while (*p && *p != ' ') p++;
+        size_t len = (size_t)(p - start);
+        if (len == 0) break;
+        if (strncmp(start, "##local", len) == 0 && len == 7) {
+            if (uri == NULL) return 1;
+            continue;
+        }
+        if (uri && strlen(uri) == len && strncmp(start, uri, len) == 0)
+            return 1;
+    }
+    return 0;
+}
+
+/* ---- simulation --------------------------------------------------- */
+
+typedef struct {
+    int* states;
+    size_t count, cap;
+} StateSet;
+
+static void ss_add(StateSet* ss, int st) {
+    for (size_t i = 0; i < ss->count; i++)
+        if (ss->states[i] == st) return;
+    if (ss->count == ss->cap) {
+        size_t cap = ss->cap ? ss->cap * 2 : 16;
+        int* grown = (int*)realloc(ss->states, cap * sizeof(int));
+        if (!grown) return;
+        ss->states = grown;
+        ss->cap = cap;
+    }
+    ss->states[ss->count++] = st;
+}
+
+static void ss_close(StateSet* ss, CmNfa* n) {
+    /* fixpoint over epsilon edges */
+    size_t i = 0;
+    while (i < ss->count) {
+        int st = ss->states[i];
+        for (size_t t = 0; t < n->count; t++)
+            if (n->trans[t].from == st && n->trans[t].symbol == -1)
+                ss_add(ss, n->trans[t].to);
+        i++;
+    }
+}
+
+int xsd_content_valid(struct leptris_xsd_schema* s, XsdCm* model,
+                      const char* target_ns, const char* const* names,
+                      const char* const* ns_uris, size_t count) {
+    (void)s;
+    if (!model) return -1;
+    CmNfa n;
+    memset(&n, 0, sizeof(n));
+    n.start = nfa_state(&n);
+    n.accept = nfa_state(&n);
+    cm_build_occurrence(&n, model, n.start, n.accept);
+
+    StateSet live;
+    memset(&live, 0, sizeof(live));
+    ss_add(&live, n.start);
+    ss_close(&live, &n);
+
+    for (size_t c = 0; c < count; c++) {
+        StateSet next;
+        memset(&next, 0, sizeof(next));
+        const char* uri = ns_uris ? ns_uris[c] : NULL;
+        for (size_t i = 0; i < live.count; i++) {
+            for (size_t t = 0; t < n.count; t++) {
+                CmTrans* tr = &n.trans[t];
+                if (tr->from != live.states[i] || tr->symbol == -1)
+                    continue;
+                XsdCm* p = tr->particle;
+                if (p->kind == XSD_CM_ELEMENT) {
+                    if (strcmp(p->name, names[c]) == 0 &&
+                        (!p->ns || (uri && strcmp(uri, p->ns) == 0)))
+                        ss_add(&next, tr->to);
+                } else if (p->kind == XSD_CM_ANY) {
+                    if (any_ns_matches(p, uri, target_ns))
+                        ss_add(&next, tr->to);
+                }
+            }
+        }
+        free(live.states);
+        live = next;
+        ss_close(&live, &n);
+        if (live.count == 0) {
+            free(n.trans);
+            return 0;
+        }
+    }
+
+    int accept = 0;
+    for (size_t i = 0; i < live.count; i++)
+        if (live.states[i] == n.accept) accept = 1;
+    free(live.states);
+    free(n.trans);
+    return accept;
+}

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

@@ -0,0 +1,287 @@
+/* xsd/validate.c — #1075 slice 4: instance-document validation.
+ *
+ * Walks an instance tree against the compiled schema: element
+ * declarations resolve by local name (global declarations), their
+ * types drive attribute checking (declared rows, required use),
+ * text-content lexical checks (builtins + user simpleTypes), and
+ * child-sequence content-model checks (slice 3's NFA). Failures
+ * accumulate in the schema-owned error list — the RNG accessor
+ * pattern: validate returns 1/0, errors enumerate every miss.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../include/leptris.h"
+#include "xsd_internal.h"
+
+extern int xsd_content_valid(struct leptris_xsd_schema* s, XsdCm* model,
+                             const char* target_ns,
+                             const char* const* names,
+                             const char* const* ns_uris, size_t count);
+extern int xsd_builtin_valid(const char* type, const char* v);
+extern int xsd_simple_valid(const XsdSimple* simple, const char* v);
+
+struct xsd_error {
+    char* text;
+    struct xsd_error* next;
+};
+
+struct leptris_xsd_schema; /* opaque here; compile.c owns the struct */
+
+/* The validator reaches the compiled model through accessors the
+ * compiler exports (compile.c defines the struct). */
+extern const XsdElementDecl* xsd_find_element(
+    struct leptris_xsd_schema* s, const char* name);
+extern XsdCm* xsd_find_complex(struct leptris_xsd_schema* s,
+                               const char* type_name);
+extern const XsdSimple* xsd_find_simple_pub(
+    struct leptris_xsd_schema* s, const char* name);
+extern const char* xsd_target_ns(struct leptris_xsd_schema* s);
+extern const XsdTypeAttrs* xsd_find_type_attrs(
+    struct leptris_xsd_schema* s, const char* type_name);
+
+/* ---- error list ---------------------------------------------------- */
+
+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;
+    struct xsd_error* errors;
+    struct xsd_error* tail;
+    size_t count;
+};
+
+static void verr_push(struct xsd_validator* v, const char* msg) {
+    struct xsd_error* e = (struct xsd_error*)malloc(sizeof(*e));
+    if (!e) return;
+    size_t n = strlen(msg) + 1;
+    e->text = (char*)malloc(n);
+    if (!e->text) {
+        free(e);
+        return;
+    }
+    memcpy(e->text, msg, n);
+    e->next = NULL;
+    if (v->tail)
+        v->tail->next = e;
+    else
+        v->errors = e;
+    v->tail = e;
+    v->count++;
+}
+
+static void verrf(struct xsd_validator* v, const char* what,
+                  const char* name, const char* detail) {
+    /* "element 'x': detail" — bounded composition */
+    char buf[256];
+    int w = snprintf(buf, sizeof(buf), "%s '%s': %s", what,
+                     name ? name : "?", detail ? detail : "invalid");
+    (void)w;
+    verr_push(v, buf);
+}
+
+/* ---- lexical helpers ---------------------------------------------- */
+
+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) {
+    if (!type) return 1;
+    int r;
+    if (strncmp(type, "xs:", 3) == 0)
+        r = xsd_builtin_valid(type, lexical);
+    else {
+        const XsdSimple* st = xsd_find_simple_pub(s, type);
+        if (!st) return 1; /* unresolved: accept */
+        r = xsd_simple_valid(st, lexical);
+    }
+    if (r == 0) {
+        verrf(v, what, name, "lexical value does not match its type");
+        return 0;
+    }
+    return 1;
+}
+
+/* One element: attributes, text, children. */
+static void validate_element(struct xsd_validator* v,
+                             struct leptris_xsd_schema* s,
+                             LeptrisElement elem, int depth);
+
+static void validate_children(struct xsd_validator* v,
+                              struct leptris_xsd_schema* s,
+                              LeptrisElement elem, XsdCm* ct) {
+    XsdCm* model = ct->first_child;
+    if (!model) return;
+    /* collect child names + uris */
+    size_t n = 0;
+    for (LeptrisNodeRef c =
+             leptris_node_first_child(leptris_element_as_node(elem));
+         c; c = leptris_node_next_sibling(c))
+        if (leptris_node_get_type(c) == LEPTRIS_NODE_TYPE_ELEMENT) n++;
+    if (!n) return;
+    const char** names = (const char**)malloc(n * sizeof(char*));
+    const char** uris = (const char**)calloc(n, sizeof(char*));
+    if (!names || !uris) {
+        free(names);
+        free(uris);
+        return;
+    }
+    size_t i = 0;
+    for (LeptrisNodeRef c =
+             leptris_node_first_child(leptris_element_as_node(elem));
+         c; c = leptris_node_next_sibling(c)) {
+        if (leptris_node_get_type(c) != LEPTRIS_NODE_TYPE_ELEMENT)
+            continue;
+        LeptrisElement ce = (LeptrisElement)c;
+        const char* local = NULL, *prefix = NULL, *uri = NULL;
+        leptris_element_expanded_name(ce, &local, &prefix, &uri);
+        names[i] = local ? local : "";
+        uris[i] = uri;
+        i++;
+    }
+    int ok = xsd_content_valid(s, model, xsd_target_ns(s), names, uris,
+                               n);
+    free(names);
+    free(uris);
+    if (!ok) {
+        const char* local = NULL;
+        leptris_element_expanded_name(elem, &local, NULL, NULL);
+        verrf(v, "element", local, "children do not match the content model");
+    }
+    /* recurse; local particles carry types (first-name-match DFS —
+     * position-exact particle typing arrives with the NFA trace). */
+    for (LeptrisNodeRef c =
+             leptris_node_first_child(leptris_element_as_node(elem));
+         c; c = leptris_node_next_sibling(c)) {
+        LeptrisElement ce = (LeptrisElement)c;
+        const char* cl = NULL, *cp = NULL, *cu = NULL;
+        leptris_element_expanded_name(ce, &cl, &cp, &cu);
+        if (cl && !xsd_find_element(s, cl) && model) {
+            const char* ptype = NULL;
+            XsdCm* stack[64];
+            int sp = 0;
+            stack[sp++] = model;
+            while (sp > 0 && ptype == NULL) {
+                XsdCm* p = stack[--sp];
+                for (; p; p = p->next) {
+                    if (p->kind == XSD_CM_ELEMENT && p->name &&
+                        strcmp(p->name, cl) == 0 && p->type) {
+                        ptype = p->type;
+                        break;
+                    }
+                    if (sp < 64 && p->first_child)
+                        stack[sp++] = p->first_child;
+                }
+            }
+            if (ptype) {
+                const char* text = leptris_element_text(ce);
+                if (text && *text)
+                    text_valid(v, s, ptype, text, "element", cl);
+            }
+        }
+        if (leptris_node_get_type(c) != LEPTRIS_NODE_TYPE_ELEMENT)
+            continue;
+        validate_element(v, s, ce, 0);
+    }
+}
+
+static void validate_attributes(struct xsd_validator* v,
+                                struct leptris_xsd_schema* s,
+                                LeptrisElement elem,
+                                const XsdTypeAttrs* ta) {
+    if (!ta) return;
+    /* declared rows: present? value typed? */
+    for (XsdAttrDecl* a = ta->attrs; a; a = a->next) {
+        const char* val = leptris_element_attribute(elem, a->name);
+        if (!val) {
+            /* lenient: the qualified spelling (#1586 semantics) */
+            for (LeptrisAttribute at =
+                     leptris_element_first_attribute(elem);
+                 at; at = leptris_attribute_next(at)) {
+                const char* qn = leptris_attribute_get_name(at);
+                const char* colon = qn ? strchr(qn, ':') : NULL;
+                if (qn && colon && strcmp(colon + 1, a->name) == 0) {
+                    val = leptris_attribute_get_value(elem, at);
+                    break;
+                }
+                if (qn && !colon && strcmp(qn, a->name) == 0) {
+                    val = leptris_attribute_get_value(elem, at);
+                    break;
+                }
+            }
+        }
+        if (!val) {
+            if (a->required)
+                verrf(v, "attribute", a->name, "required but absent");
+            continue;
+        }
+        text_valid(v, s, a->type, val, "attribute", a->name);
+    }
+}
+
+static void validate_element(struct xsd_validator* v,
+                             struct leptris_xsd_schema* s,
+                             LeptrisElement elem, int depth) {
+    if (depth > 64) return;
+    const char* local = NULL, *prefix = NULL, *uri = NULL;
+    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->type) return; /* anyType */
+
+    XsdCm* ct = xsd_find_complex(s, d->type);
+    if (ct) {
+        validate_attributes(v, s, elem, xsd_find_type_attrs(s, d->type));
+        validate_children(v, s, elem, ct);
+        return;
+    }
+
+    /* simple-typed element: text must be lexically valid */
+    if (strncmp(d->type, "xs:", 3) == 0 ||
+        xsd_find_simple_pub(s, d->type)) {
+        const char* text = leptris_element_text(elem);
+        if (text && *text)
+            text_valid(v, s, d->type, text, "element", local);
+    }
+}
+
+struct xsd_validator* xsd_validator_new(struct leptris_xsd_schema* s) {
+    struct xsd_validator* v =
+        (struct xsd_validator*)calloc(1, sizeof(*v));
+    if (v) v->s = s;
+    return v;
+}
+
+void xsd_validator_free(struct xsd_validator* v) {
+    if (!v) return;
+    struct xsd_error* e = v->errors;
+    while (e) {
+        struct xsd_error* n = e->next;
+        free(e->text);
+        free(e);
+        e = n;
+    }
+    free(v);
+}
+
+int xsd_validator_run(struct xsd_validator* v, LeptrisDocument doc) {
+    if (!v || !doc) return -1;
+    LeptrisElement root = leptris_document_root(doc);
+    if (!root) return -1;
+    validate_element(v, v->s, root, 0);
+    return v->count == 0 ? 1 : 0;
+}
+
+size_t xsd_validator_error_count(struct xsd_validator* v) {
+    return v ? v->count : 0;
+}
+
+const char* xsd_validator_error_at(struct xsd_validator* v, size_t i) {
+    if (!v) return NULL;
+    struct xsd_error* e = v->errors;
+    for (size_t k = 0; e && k < i; k++) e = e->next;
+    return e ? e->text : NULL;
+}

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

@@ -37,7 +37,55 @@ typedef struct xsd_simple {
     struct xsd_simple* next;
 } XsdSimple;
 
+/* Content-model node: a particle (element ref / wildcard) or a
+ * group (sequence | choice | all). Owned by the schema; freed
+ * with the schema. */
+typedef enum {
+    XSD_CM_ELEMENT = 0,
+    XSD_CM_ANY,
+    XSD_CM_SEQ,
+    XSD_CM_CHOICE,
+    XSD_CM_ALL
+} XsdCmKind;
+
+typedef struct xsd_cm {
+    XsdCmKind kind;
+    char* name;   /* CM_ELEMENT: child element local name */
+    char* type;   /* CM_ELEMENT: the particle's type ref, if any */
+    char* ns;     /* CM_ELEMENT: expected namespace (NULL = unqualified) */
+    char* any_ns; /* CM_ANY: the namespace attribute grammar */
+    int process_skip; /* CM_ANY: processContents="skip" or "lax" */
+    int min, max; /* occurrence bounds; max < 0 = unbounded */
+    struct xsd_cm* first_child; /* group children list */
+    struct xsd_cm* next;        /* sibling link within the parent group */
+} XsdCm;
+
+/* 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 */
+    struct xsd_element_decl* next;
+} XsdElementDecl;
+
+typedef struct xsd_attr_decl {
+    char* name;  /* attribute local name */
+    char* type;  /* builtin ref or local simpleType name (NULL=anySimple) */
+    int required;
+    struct xsd_attr_decl* next;
+} XsdAttrDecl;
+
+/* complexType name -> its attribute declarations (hash-free: a
+ * parallel list keyed the same way as complex model roots). */
+typedef struct xsd_type_attrs {
+    char* type_name;
+    XsdAttrDecl* attrs;
+    struct xsd_type_attrs* next;
+} XsdTypeAttrs;
+
 #ifdef __cplusplus
 }
 #endif
+
+/* ---- slice 4: attribute declarations + instance validation ------- */
+
 #endif /* LEPTRIS_XSD_INTERNAL_H */