Lines Matching defs:node
42 #define IS_RELAXNG(node, typ) \
43 ((node != NULL) && (node->ns != NULL) && \
44 (node->type == XML_ELEMENT_NODE) && \
45 (xmlStrEqual(node->name, (const xmlChar *) typ)) && \
46 (xmlStrEqual(node->ns->href, xmlRelaxNGNs)))
157 xmlNodePtr node; /* the node in the source */
303 xmlNodePtr node; /* the current node */
338 xmlNodePtr node; /* the current node */
389 xmlNodePtr pnode; /* the current node */
502 * @node: the node raising the error
511 xmlRngPErr(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node, int error,
527 NULL, node, XML_FROM_RELAXNGP,
536 * @node: the node raising the error
545 xmlRngVErr(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node, int error,
561 NULL, node, XML_FROM_RELAXNGV,
598 xmlNodePtr node);
884 * @node: the node in the input document.
891 xmlRelaxNGNewDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
925 ret->node = node;
1176 * @node: the current node or NULL for the document
1183 xmlRelaxNGNewValidState(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node)
1191 if (node == NULL) {
1196 attr = node->properties;
1220 if (node == NULL) {
1221 ret->node = (xmlNodePtr) ctxt->doc;
1224 ret->node = node;
1225 ret->seq = node->children;
1256 attr = node->properties;
1355 if (state1->node != state2->node)
1585 * @node: the include node.
1596 xmlNodePtr node, const xmlChar * ns)
1625 xmlRngPErr(ctxt, node, XML_RNGP_PARSE_ERROR,
1692 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY,
1698 xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
1707 cur = node->children;
1715 xmlRngPErr(ctxt, node, XML_RNGP_START_MISSING,
1724 xmlRngPErr(ctxt, node, XML_RNGP_NAME_MISSING,
1734 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_MISSING,
1798 (ctxt->err->node == ctxt->state->node) && (ctxt->err->err == err))
1812 cur->node = ctxt->state->node;
1815 cur->node = NULL;
2225 * @node: the node
2226 * @child: the node child generating the problem.
2234 xmlRelaxNGValidErr err, xmlNodePtr node,
2252 xmlRngVErr(ctxt, (child == NULL ? node : child), err,
2312 if ((err->err == dup->err) && (err->node == dup->node) &&
2318 xmlRelaxNGShowValidError(ctxt, err->err, err->node, err->seq,
2365 xmlNodePtr node, seq;
2374 node = ctxt->state->node;
2377 node = seq = NULL;
2379 if ((node == NULL) && (seq == NULL)) {
2380 node = ctxt->pnode;
2382 xmlRelaxNGShowValidError(ctxt, err, node, seq, arg1, arg2);
2431 * @node: the node
2442 void **result, xmlNodePtr node)
2455 (xmlSchemaValPtr *) result, node);
2644 * @node: the node
2656 xmlNodePtr node ATTRIBUTE_UNUSED)
3335 ctxt, xmlNodePtr node);
3337 ctxt, xmlNodePtr node);
3342 ctxt, xmlNodePtr node);
3344 xmlNodePtr node);
3348 ctxt, xmlNodePtr node,
3463 * @node: the current data or value element
3471 xmlNodePtr node)
3475 if (node == NULL)
3478 if ((IS_RELAXNG(node, "data")) || (IS_RELAXNG(node, "value"))) {
3479 ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
3493 node = node->parent;
3494 while ((node != NULL) && (node->type == XML_ELEMENT_NODE)) {
3495 ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
3508 node = node->parent;
3516 * @node: the data node.
3518 * parse the content of a RelaxNG value node.
3523 xmlRelaxNGParseValue(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
3531 def = xmlRelaxNGNewDefine(ctxt, node);
3536 type = xmlGetProp(node, BAD_CAST "type");
3540 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
3543 library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
3554 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
3561 xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
3567 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
3574 if (node->children == NULL) {
3576 } else if (((node->children->type != XML_TEXT_NODE) &&
3577 (node->children->type != XML_CDATA_SECTION_NODE)) ||
3578 (node->children->next != NULL)) {
3579 xmlRngPErr(ctxt, node, XML_RNGP_TEXT_EXPECTED,
3583 def->value = xmlNodeGetContent(node);
3585 xmlRngPErr(ctxt, node, XML_RNGP_VALUE_NO_CONTENT,
3591 lib->check(lib->data, def->name, def->value, &val, node);
3593 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_VALUE,
3608 * @node: the data node.
3610 * parse the content of a RelaxNG data node.
3615 xmlRelaxNGParseData(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
3625 type = xmlGetProp(node, BAD_CAST "type");
3627 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_MISSING, "data has no type\n", NULL,
3633 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
3636 library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
3641 def = xmlRelaxNGNewDefine(ctxt, node);
3653 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
3660 xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
3666 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
3680 content = node->children;
3690 xmlRngPErr(ctxt, node, XML_RNGP_PARAM_FORBIDDEN,
3698 param = xmlRelaxNGNewDefine(ctxt, node);
3703 xmlRngPErr(ctxt, node, XML_RNGP_PARAM_NAME_MISSING,
3727 except = xmlRelaxNGNewDefine(ctxt, node);
3784 xmlNode node;
3797 node.name = def1->name;
3799 node.name = invalidName;
3803 node.ns = NULL;
3805 node.ns = &ns;
3809 node.ns = NULL;
3811 if (xmlRelaxNGElementMatch(&ctxt, def2, &node)) {
3834 node.name = def2->name;
3836 node.name = invalidName;
3838 node.ns = &ns;
3841 node.ns = NULL;
3848 if (xmlRelaxNGElementMatch(&ctxt, def1, &node)) {
4280 xmlRngPErr(ctxt, def->node, XML_RNGP_GROUP_ATTR_CONFLICT,
4386 xmlRngPErr(ctxt, def->node, XML_RNGP_ELEM_TEXT_CONFLICT,
4393 xmlRngPErr(ctxt, def->node, XML_RNGP_ATTR_CONFLICT,
4472 * @node: the data node.
4474 * parse the content of a RelaxNG interleave node.
4479 xmlRelaxNGParseInterleave(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4485 def = xmlRelaxNGNewDefine(ctxt, node);
4500 xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_ADD,
4505 child = node->children;
4507 xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_NO_CONTENT,
4534 * @node: the include node
4536 * Integrate the content of an include node in the current grammar
4541 xmlRelaxNGParseInclude(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4547 incl = node->psvi;
4549 xmlRngPErr(ctxt, node, XML_RNGP_INCLUDE_EMPTY,
4550 "Include node has no data\n", NULL, NULL);
4555 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY, "Include document is empty\n",
4560 xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
4573 if (node->children != NULL) {
4574 tmp = xmlRelaxNGParseGrammarContent(ctxt, node->children);
4584 * @node: the define node
4586 * parse the content of a RelaxNG define element node.
4591 xmlRelaxNGParseDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4598 name = xmlGetProp(node, BAD_CAST "name");
4600 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_NAME_MISSING,
4605 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_DEFINE_NAME,
4608 def = xmlRelaxNGNewDefine(ctxt, node);
4615 if (node->children == NULL) {
4616 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_EMPTY,
4622 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4628 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
4638 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
4722 * @node: the externlRef node
4724 * Process and compile an externlRef node
4729 xmlRelaxNGProcessExternalRef(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4737 docu = node->psvi;
4739 def = xmlRelaxNGNewDefine(ctxt, node);
4750 xmlRngPErr(ctxt, node, XML_RNGP_EXTERNALREF_EMTPY,
4760 tmp = node;
4808 * @node: the pattern node.
4810 * parse the content of a RelaxNG pattern node.
4816 xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4820 if (node == NULL) {
4823 if (IS_RELAXNG(node, "element")) {
4824 def = xmlRelaxNGParseElement(ctxt, node);
4825 } else if (IS_RELAXNG(node, "attribute")) {
4826 def = xmlRelaxNGParseAttribute(ctxt, node);
4827 } else if (IS_RELAXNG(node, "empty")) {
4828 def = xmlRelaxNGNewDefine(ctxt, node);
4832 if (node->children != NULL) {
4833 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_NOT_EMPTY,
4834 "empty: had a child node\n", NULL, NULL);
4836 } else if (IS_RELAXNG(node, "text")) {
4837 def = xmlRelaxNGNewDefine(ctxt, node);
4841 if (node->children != NULL) {
4842 xmlRngPErr(ctxt, node, XML_RNGP_TEXT_HAS_CHILD,
4843 "text: had a child node\n", NULL, NULL);
4845 } else if (IS_RELAXNG(node, "zeroOrMore")) {
4846 def = xmlRelaxNGNewDefine(ctxt, node);
4850 if (node->children == NULL) {
4851 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4852 "Element %s is empty\n", node->name, NULL);
4855 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4857 } else if (IS_RELAXNG(node, "oneOrMore")) {
4858 def = xmlRelaxNGNewDefine(ctxt, node);
4862 if (node->children == NULL) {
4863 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4864 "Element %s is empty\n", node->name, NULL);
4867 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4869 } else if (IS_RELAXNG(node, "optional")) {
4870 def = xmlRelaxNGNewDefine(ctxt, node);
4874 if (node->children == NULL) {
4875 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4876 "Element %s is empty\n", node->name, NULL);
4879 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4881 } else if (IS_RELAXNG(node, "choice")) {
4882 def = xmlRelaxNGNewDefine(ctxt, node);
4886 if (node->children == NULL) {
4887 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4888 "Element %s is empty\n", node->name, NULL);
4891 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4893 } else if (IS_RELAXNG(node, "group")) {
4894 def = xmlRelaxNGNewDefine(ctxt, node);
4898 if (node->children == NULL) {
4899 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4900 "Element %s is empty\n", node->name, NULL);
4903 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4905 } else if (IS_RELAXNG(node, "ref")) {
4906 def = xmlRelaxNGNewDefine(ctxt, node);
4910 def->name = xmlGetProp(node, BAD_CAST "name");
4912 xmlRngPErr(ctxt, node, XML_RNGP_REF_NO_NAME, "ref has no name\n",
4917 xmlRngPErr(ctxt, node, XML_RNGP_REF_NAME_INVALID,
4922 if (node->children != NULL) {
4923 xmlRngPErr(ctxt, node, XML_RNGP_REF_NOT_EMPTY, "ref is not empty\n",
4929 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4943 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4947 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4958 } else if (IS_RELAXNG(node, "data")) {
4959 def = xmlRelaxNGParseData(ctxt, node);
4960 } else if (IS_RELAXNG(node, "value")) {
4961 def = xmlRelaxNGParseValue(ctxt, node);
4962 } else if (IS_RELAXNG(node, "list")) {
4963 def = xmlRelaxNGNewDefine(ctxt, node);
4967 if (node->children == NULL) {
4968 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4969 "Element %s is empty\n", node->name, NULL);
4972 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4974 } else if (IS_RELAXNG(node, "interleave")) {
4975 def = xmlRelaxNGParseInterleave(ctxt, node);
4976 } else if (IS_RELAXNG(node, "externalRef")) {
4977 def = xmlRelaxNGProcessExternalRef(ctxt, node);
4978 } else if (IS_RELAXNG(node, "notAllowed")) {
4979 def = xmlRelaxNGNewDefine(ctxt, node);
4983 if (node->children != NULL) {
4984 xmlRngPErr(ctxt, node, XML_RNGP_NOTALLOWED_NOT_EMPTY,
4988 } else if (IS_RELAXNG(node, "grammar")) {
5000 grammar = xmlRelaxNGParseGrammar(ctxt, node->children);
5015 } else if (IS_RELAXNG(node, "parentRef")) {
5017 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_PARENT,
5022 def = xmlRelaxNGNewDefine(ctxt, node);
5026 def->name = xmlGetProp(node, BAD_CAST "name");
5028 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_NAME,
5033 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NAME_INVALID,
5038 if (node->children != NULL) {
5039 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NOT_EMPTY,
5045 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
5059 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
5069 } else if (IS_RELAXNG(node, "mixed")) {
5070 if (node->children == NULL) {
5071 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, "Mixed is empty\n",
5075 def = xmlRelaxNGParseInterleave(ctxt, node);
5080 tmp = xmlRelaxNGNewDefine(ctxt, node);
5088 tmp = xmlRelaxNGNewDefine(ctxt, node);
5097 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_CONSTRUCT,
5098 "Unexpected node %s is not a pattern\n", node->name,
5108 * @node: the element node
5110 * parse the content of a RelaxNG attribute node.
5115 xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
5121 ret = xmlRelaxNGNewDefine(ctxt, node);
5126 child = node->children;
5128 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_EMPTY,
5167 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CONTENT,
5172 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_NOOP,
5181 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CHILDREN,
5191 * @node: the except node
5194 * parse the content of a RelaxNG nameClass node.
5200 xmlNodePtr node, int attr)
5205 if (!IS_RELAXNG(node, "except")) {
5206 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MISSING,
5207 "Expecting an except node\n", NULL, NULL);
5210 if (node->next != NULL) {
5211 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MULTIPLE,
5212 "exceptNameClass allows only a single except node\n",
5215 if (node->children == NULL) {
5216 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_EMPTY, "except has no content\n",
5221 ret = xmlRelaxNGNewDefine(ctxt, node);
5225 child = node->children;
5252 * @node: the nameClass node
5255 * parse the content of a RelaxNG nameClass node.
5260 xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node,
5267 if ((IS_RELAXNG(node, "name")) || (IS_RELAXNG(node, "anyName")) ||
5268 (IS_RELAXNG(node, "nsName"))) {
5271 ret = xmlRelaxNGNewDefine(ctxt, node);
5281 if (IS_RELAXNG(node, "name")) {
5282 val = xmlNodeGetContent(node);
5285 if (node->parent != NULL)
5286 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
5288 node->parent->name, val);
5290 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
5295 val = xmlGetProp(node, BAD_CAST "ns");
5300 xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
5307 xmlRngPErr(ctxt, node, XML_RNGP_XMLNS_NAME,
5311 } else if (IS_RELAXNG(node, "anyName")) {
5314 if (node->children != NULL) {
5316 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
5320 } else if (IS_RELAXNG(node, "nsName")) {
5322 ret->ns = xmlGetProp(node, BAD_CAST "ns");
5324 xmlRngPErr(ctxt, node, XML_RNGP_NSNAME_NO_NS,
5331 xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
5335 if (node->children != NULL) {
5337 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
5341 } else if (IS_RELAXNG(node, "choice")) {
5345 ret = xmlRelaxNGNewDefine(ctxt, node);
5351 if (node->children == NULL) {
5352 xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_EMPTY,
5356 child = node->children;
5371 xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_CONTENT,
5373 (node == NULL ? (const xmlChar *) "nothing" : node->name),
5394 * @node: the element node
5396 * parse the content of a RelaxNG element node.
5401 xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
5407 ret = xmlRelaxNGNewDefine(ctxt, node);
5412 child = node->children;
5414 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_EMPTY,
5424 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NO_CONTENT,
5459 ret->content = xmlRelaxNGNewDefine(ctxt, node);
5476 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5481 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5486 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5491 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5509 * parse the content of a RelaxNG start node.
5557 * parse the content of a RelaxNG start node.
5615 * parse the content of a RelaxNG grammar node.
5684 xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
5690 xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
5704 xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
5709 xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
5737 combine = xmlGetProp(cur->node, BAD_CAST "combine");
5743 xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
5751 xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
5756 xmlRngPErr(ctxt, define->node, XML_RNGP_UNKNOWN_COMBINE,
5765 xmlRngPErr(ctxt, define->node, XML_RNGP_NEED_COMBINE,
5780 cur = xmlRelaxNGNewDefine(ctxt, define->node);
5795 tmp2 = xmlRelaxNGNewDefine(ctxt, tmp->content->node);
5818 xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5827 xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5858 if ((cur->node == NULL) || (cur->node->parent == NULL) ||
5859 (!xmlStrEqual(cur->node->parent->name, BAD_CAST "start"))) {
5861 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_MISSING,
5865 combine = xmlGetProp(cur->node->parent, BAD_CAST "combine");
5873 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
5881 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
5886 xmlRngPErr(ctxt, cur->node, XML_RNGP_UNKNOWN_COMBINE,
5895 xmlRngPErr(ctxt, cur->node, XML_RNGP_NEED_COMBINE,
5910 cur = xmlRelaxNGNewDefine(ctxt, starts->node);
5923 xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5932 xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5964 xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_CYCLE,
6135 * the current node may have been transformed back
6260 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_REF,
6266 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_REF,
6272 xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF,
6276 xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF,
6296 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ELEM,
6301 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ELEM,
6306 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
6311 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
6323 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_EMPTY,
6331 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_ERROR,
6339 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ATTR,
6344 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ATTR,
6349 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_GROUP_ATTR,
6354 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
6359 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ATTR,
6364 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ATTR,
6371 xmlRngPErr(ctxt, cur->node, XML_RNGP_ANYNAME_ATTR_ANCESTOR,
6375 xmlRngPErr(ctxt, cur->node, XML_RNGP_NSNAME_ATTR_ANCESTOR,
6386 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ONEMORE,
6391 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ONEMORE,
6402 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_LIST,
6407 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_LIST,
6412 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_LIST,
6422 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_GROUP,
6427 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_GROUP,
6444 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_INTERLEAVE,
6449 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
6454 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
6476 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_DATA,
6484 xmlRngPErr(ctxt, cur->node
6492 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_TEXT,
6497 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_TEXT,
6502 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_TEXT,
6509 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_EMPTY,
6514 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_EMPTY,
6560 * parse a Relax-NG <grammar> node
6632 * @node: the root node of the RelaxNG schema
6641 xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
6647 if ((ctxt == NULL) || (node == NULL))
6656 if (IS_RELAXNG(node, "grammar")) {
6657 schema->topgrammar = xmlRelaxNGParseGrammar(ctxt, node->children);
6681 xmlRelaxNGParseStart(ctxt, node);
6903 * @node: a Relax-NG node
6905 * Check all the attributes on the given node
6908 xmlRelaxNGCleanupAttributes(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
6912 cur = node->properties;
6918 if ((!xmlStrEqual(node->name, BAD_CAST "element")) &&
6919 (!xmlStrEqual(node->name, BAD_CAST "attribute")) &&
6920 (!xmlStrEqual(node->name, BAD_CAST "ref")) &&
6921 (!xmlStrEqual(node->name, BAD_CAST "parentRef")) &&
6922 (!xmlStrEqual(node->name, BAD_CAST "param")) &&
6923 (!xmlStrEqual(node->name, BAD_CAST "define"))) {
6924 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6926 cur->name, node->name);
6929 if ((!xmlStrEqual(node->name, BAD_CAST "value")) &&
6930 (!xmlStrEqual(node->name, BAD_CAST "data"))) {
6931 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6933 cur->name, node->name);
6936 if ((!xmlStrEqual(node->name, BAD_CAST "externalRef")) &&
6937 (!xmlStrEqual(node->name, BAD_CAST "include"))) {
6938 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6940 cur->name, node->name);
6943 if ((!xmlStrEqual(node->name, BAD_CAST "start")) &&
6944 (!xmlStrEqual(node->name, BAD_CAST "define"))) {
6945 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6947 cur->name, node->name);
6953 val = xmlNodeListGetString(node->doc, cur->children, 1);
6958 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_URI,
6963 xmlRngPErr(ctxt, node, XML_RNGP_URI_NOT_ABSOLUTE,
6968 xmlRngPErr(ctxt, node, XML_RNGP_URI_FRAGMENT,
6978 xmlRngPErr(ctxt, node
6980 node->name);
7184 xmlNodePtr node;
7186 node = xmlNewDocNode(cur->doc, cur->ns,
7188 if (node != NULL) {
7189 xmlAddPrevSibling(cur->children, node);
7191 xmlAddChild(node, text);
7192 text = node;
7222 xmlNodePtr node;
7225 node = cur->parent;
7226 while ((node != NULL) &&
7227 (node->type == XML_ELEMENT_NODE)) {
7228 ns = xmlGetProp(node, BAD_CAST "ns");
7232 node = node->parent;
7390 * Skip to next node
8063 * Push a new regexp for the current node content model on the stack
8100 * Pop the regexp of the current node content model from the stack
8140 xmlNodePtr node;
8151 node = ctxt->pnode;
8175 if (node->type != XML_ELEMENT_NODE) {
8184 * this node cannot be validated in a streamable fashion
8206 state = xmlRelaxNGNewValidState(ctxt, node);
8217 VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name);
8275 * element requires a full node, and -1 in case of error.
8444 * 0 and the content of the node has been expanded.
8494 * @node: the top node.
8502 xmlNodePtr node)
8507 while ((node != NULL) &&
8508 ((node->type == XML_COMMENT_NODE) ||
8509 (node->type == XML_PI_NODE) ||
8510 (node->type == XML_XINCLUDE_START) ||
8511 (node->type == XML_XINCLUDE_END) ||
8512 (((node->type == XML_TEXT_NODE) ||
8513 (node->type == XML_CDATA_SECTION_NODE)) &&
8515 (IS_BLANK_NODE(node)))))) {
8516 node = node->next;
8518 return (node);
8572 * @node: the node
8581 xmlRelaxNGDefinePtr define, xmlNodePtr node)
8596 lib->check(lib->data, define->name, value, &result, node);
8598 ret = lib->check(lib->data, define->name, value, NULL, node);
8734 define->value, define->node,
8736 value, ctxt->state->node);
9063 * Validate the given attribute definition for that node
9173 * Validate the given node against the list of attribute definitions
9218 * @node: the node
9221 * Check if a node can be matched by one of the definitions
9226 xmlRelaxNGNodeMatchesList(xmlNodePtr node, xmlRelaxNGDefinePtr * list)
9231 if ((node == NULL) || (list == NULL))
9236 if ((node->type == XML_ELEMENT_NODE) &&
9238 tmp = xmlRelaxNGElementMatch(NULL, cur, node);
9241 } else if (((node->type == XML_TEXT_NODE) ||
9242 (node->type == XML_CDATA_SECTION_NODE)) &&
9256 * Validate an interleave definition for a node.
9314 * Build arrays to store the first and last node of the chain
9547 * Validate the given node content against the (list) of definitions
9783 state->node->name, state->seq->name);
9792 state->attrs[i]->name, state->node->name);
9813 xmlNodePtr node;
9823 node = ctxt->state->seq;
9825 node = NULL;
9834 if ((node != NULL) && (node->name != NULL))
9835 xmlGenericError(xmlGenericErrorContext, "on %s\n", node->name);
9842 node = xmlRelaxNGSkipIgnored(ctxt, node);
9849 while ((node != NULL) &&
9850 ((node->type == XML_TEXT_NODE) ||
9851 (node->type == XML_COMMENT_NODE) ||
9852 (node->type == XML_PI_NODE) ||
9853 (node->type == XML_CDATA_SECTION_NODE)))
9854 node = node->next;
9855 ctxt->state->seq = node;
9859 node = xmlRelaxNGSkipIgnored(ctxt, node);
9860 if (node == NULL) {
9867 if (node->type != XML_ELEMENT_NODE) {
9875 * This node was already validated successfully against
9878 if (node->psvi == define) {
9879 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
9885 && (xmlStrEqual(ctxt->err->arg2, node->name)))
9889 && (xmlStrEqual(ctxt->err->arg1, node->name)))
9898 ret = xmlRelaxNGElementMatch(ctxt, define, node);
9911 (xmlStrEqual(ctxt->err->arg2, node->name))) ||
9913 (xmlStrEqual(ctxt->err->arg1, node->name))) ||
9924 state = xmlRelaxNGNewValidState(ctxt, node);
9938 VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name);
9946 nstate = xmlRelaxNGNewValidState(ctxt, node);
10014 node->name);
10018 node->name);
10060 node->psvi = define;
10065 oldstate->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
10083 node->name, ret);
10248 * and make them the new node set
10293 node = xmlRelaxNGSkipIgnored(ctxt, node);
10297 (node != NULL)) {
10299 * node == NULL can't be optimized since IS_TRIABLE
10310 if ((node->type == XML_TEXT_NODE) ||
10311 (node->type == XML_CDATA_SECTION_NODE)) {
10314 } else if (node->type == XML_ELEMENT_NODE) {
10315 if (node->ns != NULL) {
10316 list = xmlHashLookup2(triage, node->name,
10317 node->ns->href);
10321 node->ns->href);
10324 xmlHashLookup2(triage, node->name, NULL);
10332 VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, node->name);
10409 child = node;
10413 node->parent->name);
10452 child = node;
10456 node->parent->name);
10503 child = node;
10507 node->parent->name);
10540 } else if ((ret == 0) && (node != NULL)) {
10541 ctxt->state->seq = node->next;
10573 * Validate the current node lists against the definition
10713 xmlNodePtr node;
10730 node = state->seq;
10731 node = xmlRelaxNGSkipIgnored(ctxt, node);
10732 if (node != NULL) {
10744 node = state->seq;
10745 node = xmlRelaxNGSkipIgnored(ctxt, node);
10746 if (node == NULL)
10793 * @node: an input element or document
10798 * field, the value stored is actually - the node number (starting at -1)
10805 xmlRelaxNGCleanPSVI(xmlNodePtr node) {
10808 if ((node == NULL) ||
10809 ((node->type != XML_ELEMENT_NODE) &&
10810 (node->type != XML_DOCUMENT_NODE) &&
10811 (node->type != XML_HTML_DOCUMENT_NODE)))
10813 if (node->type == XML_ELEMENT_NODE)
10814 node->psvi = NULL;
10816 cur = node->children;
10833 if (cur == node) {
