leptris 1.9.331.0 → 1.9.334.0

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

@@ -36,11 +36,14 @@ struct leptris_xsd_schema {
     XsdElementDecl* elements;
     XsdCm* complex_types; /* name-carrying model roots */
     XsdGroupDef* groups;  /* top-level xs:group definitions */
+    XsdCm* default_open;  /* xs:defaultOpenContent wildcard */
+    int default_oc_empty; /* appliesToEmpty="true" */
     XsdAttrGroupDef* attr_groups;
     XsdAttrDecl* top_attrs; /* top-level xs:attribute declarations */
     XsdTypeAttrs* type_attrs;
     XsdElementIcs* element_ics;
     char* target_ns;
+    int version_11;    /* xs:schema @version = "1.1" */
     char* base_dir;    /* schemaLocation resolution (file compile) */
     int include_depth; /* include/import recursion guard */
     void* validator; /* slice-4 parked error list */
@@ -76,10 +79,18 @@ static char* xsd_read_file(const char* path, size_t* out_len);
 static XsdAttrDecl* xsd_copy_attr_rows(const XsdAttrDecl* src);
 static void xsd_register_complex(struct leptris_xsd_schema* s,
                                  XsdCm* root, XsdAttrDecl* attrs,
-                                 const char* name);
+                                 const char* name,
+                                 char* any_attr_ns);
 static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                                         LeptrisElement ct,
                                         const char* name);
+static XsdAssert* xsd_capture_assert(struct leptris_xsd_schema* s,
+                                     LeptrisElement e);
+static XsdCm* xsd_capture_any(LeptrisElement any_child);
+static char* xsd_capture_any_attr_ns(LeptrisElement container);
+static void xsd_capture_alternatives(struct leptris_xsd_schema* s,
+                                     LeptrisElement decl_elem,
+                                     XsdElementDecl* d);
 static XsdSimple* xsd_capture_simple(LeptrisElement st);
 
 
