Lines Matching defs:node
42 #define IS_RELAXNG(node, type) \
43 ((node != NULL) && (node->ns != NULL) && \
44 (xmlStrEqual(node->name, (const xmlChar *) type)) && \
45 (xmlStrEqual(node->ns->href, xmlRelaxNGNs)))
155 xmlNodePtr node; /* the node in the source */
301 xmlNodePtr node; /* the current node */
336 xmlNodePtr node; /* the current node */
387 xmlNodePtr pnode; /* the current node */
499 * @node: the node raising the error
508 xmlRngPErr(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node, int error,
524 NULL, node, XML_FROM_RELAXNGP,
533 * @node: the node raising the error
542 xmlRngVErr(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node, int error,
558 NULL, node, XML_FROM_RELAXNGV,
595 xmlNodePtr node);
881 * @node: the node in the input document.
888 xmlRelaxNGNewDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
922 ret->node = node;
1173 * @node: the current node or NULL for the document
1180 xmlRelaxNGNewValidState(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node)
1188 if (node == NULL) {
1193 attr = node->properties;
1217 if (node == NULL) {
1218 ret->node = (xmlNodePtr) ctxt->doc;
1221 ret->node = node;
1222 ret->seq = node->children;
1253 attr = node->properties;
1352 if (state1->node != state2->node)
1582 * @node: the include node.
1593 xmlNodePtr node, const xmlChar * ns)
1622 xmlRngPErr(ctxt, node, XML_RNGP_PARSE_ERROR,
1689 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY,
1695 xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
1704 cur = node->children;
1712 xmlRngPErr(ctxt, node, XML_RNGP_START_MISSING,
1721 xmlRngPErr(ctxt, node, XML_RNGP_NAME_MISSING,
1731 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_MISSING,
1795 (ctxt->err->node == ctxt->state->node) && (ctxt->err->err == err))
1809 cur->node = ctxt->state->node;
1812 cur->node = NULL;
2221 * @node: the node
2222 * @child: the node child generating the problem.
2230 xmlRelaxNGValidErr err, xmlNodePtr node,
2248 xmlRngVErr(ctxt, (child == NULL ? node : child), err,
2308 if ((err->err == dup->err) && (err->node == dup->node) &&
2314 xmlRelaxNGShowValidError(ctxt, err->err, err->node, err->seq,
2361 xmlNodePtr node, seq;
2370 node = ctxt->state->node;
2373 node = seq = NULL;
2375 xmlRelaxNGShowValidError(ctxt, err, node, seq, arg1, arg2);
2424 * @node: the node
2435 void **result, xmlNodePtr node)
2448 (xmlSchemaValPtr *) result, node);
2637 * @node: the node
2649 xmlNodePtr node ATTRIBUTE_UNUSED)
3303 ctxt, xmlNodePtr node);
3305 ctxt, xmlNodePtr node);
3310 ctxt, xmlNodePtr node);
3312 xmlNodePtr node);
3316 ctxt, xmlNodePtr node,
3431 * @node: the current data or value element
3439 xmlNodePtr node)
3443 if ((IS_RELAXNG(node, "data")) || (IS_RELAXNG(node, "value"))) {
3444 ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
3458 node = node->parent;
3459 while ((node != NULL) && (node->type == XML_ELEMENT_NODE)) {
3460 ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
3473 node = node->parent;
3481 * @node: the data node.
3483 * parse the content of a RelaxNG value node.
3488 xmlRelaxNGParseValue(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
3496 def = xmlRelaxNGNewDefine(ctxt, node);
3501 type = xmlGetProp(node, BAD_CAST "type");
3505 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
3508 library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
3519 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
3526 xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
3532 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
3539 if (node->children == NULL) {
3541 } else if (((node->children->type != XML_TEXT_NODE) &&
3542 (node->children->type != XML_CDATA_SECTION_NODE)) ||
3543 (node->children->next != NULL)) {
3544 xmlRngPErr(ctxt, node, XML_RNGP_TEXT_EXPECTED,
3548 def->value = xmlNodeGetContent(node);
3550 xmlRngPErr(ctxt, node, XML_RNGP_VALUE_NO_CONTENT,
3556 lib->check(lib->data, def->name, def->value, &val, node);
3558 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_VALUE,
3573 * @node: the data node.
3575 * parse the content of a RelaxNG data node.
3580 xmlRelaxNGParseData(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
3590 type = xmlGetProp(node, BAD_CAST "type");
3592 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_MISSING, "data has no type\n", NULL,
3598 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
3601 library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
3606 def = xmlRelaxNGNewDefine(ctxt, node);
3618 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
3625 xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
3631 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
3645 content = node->children;
3655 xmlRngPErr(ctxt, node, XML_RNGP_PARAM_FORBIDDEN,
3663 param = xmlRelaxNGNewDefine(ctxt, node);
3668 xmlRngPErr(ctxt, node, XML_RNGP_PARAM_NAME_MISSING,
3692 except = xmlRelaxNGNewDefine(ctxt, node);
3749 xmlNode node;
3762 node.name = def1->name;
3764 node.name = invalidName;
3768 node.ns = NULL;
3770 node.ns = &ns;
3774 node.ns = NULL;
3776 if (xmlRelaxNGElementMatch(&ctxt, def2, &node)) {
3799 node.name = def2->name;
3801 node.name = invalidName;
3803 node.ns = &ns;
3806 node.ns = NULL;
3813 if (xmlRelaxNGElementMatch(&ctxt, def1, &node)) {
4245 xmlRngPErr(ctxt, def->node, XML_RNGP_GROUP_ATTR_CONFLICT,
4351 xmlRngPErr(ctxt, def->node, XML_RNGP_ELEM_TEXT_CONFLICT,
4358 xmlRngPErr(ctxt, def->node, XML_RNGP_ATTR_CONFLICT,
4437 * @node: the data node.
4439 * parse the content of a RelaxNG interleave node.
4444 xmlRelaxNGParseInterleave(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4450 def = xmlRelaxNGNewDefine(ctxt, node);
4465 xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_ADD,
4470 child = node->children;
4472 xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_NO_CONTENT,
4499 * @node: the include node
4501 * Integrate the content of an include node in the current grammar
4506 xmlRelaxNGParseInclude(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4512 incl = node->psvi;
4514 xmlRngPErr(ctxt, node, XML_RNGP_INCLUDE_EMPTY,
4515 "Include node has no data\n", NULL, NULL);
4520 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY, "Include document is empty\n",
4525 xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
4538 if (node->children != NULL) {
4539 tmp = xmlRelaxNGParseGrammarContent(ctxt, node->children);
4549 * @node: the define node
4551 * parse the content of a RelaxNG define element node.
4556 xmlRelaxNGParseDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4563 name = xmlGetProp(node, BAD_CAST "name");
4565 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_NAME_MISSING,
4570 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_DEFINE_NAME,
4573 def = xmlRelaxNGNewDefine(ctxt, node);
4580 if (node->children == NULL) {
4581 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_EMPTY,
4587 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4593 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
4603 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
4621 * @node: the externlRef node
4623 * Process and compile an externlRef node
4628 xmlRelaxNGProcessExternalRef(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4636 docu = node->psvi;
4638 def = xmlRelaxNGNewDefine(ctxt, node);
4649 xmlRngPErr(ctxt, node, XML_RNGP_EXTERNALREF_EMTPY,
4659 tmp = node;
4705 * @node: the pattern node.
4707 * parse the content of a RelaxNG pattern node.
4713 xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4717 if (node == NULL) {
4720 if (IS_RELAXNG(node, "element")) {
4721 def = xmlRelaxNGParseElement(ctxt, node);
4722 } else if (IS_RELAXNG(node, "attribute")) {
4723 def = xmlRelaxNGParseAttribute(ctxt, node);
4724 } else if (IS_RELAXNG(node, "empty")) {
4725 def = xmlRelaxNGNewDefine(ctxt, node);
4729 if (node->children != NULL) {
4730 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_NOT_EMPTY,
4731 "empty: had a child node\n", NULL, NULL);
4733 } else if (IS_RELAXNG(node, "text")) {
4734 def = xmlRelaxNGNewDefine(ctxt, node);
4738 if (node->children != NULL) {
4739 xmlRngPErr(ctxt, node, XML_RNGP_TEXT_HAS_CHILD,
4740 "text: had a child node\n", NULL, NULL);
4742 } else if (IS_RELAXNG(node, "zeroOrMore")) {
4743 def = xmlRelaxNGNewDefine(ctxt, node);
4747 if (node->children == NULL) {
4748 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4749 "Element %s is empty\n", node->name, NULL);
4752 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4754 } else if (IS_RELAXNG(node, "oneOrMore")) {
4755 def = xmlRelaxNGNewDefine(ctxt, node);
4759 if (node->children == NULL) {
4760 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4761 "Element %s is empty\n", node->name, NULL);
4764 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4766 } else if (IS_RELAXNG(node, "optional")) {
4767 def = xmlRelaxNGNewDefine(ctxt, node);
4771 if (node->children == NULL) {
4772 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4773 "Element %s is empty\n", node->name, NULL);
4776 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4778 } else if (IS_RELAXNG(node, "choice")) {
4779 def = xmlRelaxNGNewDefine(ctxt, node);
4783 if (node->children == NULL) {
4784 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4785 "Element %s is empty\n", node->name, NULL);
4788 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4790 } else if (IS_RELAXNG(node, "group")) {
4791 def = xmlRelaxNGNewDefine(ctxt, node);
4795 if (node->children == NULL) {
4796 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4797 "Element %s is empty\n", node->name, NULL);
4800 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4802 } else if (IS_RELAXNG(node, "ref")) {
4803 def = xmlRelaxNGNewDefine(ctxt, node);
4807 def->name = xmlGetProp(node, BAD_CAST "name");
4809 xmlRngPErr(ctxt, node, XML_RNGP_REF_NO_NAME, "ref has no name\n",
4814 xmlRngPErr(ctxt, node, XML_RNGP_REF_NAME_INVALID,
4819 if (node->children != NULL) {
4820 xmlRngPErr(ctxt, node, XML_RNGP_REF_NOT_EMPTY, "ref is not empty\n",
4826 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4840 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4844 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4855 } else if (IS_RELAXNG(node, "data")) {
4856 def = xmlRelaxNGParseData(ctxt, node);
4857 } else if (IS_RELAXNG(node, "value")) {
4858 def = xmlRelaxNGParseValue(ctxt, node);
4859 } else if (IS_RELAXNG(node, "list")) {
4860 def = xmlRelaxNGNewDefine(ctxt, node);
4864 if (node->children == NULL) {
4865 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4866 "Element %s is empty\n", node->name, NULL);
4869 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4871 } else if (IS_RELAXNG(node, "interleave")) {
4872 def = xmlRelaxNGParseInterleave(ctxt, node);
4873 } else if (IS_RELAXNG(node, "externalRef")) {
4874 def = xmlRelaxNGProcessExternalRef(ctxt, node);
4875 } else if (IS_RELAXNG(node, "notAllowed")) {
4876 def = xmlRelaxNGNewDefine(ctxt, node);
4880 if (node->children != NULL) {
4881 xmlRngPErr(ctxt, node, XML_RNGP_NOTALLOWED_NOT_EMPTY,
4885 } else if (IS_RELAXNG(node, "grammar")) {
4897 grammar = xmlRelaxNGParseGrammar(ctxt, node->children);
4912 } else if (IS_RELAXNG(node, "parentRef")) {
4914 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_PARENT,
4919 def = xmlRelaxNGNewDefine(ctxt, node);
4923 def->name = xmlGetProp(node, BAD_CAST "name");
4925 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_NAME,
4930 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NAME_INVALID,
4935 if (node->children != NULL) {
4936 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NOT_EMPTY,
4942 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
4956 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
4966 } else if (IS_RELAXNG(node, "mixed")) {
4967 if (node->children == NULL) {
4968 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, "Mixed is empty\n",
4972 def = xmlRelaxNGParseInterleave(ctxt, node);
4977 tmp = xmlRelaxNGNewDefine(ctxt, node);
4985 tmp = xmlRelaxNGNewDefine(ctxt, node);
4994 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_CONSTRUCT,
4995 "Unexpected node %s is not a pattern\n", node->name,
5005 * @node: the element node
5007 * parse the content of a RelaxNG attribute node.
5012 xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
5018 ret = xmlRelaxNGNewDefine(ctxt, node);
5023 child = node->children;
5025 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_EMPTY,
5064 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CONTENT,
5069 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_NOOP,
5078 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CHILDREN,
5088 * @node: the except node
5091 * parse the content of a RelaxNG nameClass node.
5097 xmlNodePtr node, int attr)
5102 if (!IS_RELAXNG(node, "except")) {
5103 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MISSING,
5104 "Expecting an except node\n", NULL, NULL);
5107 if (node->next != NULL) {
5108 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MULTIPLE,
5109 "exceptNameClass allows only a single except node\n",
5112 if (node->children == NULL) {
5113 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_EMPTY, "except has no content\n",
5118 ret = xmlRelaxNGNewDefine(ctxt, node);
5122 child = node->children;
5149 * @node: the nameClass node
5152 * parse the content of a RelaxNG nameClass node.
5157 node,
5164 if ((IS_RELAXNG(node, "name")) || (IS_RELAXNG(node, "anyName")) ||
5165 (IS_RELAXNG(node, "nsName"))) {
5168 ret = xmlRelaxNGNewDefine(ctxt, node);
5178 if (IS_RELAXNG(node, "name")) {
5179 val = xmlNodeGetContent(node);
5182 if (node->parent != NULL)
5183 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
5185 node->parent->name, val);
5187 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
5192 val = xmlGetProp(node, BAD_CAST "ns");
5197 xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
5204 xmlRngPErr(ctxt, node, XML_RNGP_XMLNS_NAME,
5208 } else if (IS_RELAXNG(node, "anyName")) {
5211 if (node->children != NULL) {
5213 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
5217 } else if (IS_RELAXNG(node, "nsName")) {
5219 ret->ns = xmlGetProp(node, BAD_CAST "ns");
5221 xmlRngPErr(ctxt, node, XML_RNGP_NSNAME_NO_NS,
5228 xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
5232 if (node->children != NULL) {
5234 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
5238 } else if (IS_RELAXNG(node, "choice")) {
5242 ret = xmlRelaxNGNewDefine(ctxt, node);
5248 if (node->children == NULL) {
5249 xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_EMPTY,
5253 child = node->children;
5268 xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_CONTENT,
5270 node->name, NULL);
5290 * @node: the element node
5292 * parse the content of a RelaxNG element node.
5297 xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
5303 ret = xmlRelaxNGNewDefine(ctxt, node);
5308 child = node->children;
5310 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_EMPTY,
5320 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NO_CONTENT,
5355 ret->content = xmlRelaxNGNewDefine(ctxt, node);
5372 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5377 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5382 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5387 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5405 * parse the content of a RelaxNG start node.
5453 * parse the content of a RelaxNG start node.
5511 * parse the content of a RelaxNG grammar node.
5574 xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
5580 xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
5594 xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
5599 xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
5627 combine = xmlGetProp(cur->node, BAD_CAST "combine");
5633 xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
5641 xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
5646 xmlRngPErr(ctxt, define->node, XML_RNGP_UNKNOWN_COMBINE,
5655 xmlRngPErr(ctxt, define->node, XML_RNGP_NEED_COMBINE,
5670 cur = xmlRelaxNGNewDefine(ctxt, define->node);
5685 tmp2 = xmlRelaxNGNewDefine(ctxt, tmp->content->node);
5708 xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5717 xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5748 if ((cur->node == NULL) || (cur->node->parent == NULL) ||
5749 (!xmlStrEqual(cur->node->parent->name, BAD_CAST "start"))) {
5751 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_MISSING,
5755 combine = xmlGetProp(cur->node->parent, BAD_CAST "combine");
5763 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
5771 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
5776 xmlRngPErr(ctxt, cur->node, XML_RNGP_UNKNOWN_COMBINE,
5785 xmlRngPErr(ctxt, cur->node, XML_RNGP_NEED_COMBINE,
5800 cur = xmlRelaxNGNewDefine(ctxt, starts->node);
5813 xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5822 xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5854 xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_CYCLE,
6025 * the current node may have been transformed back
6150 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_REF,
6156 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_REF,
6176 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ELEM,
6181 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ELEM,
6186 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
6191 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
6203 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_EMPTY,
6211 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_ERROR,
6219 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ATTR,
6224 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ATTR,
6229 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_GROUP_ATTR,
6234 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
6239 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ATTR,
6244 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ATTR,
6251 xmlRngPErr(ctxt, cur->node, XML_RNGP_ANYNAME_ATTR_ANCESTOR,
6255 xmlRngPErr(ctxt, cur->node, XML_RNGP_NSNAME_ATTR_ANCESTOR,
6266 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ONEMORE,
6271 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ONEMORE,
6282 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_LIST,
6287 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_LIST,
6292 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_LIST,
6302 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_GROUP,
6307 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_GROUP,
6324 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_INTERLEAVE,
6329 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
6334 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
6356 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_DATA,
6364 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_VALUE,
6372 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_TEXT,
6377 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_TEXT,
6382 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_TEXT,
6389 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_EMPTY,
6394 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_EMPTY,
6436 * parse a Relax-NG <grammar> node
6507 * @node: the root node of the RelaxNG schema
6516 xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
6522 if ((ctxt == NULL) || (node == NULL))
6531 if (IS_RELAXNG(node, "grammar")) {
6532 schema->topgrammar = xmlRelaxNGParseGrammar(ctxt, node->children);
6556 xmlRelaxNGParseStart(ctxt, node);
6778 * @node: a Relax-NG node
6780 * Check all the attributes on the given node
6783 xmlRelaxNGCleanupAttributes(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
6787 cur = node->properties;
6793 if ((!xmlStrEqual(node->name, BAD_CAST "element")) &&
6794 (!xmlStrEqual(node->name, BAD_CAST "attribute")) &&
6795 (!xmlStrEqual(node->name, BAD_CAST "ref")) &&
6796 (!xmlStrEqual(node->name, BAD_CAST "parentRef")) &&
6797 (!xmlStrEqual(node->name, BAD_CAST "param")) &&
6798 (!xmlStrEqual(node->name, BAD_CAST "define"))) {
6799 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6801 cur->name, node->name);
6804 if ((!xmlStrEqual(node->name, BAD_CAST "value")) &&
6805 (!xmlStrEqual(node->name, BAD_CAST "data"))) {
6806 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6808 cur->name, node->name);
6811 if ((!xmlStrEqual(node->name, BAD_CAST "externalRef")) &&
6812 (!xmlStrEqual(node->name, BAD_CAST "include"))) {
6813 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6815 cur->name, node->name);
6818 if ((!xmlStrEqual(node->name, BAD_CAST "start")) &&
6819 (!xmlStrEqual(node->name, BAD_CAST "define"))) {
6820 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6822 cur->name, node->name);
6828 val = xmlNodeListGetString(node->doc, cur->children, 1);
6833 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_URI,
6838 xmlRngPErr(ctxt, node, XML_RNGP_URI_NOT_ABSOLUTE,
6843 xmlRngPErr(ctxt, node, XML_RNGP_URI_FRAGMENT,
6853 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_ATTRIBUTE,
6855 node->name);
7059 xmlNodePtr node;
7061 node = xmlNewDocNode(cur->doc, cur->ns,
7063 if (node != NULL) {
7064 xmlAddPrevSibling(cur->children, node);
7066 xmlAddChild(node, text);
7067 text = node;
7097 xmlNodePtr node;
7100 node = cur->parent;
7101 while ((node != NULL) &&
7102 (node->type == XML_ELEMENT_NODE)) {
7103 ns = xmlGetProp(node, BAD_CAST "ns");
7107 node = node->parent;
7265 * Skip to next node
7938 * Push a new regexp for the current node content model on the stack
7975 * Pop the regexp of the current node content model from the stack
8015 xmlNodePtr node;
8026 node = ctxt->pnode;
8050 if (node->type != XML_ELEMENT_NODE) {
8059 * this node cannot be validated in a streamable fashion
8081 state = xmlRelaxNGNewValidState(ctxt, node);
8092 VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name);
8150 * element requires a full node, and -1 in case of error.
8319 * 0 and the content of the node has been expanded.
8369 * @node: the top node.
8377 xmlNodePtr node)
8382 while ((node != NULL) &&
8383 ((node->type == XML_COMMENT_NODE) ||
8384 (node->type == XML_PI_NODE) ||
8385 (node->type == XML_XINCLUDE_START) ||
8386 (node->type == XML_XINCLUDE_END) ||
8387 (((node->type == XML_TEXT_NODE) ||
8388 (node->type == XML_CDATA_SECTION_NODE)) &&
8390 (IS_BLANK_NODE(node)))))) {
8391 node = node->next;
8393 return (node);
8447 * @node: the node
8456 xmlRelaxNGDefinePtr define, xmlNodePtr node)
8471 node);
8473 ret = lib->check(lib->data, define->name, value, NULL, node);
8609 define->value, define->node,
8611 value, ctxt->state->node);
8906 * Validate the given attribute definition for that node
9016 * Validate the given node against the list of attribute definitions
9061 * @node: the node
9064 * Check if a node can be matched by one of the definitions
9069 xmlRelaxNGNodeMatchesList(xmlNodePtr node, xmlRelaxNGDefinePtr * list)
9074 if ((node == NULL) || (list == NULL))
9079 if ((node->type == XML_ELEMENT_NODE) &&
9081 tmp = xmlRelaxNGElementMatch(NULL, cur, node);
9084 } else if (((node->type == XML_TEXT_NODE) ||
9085 (node->type == XML_CDATA_SECTION_NODE)) &&
9099 * Validate an interleave definition for a node.
9157 * Build arrays to store the first and last node of the chain
9384 * Validate the given node content against the (list) of definitions
9620 state->node->name, state->seq->name);
9629 state->attrs[i]->name, state->node->name);
9650 xmlNodePtr node;
9660 node = ctxt->state->seq;
9662 node = NULL;
9671 if ((node != NULL) && (node->name != NULL))
9672 xmlGenericError(xmlGenericErrorContext, "on %s\n", node->name);
9679 node = xmlRelaxNGSkipIgnored(ctxt, node);
9686 while ((node != NULL) &&
9687 ((node->type == XML_TEXT_NODE) ||
9688 (node->type == XML_COMMENT_NODE) ||
9689 (node->type == XML_PI_NODE) ||
9690 (node->type == XML_CDATA_SECTION_NODE)))
9691 node = node->next;
9692 ctxt->state->seq = node;
9696 node = xmlRelaxNGSkipIgnored(ctxt, node);
9697 if (node == NULL) {
9704 if (node->type != XML_ELEMENT_NODE) {
9712 * This node was already validated successfully against
9715 if (node->psvi == define) {
9716 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
9722 && (xmlStrEqual(ctxt->err->arg2, node->name)))
9726 && (xmlStrEqual(ctxt->err->arg1, node->name)))
9735 ret = xmlRelaxNGElementMatch(ctxt, define, node);
9748 (xmlStrEqual(ctxt->err->arg2, node->name))) ||
9750 (xmlStrEqual(ctxt->err->arg1, node->name))) ||
9761 state = xmlRelaxNGNewValidState(ctxt, node);
9775 VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name);
9783 nstate = xmlRelaxNGNewValidState(ctxt, node);
9851 node->name);
9855 node->name);
9897 node->psvi = define;
9902 oldstate->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
9920 node->name, ret);
10093 * and make them the new node set
10139 node = xmlRelaxNGSkipIgnored(ctxt, node);
10143 (node != NULL)) {
10145 * node == NULL can't be optimized since IS_TRIABLE
10156 if ((node->type == XML_TEXT_NODE) ||
10157 (node->type == XML_CDATA_SECTION_NODE)) {
10160 } else if (node->type == XML_ELEMENT_NODE) {
10161 if (node->ns != NULL) {
10162 list = xmlHashLookup2(triage, node->name,
10163 node->ns->href);
10167 node->ns->href);
10170 xmlHashLookup2(triage, node->name, NULL);
10178 VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, node->name);
10255 child = node;
10259 node->parent->name);
10298 child = node;
10302 node->parent->name);
10349 child = node;
10353 node->parent->name);
10386 } else if ((ret == 0) && (node != NULL)) {
10387 ctxt->state->seq = node->next;
10419 * Validate the current node lists against the definition
10559 xmlNodePtr node;
10576 node = state->seq;
10577 node = xmlRelaxNGSkipIgnored(ctxt, node);
10578 if (node != NULL) {
10590 node = state->seq;
10591 node = xmlRelaxNGSkipIgnored(ctxt, node);
10592 if (node == NULL)