@@ -95,6 +106,15 @@ static XsdCm* xsd_cm_new(XsdCmKind kind) {
 static void xsd_cm_free(XsdCm* cm) {
     while (cm) {
         XsdCm* next = cm->next;
+        XsdAssert* a = cm->asserts;
+        while (a) {
+            XsdAssert* an = a->next;
+            if (a->compiled) leptris_xquery_free(a->compiled);
+            free(a->test);
+            free(a);
+            a = an;
+        }
+        if (cm->oc_owned && cm->open_any) xsd_cm_free(cm->open_any);
         xsd_cm_free(cm->first_child);
         free(cm->name);
         free(cm->type);
@@ -370,6 +390,9 @@ static XsdSimple* xsd_capture_simple(LeptrisElement st) {
                     simple->fraction_digits = val ? strtol(val, NULL, 10) : -1;
                 else if (strcmp(fl, "whiteSpace") == 0)
                     simple->whitespace = xsd_strdup(val);
+                else if (strcmp(fl, "assertion") == 0)
+                    simple->assertion = xsd_strdup(
+                        leptris_element_attribute(fe, "test"));
             }
         }
     }
@@ -481,6 +504,7 @@ static int xsd_is_declaration(const char* local, const char* uri) {
     static const char* names[] = {
         "element",    "attribute",    "simpleType", "complexType",
         "group",      "attributeGroup", "notation", "include",
+        "defaultOpenContent",
         "import",     "redefine",     NULL
     };
     for (int i = 0; names[i]; i++)
@@ -594,6 +618,10 @@ static LeptrisXsdSchema xsd_compile_impl(const char* xsd_text,
     }
     s->target_ns = xsd_strdup(
         leptris_element_attribute(root, "targetNamespace"));
+    {
+        const char* ver = leptris_element_attribute(root, "version");
+        s->version_11 = (ver && strcmp(ver, "1.1") == 0);
+    }
 
     const char* local = NULL;
     const char* prefix = NULL;
@@ -692,6 +720,7 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                 if (d) {
                     d->name = xsd_strdup(nm);
                     d->type = xsd_strdup(ty);
+                    xsd_capture_alternatives(s, (LeptrisElement)n, d);
                     d->fixed = xsd_strdup(
                         leptris_element_attribute((LeptrisElement)n,
                                                   "fixed"));
@@ -730,6 +759,29 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                 leptris_element_attribute((LeptrisElement)n, "name");
             if (nm)
                 xsd_capture_complex_model(s, (LeptrisElement)n, nm);
+        } else if (strcmp(local, "defaultOpenContent") == 0 && uri &&
+                   !strcmp(uri, XSD_NS)) {
+            if (s->version_11) {
+                const char* ape = leptris_element_attribute(
+                    (LeptrisElement)n, "appliesToEmpty");
+                for (LeptrisNodeRef q = leptris_node_first_child(
+                         leptris_element_as_node((LeptrisElement)n));
+                     q && !s->default_open;
+                     q = leptris_node_next_sibling(q)) {
+                    if (leptris_node_get_type(q) !=
+                        LEPTRIS_NODE_TYPE_ELEMENT)
+                        continue;
+                    LeptrisElement qe = (LeptrisElement)q;
+                    const char* ql = NULL;
+                    leptris_element_expanded_name(qe, &ql, NULL, NULL);
+                    if (ql && strcmp(ql, "any") == 0)
+                        s->default_open = xsd_capture_any(qe);
+                }
+                if (s->default_open)
+                    s->default_oc_empty =
+                        (ape && strcmp(ape, "true") == 0);
+            }
+            continue;
         } else if (strcmp(local, "attribute") == 0 && uri && !strcmp(uri, XSD_NS)) {
             const char* nm =
                 leptris_element_attribute((LeptrisElement)n, "name");
@@ -803,6 +855,8 @@ static void xsd_free_simple_one(XsdSimple* t) {
     free(t->max_inclusive);
     free(t->max_exclusive);
     free(t->whitespace);
+    if (t->assertion_q) leptris_xquery_free(t->assertion_q);
+    free(t->assertion);
     free(t->item_type);
     xsd_free_simple_one(t->item_def);
     for (size_t i = 0; i < t->member_count; i++) free(t->members[i]);
@@ -848,12 +902,22 @@ LEPTRIS_API void leptris_xsd_free(LeptrisXsdSchema schema) {
             a = an;
         }
         free(ta->type_name);
+        free(ta->any_attr_ns);
         free(ta);
         ta = tn;
     }
     XsdElementDecl* d = s->elements;
     while (d) {
         XsdElementDecl* dn = d->next;
+        XsdAlternative* a = d->alternatives;
+        while (a) {
+            XsdAlternative* an = a->next;
+            if (a->compiled) leptris_xquery_free(a->compiled);
+            free(a->test);
+            free(a->type);
+            free(a);
+            a = an;
+        }
         free(d->name);
         free(d->type);
         free(d->fixed);
@@ -894,6 +958,7 @@ LEPTRIS_API void leptris_xsd_free(LeptrisXsdSchema schema) {
         free(g);
         g = gn;
     }
+    if (s->default_open) xsd_cm_free(s->default_open);
     free(s->target_ns);
     free(s->base_dir);
     if (s->validator)
@@ -936,19 +1001,107 @@ static XsdCm* xsd_cm_copy_list(const XsdCm* head) {
 
 static void xsd_register_complex(struct leptris_xsd_schema* s,
                                  XsdCm* root, XsdAttrDecl* attrs,
-                                 const char* name) {
+                                 const char* name,
+                                 char* any_attr_ns) {
     if (!root) return;
     root->name = xsd_strdup(name);
     root->next = s->complex_types;
     s->complex_types = root;
-    if (attrs) {
+    if (attrs || any_attr_ns) {
         XsdTypeAttrs* ta = (XsdTypeAttrs*)calloc(1, sizeof(*ta));
         if (ta) {
             ta->type_name = xsd_strdup(name);
             ta->attrs = attrs;
+            ta->any_attr_ns = any_attr_ns;
             ta->next = s->type_attrs;
             s->type_attrs = ta;
         }
+    } else if (any_attr_ns) {
+        free(any_attr_ns);
+    }
+}
+
+/* XSD 1.1: xs:alternative children of an element declaration. */
+static void xsd_capture_alternatives(struct leptris_xsd_schema* s,
+                                     LeptrisElement decl_elem,
+                                     XsdElementDecl* d) {
+    if (!s->version_11) return;
+    XsdAlternative* tail = NULL;
+    for (LeptrisNodeRef n =
+             leptris_node_first_child(leptris_element_as_node(decl_elem));
+         n; n = leptris_node_next_sibling(n)) {
+        if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
+            continue;
+        LeptrisElement e = (LeptrisElement)n;
+        const char* local = NULL;
+        leptris_element_expanded_name(e, &local, NULL, NULL);
+        if (!local || strcmp(local, "alternative") != 0) continue;
+        const char* test = leptris_element_attribute(e, "test");
+        const char* type = leptris_element_attribute(e, "type");
+        if (!test || !type) continue;
+        XsdAlternative* a = (XsdAlternative*)calloc(1, sizeof(*a));
+        if (!a) continue;
+        a->test = xsd_strdup(test);
+        a->type = xsd_strdup(type);
+        a->compiled = leptris_xquery_parse(test, strlen(test));
+        if (tail)
+            tail->next = a;
+        else
+            d->alternatives = a;
+        tail = a;
+    }
+}
+
+static XsdCm* xsd_capture_any(LeptrisElement any_child) {
+    XsdCm* w = xsd_cm_new(XSD_CM_ANY);
+    if (!w) return NULL;
+    w->any_ns = xsd_strdup(
+        leptris_element_attribute(any_child, "namespace"));
+    const char* pc = leptris_element_attribute(any_child,
+                                               "processContents");
+    w->process_skip =
+        (pc && (strcmp(pc, "skip") == 0 || strcmp(pc, "lax") == 0))
+            ? 1
+            : 0;
+    w->min = 0;
+    w->max = -1;
+    return w;
+}
+
+static XsdAssert* xsd_capture_assert(struct leptris_xsd_schema* s,
+                                     LeptrisElement e) {
+    const char* test = leptris_element_attribute(e, "test");
+    if (!test || !*test) return NULL;
+    XsdAssert* a = (XsdAssert*)calloc(1, sizeof(*a));
+    if (!a) return NULL;
+    a->test = xsd_strdup(test);
+    if (s->version_11) {
+        a->compiled = leptris_xquery_parse(test, strlen(test));
+        /* NULL = syntax error: evaluation reports the assertion
+         * as failed (XSD 1.1: an error is a failure) */
+    }
+    return a;
+}
+
+/* Append every xs:assert child under `container` to the type. */
+static void xsd_capture_assert_children(
+    struct leptris_xsd_schema* s, LeptrisElement container,
+    XsdCm* root) {
+    XsdAssert* tail = root->asserts;
+    while (tail && tail->next) tail = tail->next;
+    for (LeptrisNodeRef n =
+             leptris_node_first_child(leptris_element_as_node(container));
+         n; n = leptris_node_next_sibling(n)) {
+        if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
+            continue;
+        LeptrisElement e = (LeptrisElement)n;
+        const char* local = NULL;
+        leptris_element_expanded_name(e, &local, NULL, NULL);
+        if (!local || strcmp(local, "assert") != 0) continue;
+        XsdAssert* a = xsd_capture_assert(s, e);
+        if (!a) continue;
+        if (!root->asserts) root->asserts = a;
+        tail = a;
     }
 }
 
@@ -962,6 +1115,7 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
     XsdCm* root = xsd_cm_new(XSD_CM_SEQ); /* wrapper keeps the name */
     if (!root) return NULL;
     XsdAttrDecl* attrs = NULL;
+    char* any_attr_ns = NULL;
 
     for (LeptrisNodeRef n =
              leptris_node_first_child(leptris_element_as_node(ct));
@@ -1026,6 +1180,11 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                     root->first_child = xsd_cm_parse(s, dq, NULL);
                     attrs = xsd_capture_attr_rows(s, dq, 0);
                 }
+                /* XSD 1.1: asserts nested under the derivation */
+                if (s->version_11)
+                    xsd_capture_assert_children(s, dq, root);
+                if (!any_attr_ns)
+                    any_attr_ns = xsd_capture_any_attr_ns(dq);
             }
         } else if (strcmp(local, "simpleContent") == 0) {
             for (LeptrisNodeRef q = leptris_node_first_child(
@@ -1092,7 +1251,52 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
          * re-capturing would orphan those rows. */
         root->first_child = xsd_cm_parse(s, ct, NULL);
         if (!attrs) attrs = xsd_capture_attr_rows(s, ct, 0);
+        if (!any_attr_ns) any_attr_ns = xsd_capture_any_attr_ns(ct);
     }
+    /* XSD 1.1: openContent on the type, else the schema default */
+    if (s->version_11) {
+        for (LeptrisNodeRef n =
+                 leptris_node_first_child(leptris_element_as_node(ct));
+             n; n = leptris_node_next_sibling(n)) {
+            if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
+                continue;
+            LeptrisElement e = (LeptrisElement)n;
+            const char* ocl = NULL;
+            leptris_element_expanded_name(e, &ocl, NULL, NULL);
+            if (!ocl || strcmp(ocl, "openContent") != 0) continue;
+            const char* mode = leptris_element_attribute(e, "mode");
+            for (LeptrisNodeRef q = leptris_node_first_child(
+                     leptris_element_as_node(e));
+                 q && !root->open_any;
+                 q = leptris_node_next_sibling(q)) {
+                if (leptris_node_get_type(q) !=
+                    LEPTRIS_NODE_TYPE_ELEMENT)
+                    continue;
+                LeptrisElement qe = (LeptrisElement)q;
+                const char* ql = NULL;
+                leptris_element_expanded_name(qe, &ql, NULL, NULL);
+                if (ql && strcmp(ql, "any") == 0) {
+                    root->open_any = xsd_capture_any(qe);
+                    if (root->open_any) root->oc_owned = 1;
+                }
+            }
+            if (mode && strcmp(mode, "suffix") == 0)
+                root->oc_mode = 1;
+            else if (mode && strcmp(mode, "interleave") == 0)
+                root->oc_mode = 2;
+            else
+                root->oc_mode = 0;
+        }
+    }
+    if (!root->oc_mode && s->default_open && root->first_child)
+        root->oc_mode = 2;
+    if (!root->oc_mode && s->default_open && !root->first_child &&
+        s->default_oc_empty)
+        root->oc_mode = 2;
+    if (root->oc_mode == 2 && !root->open_any && s->default_open)
+        root->open_any = s->default_open;
+    /* XSD 1.1: direct xs:assert children of the complexType */
+    if (s->version_11) xsd_capture_assert_children(s, ct, root);
     /* the NFA and model walkers consume ONE root particle —
      * a multi-particle model (derivation splices) normalizes
      * under a sequence */
@@ -1103,7 +1307,19 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
             root->first_child = seq;
         }
     }
-    xsd_register_complex(s, root, attrs, name);
+    /* open-content semantics ride the model root (the NFA builds
+     * from ct->first_child, never the name wrapper) */
+    if (root->first_child) {
+        root->first_child->open_any = root->open_any;
+        root->first_child->oc_mode = root->oc_mode;
+        root->first_child->oc_owned = root->oc_owned;
+        root->open_any = NULL;
+        root->oc_owned = 0;
+    } else if (root->open_any && root->oc_owned) {
+        xsd_cm_free(root->open_any);
+        root->open_any = NULL;
+    }
+    xsd_register_complex(s, root, attrs, name, any_attr_ns);
     return root;
 }
 
@@ -1124,6 +1340,10 @@ int xsd_is_substitute(struct leptris_xsd_schema* s,
     return 0;
 }
 
+int xsd_schema_version_11(struct leptris_xsd_schema* s) {
+    return s ? s->version_11 : 0;
+}
+
 XsdGroupDef* xsd_find_group(struct leptris_xsd_schema* s,
                             const char* name) {
     if (!s || !name) return NULL;
@@ -1265,6 +1485,23 @@ static XsdAttrDecl* xsd_capture_attr_rows(struct leptris_xsd_schema* s,
     return head;
 }
 
+/* One container's xs:anyAttribute grammar (NULL when absent). */
+static char* xsd_capture_any_attr_ns(LeptrisElement container) {
+    for (LeptrisNodeRef ac = leptris_node_first_child(
+             leptris_element_as_node(container));
+         ac; ac = leptris_node_next_sibling(ac)) {
+        if (leptris_node_get_type(ac) != LEPTRIS_NODE_TYPE_ELEMENT)
+            continue;
+        LeptrisElement ae = (LeptrisElement)ac;
+        const char* al = NULL;
+        leptris_element_expanded_name(ae, &al, NULL, NULL);
+        if (al && strcmp(al, "anyAttribute") == 0)
+            return xsd_strdup(
+                leptris_element_attribute(ae, "namespace"));
+    }
+    return NULL;
+}
+
 LEPTRIS_API int leptris_xsd_builtin_valid(const char* builtin,
                                           const char* lexical) {
     extern int xsd_builtin_valid(const char* type, const char* v);

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

@@ -56,20 +56,35 @@ static void cm_build_occurrence(CmNfa* n, XsdCm* node,
 /* 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). */
+/* XSD 1.1 open content: a wildcard self-loop at a junction lets
+ * any-namespace elements (per the wildcard's grammar) consume a
+ * child without advancing the model. */
+static void oc_loop(CmNfa* n, XsdCm* node, int state) {
+    if (!node->open_any || !node->oc_mode) return;
+    nfa_trans(n, state, 0, node->open_any, state);
+}
+
 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 interleave =
+        (node->open_any && node->oc_mode == 2) ? 1 : 0;
     int cursor = from;
+    if (interleave) oc_loop(n, node, cursor);
     while (c->next) {
         int mid = nfa_state(n);
         cm_build_occurrence(n, c, cursor, mid);
         cursor = mid;
+        if (interleave) oc_loop(n, node, cursor);
         c = c->next;
     }
     cm_build_occurrence(n, c, cursor, to);
+    /* suffix (and interleave) wildcards may follow the sequence */
+    if (node->open_any && node->oc_mode)
+        oc_loop(n, node, to);
 }
 
 static void cm_build(CmNfa* n, XsdCm* node, int from, int to) {
@@ -193,10 +208,45 @@ static void ss_close(StateSet* ss, CmNfa* n) {
     }
 }
 
+/* XSD xs:all at the model root: order-free, each particle at
+ * most maxOccurs times, minOccurs floors — a counting check over
+ * the particle list (XSD 1.0 restricts xs:all to the model root,
+ * each child a particle, maxOccurs <= 1). */
+static int all_root_valid(XsdCm* all, const char* target_ns,
+                          const char* const* names,
+                          const char* const* ns_uris, size_t count) {
+    for (XsdCm* p = all->first_child; p; p = p->next) {
+        size_t hits = 0;
+        for (size_t i = 0; i < count; i++) {
+            const char* uri = ns_uris ? ns_uris[i] : NULL;
+            if (p->name && strcmp(p->name, names[i]) == 0 &&
+                (!p->ns || (uri && strcmp(uri, p->ns) == 0)))
+                hits++;
+        }
+        if ((long)hits < p->min) return 0;
+        if (p->max >= 0 && (long)hits > p->max) return 0;
+    }
+    /* every instance child must belong to a particle */
+    for (size_t i = 0; i < count; i++) {
+        int matched = 0;
+        const char* uri = ns_uris ? ns_uris[i] : NULL;
+        for (XsdCm* p = all->first_child; p && !matched; p = p->next) {
+            if (p->name && strcmp(p->name, names[i]) == 0 &&
+                (!p->ns || (uri && strcmp(uri, p->ns) == 0)))
+                matched = 1;
+        }
+        if (!matched) return 0;
+    }
+    (void)target_ns;
+    return 1;
+}
+
 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) {
     if (!model) return -1;
+    if (model->kind == XSD_CM_ALL && model->first_child)
+        return all_root_valid(model, target_ns, names, ns_uris, count);
     CmNfa n;
     memset(&n, 0, sizeof(n));
     n.s = s;