Lines Matching refs:ctxt
432 * @ctxt: an Relax-NG parser context
438 xmlRngPErrMemory(xmlRelaxNGParserCtxtPtr ctxt, const char *extra)
444 if (ctxt != NULL) {
445 if (ctxt->serror != NULL)
446 schannel = ctxt->serror;
448 channel = ctxt->error;
449 data = ctxt->userData;
450 ctxt->nbErrors++;
467 * @ctxt: a Relax-NG validation context
473 xmlRngVErrMemory(xmlRelaxNGValidCtxtPtr ctxt, const char *extra)
479 if (ctxt != NULL) {
480 if (ctxt->serror != NULL)
481 schannel = ctxt->serror;
483 channel = ctxt->error;
484 data = ctxt->userData;
485 ctxt->nbErrors++;
502 * @ctxt: a Relax-NG parser context
512 xmlRngPErr(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node, int error,
519 if (ctxt != NULL) {
520 if (ctxt->serror != NULL)
521 schannel = ctxt->serror;
523 channel = ctxt->error;
524 data = ctxt->userData;
525 ctxt->nbErrors++;
536 * @ctxt: a Relax-NG validation context
546 xmlRngVErr(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node, int error,
553 if (ctxt != NULL) {
554 if (ctxt->serror != NULL)
555 schannel = ctxt->serror;
557 channel = ctxt->error;
558 data = ctxt->userData;
559 ctxt->nbErrors++;
667 static int xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt
671 static void xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
754 * @ctxt: a Relax-NG validation context (optional)
761 xmlRelaxNGNewRelaxNG(xmlRelaxNGParserCtxtPtr ctxt)
767 xmlRngPErrMemory(ctxt, NULL);
833 * @ctxt: a Relax-NG validation context (optional)
840 xmlRelaxNGNewGrammar(xmlRelaxNGParserCtxtPtr ctxt)
846 xmlRngPErrMemory(ctxt, NULL);
884 * @ctxt: a Relax-NG validation context
892 xmlRelaxNGNewDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
896 if (ctxt->defMax == 0) {
897 ctxt->defMax = 16;
898 ctxt->defNr = 0;
899 ctxt->defTab = (xmlRelaxNGDefinePtr *)
900 xmlMalloc(ctxt->defMax * sizeof(xmlRelaxNGDefinePtr));
901 if (ctxt->defTab == NULL) {
902 xmlRngPErrMemory(ctxt, "allocating define\n");
905 } else if (ctxt->defMax <= ctxt->defNr) {
908 ctxt->defMax *= 2;
909 tmp = (xmlRelaxNGDefinePtr *) xmlRealloc(ctxt->defTab,
910 ctxt->defMax *
914 xmlRngPErrMemory(ctxt, "allocating define\n");
917 ctxt->defTab = tmp;
921 xmlRngPErrMemory(ctxt, "allocating define\n");
925 ctxt->defTab[ctxt->defNr++] = ret;
1000 * @ctxt: a Relax-NG validation context
1008 xmlRelaxNGNewStates(xmlRelaxNGValidCtxtPtr ctxt, int size)
1012 if ((ctxt != NULL) &&
1013 (ctxt->freeStates != NULL) && (ctxt->freeStatesNr > 0)) {
1014 ctxt->freeStatesNr--;
1015 ret = ctxt->freeStates[ctxt->freeStatesNr];
1027 xmlRngVErrMemory(ctxt, "allocating states\n");
1036 xmlRngVErrMemory(ctxt, "allocating states\n");
1045 * @ctxt: a Relax-NG validation context
1055 xmlRelaxNGAddStatesUniq(xmlRelaxNGValidCtxtPtr ctxt,
1072 xmlRngVErrMemory(ctxt, "adding states\n");
1084 * @ctxt: a Relax-NG validation context
1093 xmlRelaxNGAddStates(xmlRelaxNGValidCtxtPtr ctxt,
1112 xmlRngVErrMemory(ctxt, "adding states\n");
1119 if (xmlRelaxNGEqualValidState(ctxt, state, states->tabState[i])) {
1120 xmlRelaxNGFreeValidState(ctxt, state);
1130 * @ctxt: a Relax-NG validation context
1136 xmlRelaxNGFreeStates(xmlRelaxNGValidCtxtPtr ctxt,
1141 if ((ctxt != NULL) && (ctxt->freeStates == NULL)) {
1142 ctxt->freeStatesMax = 40;
1143 ctxt->freeStatesNr = 0;
1144 ctxt->freeStates = (xmlRelaxNGStatesPtr *)
1145 xmlMalloc(ctxt->freeStatesMax * sizeof(xmlRelaxNGStatesPtr));
1146 if (ctxt->freeStates == NULL) {
1147 xmlRngVErrMemory(ctxt, "storing states\n");
1149 } else if ((ctxt != NULL)
1150 && (ctxt->freeStatesNr >= ctxt->freeStatesMax)) {
1153 tmp = (xmlRelaxNGStatesPtr *) xmlRealloc(ctxt->freeStates,
1154 2 * ctxt->freeStatesMax *
1158 xmlRngVErrMemory(ctxt, "storing states\n");
1163 ctxt->freeStates = tmp;
1164 ctxt->freeStatesMax *= 2;
1166 if ((ctxt == NULL) || (ctxt->freeStates == NULL)) {
1170 ctxt->freeStates[ctxt->freeStatesNr++] = states;
1176 * @ctxt: a Relax-NG validation context
1184 xmlRelaxNGNewValidState(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node)
1193 root = xmlDocGetRootElement(ctxt->doc);
1206 if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
1207 ctxt->freeState->nbState--;
1208 ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
1214 xmlRngVErrMemory(ctxt, "allocating states\n");
1222 ret->node = (xmlNodePtr) ctxt->doc;
1238 xmlRngVErrMemory(ctxt, "allocating states\n");
1247 xmlRngVErrMemory(ctxt, "allocating states\n");
1271 * @ctxt: a Relax-NG validation context
1279 xmlRelaxNGCopyValidState(xmlRelaxNGValidCtxtPtr ctxt,
1288 if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
1289 ctxt->freeState->nbState--;
1290 ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
1296 xmlRngVErrMemory(ctxt, "allocating states\n");
1312 xmlRngVErrMemory(ctxt, "allocating states\n");
1322 xmlRngVErrMemory(ctxt, "allocating states\n");
1337 * @ctxt: a Relax-NG validation context
1346 xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
1383 xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
1389 if ((ctxt != NULL) && (ctxt->freeState == NULL)) {
1390 ctxt->freeState = xmlRelaxNGNewStates(ctxt, 40);
1392 if ((ctxt == NULL) || (ctxt->freeState == NULL)) {
1397 xmlRelaxNGAddStatesUniq(ctxt, ctxt->freeState, state);
1409 * @ctxt: a RelaxNG parser context
1418 xmlRelaxParserSetFlag(xmlRelaxNGParserCtxtPtr ctxt, int flags)
1420 if (ctxt == NULL) return(-1);
1422 ctxt->crng |= XML_RELAXNGP_FREE_DOC;
1426 ctxt->crng |= XML_RELAXNGP_CRNG;
1438 static xmlDocPtr xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt,
1443 * @ctxt: the parser context
1451 xmlRelaxNGIncludePush(xmlRelaxNGParserCtxtPtr ctxt,
1454 if (ctxt->incTab == NULL) {
1455 ctxt->incMax = 4;
1456 ctxt->incNr = 0;
1457 ctxt->incTab =
1458 (xmlRelaxNGIncludePtr *) xmlMalloc(ctxt->incMax *
1459 sizeof(ctxt->incTab[0]));
1460 if (ctxt->incTab == NULL) {
1461 xmlRngPErrMemory(ctxt, "allocating include\n");
1465 if (ctxt->incNr >= ctxt->incMax) {
1466 ctxt->incMax *= 2;
1467 ctxt->incTab =
1468 (xmlRelaxNGIncludePtr *) xmlRealloc(ctxt->incTab,
1469 ctxt->incMax *
1470 sizeof(ctxt->incTab[0]));
1471 if (ctxt->incTab == NULL) {
1472 xmlRngPErrMemory(ctxt, "allocating include\n");
1476 ctxt->incTab[ctxt->incNr] = value;
1477 ctxt->inc = value;
1478 return (ctxt->incNr++);
1483 * @ctxt: the parser context
1490 xmlRelaxNGIncludePop(xmlRelaxNGParserCtxtPtr ctxt)
1494 if (ctxt->incNr <= 0)
1496 ctxt->incNr--;
1497 if (ctxt->incNr > 0)
1498 ctxt->inc = ctxt->incTab[ctxt->incNr - 1];
1500 ctxt->inc = NULL;
1501 ret = ctxt->incTab[ctxt->incNr];
1502 ctxt->incTab[ctxt->incNr] = NULL;
1508 * @ctxt: the parser context
1518 xmlRelaxNGRemoveRedefine(xmlRelaxNGParserCtxtPtr ctxt,
1565 if (xmlRelaxNGRemoveRedefine(ctxt, href,
1584 * @ctxt: the parser context
1596 xmlRelaxNGLoadInclude(xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * URL,
1612 for (i = 0; i < ctxt->incNr; i++) {
1613 if (xmlStrEqual(ctxt->incTab[i]->href, URL)) {
1614 xmlRngPErr(ctxt, NULL, XML_RNGP_INCLUDE_RECURSE,
1626 xmlRngPErr(ctxt, node, XML_RNGP_PARSE_ERROR,
1639 xmlRngPErrMemory(ctxt, "allocating include\n");
1646 ret->next = ctxt->includes;
1647 ctxt->includes = ret;
1664 xmlRelaxNGIncludePush(ctxt, ret);
1674 doc = xmlRelaxNGCleanupDoc(ctxt, doc);
1676 ctxt->inc = NULL;
1683 xmlRelaxNGIncludePop(ctxt);
1693 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY,
1699 xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
1714 xmlRelaxNGRemoveRedefine(ctxt, URL, root->children, NULL);
1716 xmlRngPErr(ctxt, node, XML_RNGP_START_MISSING,
1725 xmlRngPErr(ctxt, node, XML_RNGP_NAME_MISSING,
1732 found = xmlRelaxNGRemoveRedefine(ctxt, URL,
1735 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_MISSING,
1751 * @ctxt: the validation context
1762 xmlRelaxNGValidErrorPush(xmlRelaxNGValidCtxtPtr ctxt,
1770 "Pushing error %d at %d on stack\n", err, ctxt->errNr);
1772 if (ctxt->errTab == NULL) {
1773 ctxt->errMax = 8;
1774 ctxt->errNr = 0;
1775 ctxt->errTab =
1776 (xmlRelaxNGValidErrorPtr) xmlMalloc(ctxt->errMax *
1779 if (ctxt->errTab == NULL) {
1780 xmlRngVErrMemory(ctxt, "pushing error\n");
1783 ctxt->err = NULL;
1785 if (ctxt->errNr >= ctxt->errMax) {
1786 ctxt->errMax *= 2;
1787 ctxt->errTab =
1788 (xmlRelaxNGValidErrorPtr) xmlRealloc(ctxt->errTab,
1789 ctxt->errMax *
1792 if (ctxt->errTab == NULL) {
1793 xmlRngVErrMemory(ctxt, "pushing error\n");
1796 ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
1798 if ((ctxt->err != NULL) && (ctxt->state != NULL) &&
1799 (ctxt->err->node == ctxt->state->node) && (ctxt->err->err == err))
1800 return (ctxt->errNr);
1801 cur = &ctxt->errTab[ctxt->errNr];
1812 if (ctxt->state != NULL) {
1813 cur->node = ctxt->state->node;
1814 cur->seq = ctxt->state->seq;
1819 ctxt->err = cur;
1820 return (ctxt->errNr++);
1825 * @ctxt: the validation context
1830 xmlRelaxNGValidErrorPop(xmlRelaxNGValidCtxtPtr ctxt)
1834 if (ctxt->errNr <= 0) {
1835 ctxt->err = NULL;
1838 ctxt->errNr--;
1839 if (ctxt->errNr > 0)
1840 ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
1842 ctxt->err = NULL;
1843 cur = &ctxt->errTab[ctxt->errNr];
1857 * @ctxt: the parser context
1865 xmlRelaxNGDocumentPush(xmlRelaxNGParserCtxtPtr ctxt,
1868 if (ctxt->docTab == NULL) {
1869 ctxt->docMax = 4;
1870 ctxt->docNr = 0;
1871 ctxt->docTab =
1872 (xmlRelaxNGDocumentPtr *) xmlMalloc(ctxt->docMax *
1873 sizeof(ctxt->docTab[0]));
1874 if (ctxt->docTab == NULL) {
1875 xmlRngPErrMemory(ctxt, "adding document\n");
1879 if (ctxt->docNr >= ctxt->docMax) {
1880 ctxt->docMax *= 2;
1881 ctxt->docTab =
1882 (xmlRelaxNGDocumentPtr *) xmlRealloc(ctxt->docTab,
1883 ctxt->docMax *
1884 sizeof(ctxt->docTab[0]));
1885 if (ctxt->docTab == NULL) {
1886 xmlRngPErrMemory(ctxt, "adding document\n");
1890 ctxt->docTab[ctxt->docNr] = value;
1891 ctxt->doc = value;
1892 return (ctxt->docNr++);
1897 * @ctxt: the parser context
1904 xmlRelaxNGDocumentPop(xmlRelaxNGParserCtxtPtr ctxt)
1908 if (ctxt->docNr <= 0)
1910 ctxt->docNr--;
1911 if (ctxt->docNr > 0)
1912 ctxt->doc = ctxt->docTab[ctxt->docNr - 1];
1914 ctxt->doc = NULL;
1915 ret = ctxt->docTab[ctxt->docNr];
1916 ctxt->docTab[ctxt->docNr] = NULL;
1922 * @ctxt: the parser context
1933 xmlRelaxNGLoadExternalRef(xmlRelaxNGParserCtxtPtr ctxt,
1944 for (i = 0; i < ctxt->docNr; i++) {
1945 if (xmlStrEqual(ctxt->docTab[i]->href, URL)) {
1946 xmlRngPErr(ctxt, NULL, XML_RNGP_EXTERNALREF_RECURSE,
1958 xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
1968 xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_ERR_NO_MEMORY,
1976 ret->next = ctxt->documents;
1978 ctxt->documents = ret;
1995 xmlRelaxNGDocumentPush(ctxt, ret);
2000 doc = xmlRelaxNGCleanupDoc(ctxt, doc);
2002 ctxt->doc = NULL;
2006 xmlRelaxNGDocumentPop(ctxt);
2017 #define VALID_ERR(a) xmlRelaxNGAddValidError(ctxt, a, NULL, NULL, 0);
2018 #define VALID_ERR2(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 0);
2019 #define VALID_ERR3(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 0);
2020 #define VALID_ERR2P(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 1);
2021 #define VALID_ERR3P(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 1);
2226 * @ctxt: the validation context
2236 xmlRelaxNGShowValidError(xmlRelaxNGValidCtxtPtr ctxt,
2243 if (ctxt->flags & FLAGS_NOERROR)
2253 if (ctxt->errNo == XML_RELAXNG_OK)
2254 ctxt->errNo = err;
2255 xmlRngVErr(ctxt, (child == NULL ? node : child), err,
2262 * @ctxt: the validation context
2268 xmlRelaxNGPopErrors(xmlRelaxNGValidCtxtPtr ctxt, int level)
2277 for (i = level; i < ctxt->errNr; i++) {
2278 err = &ctxt->errTab[i];
2289 ctxt->errNr = level;
2290 if (ctxt->errNr <= 0)
2291 ctxt->err = NULL;
2296 * @ctxt: the validation context
2301 xmlRelaxNGDumpValidError(xmlRelaxNGValidCtxtPtr ctxt)
2308 "Dumping error stack %d errors\n", ctxt->errNr);
2310 for (i = 0, k = 0; i < ctxt->errNr; i++) {
2311 err = &ctxt->errTab[i];
2314 dup = &ctxt->errTab[j];
2321 xmlRelaxNGShowValidError(ctxt, err->err, err->node, err->seq,
2336 ctxt->errNr = 0;
2341 * @ctxt: the validation context
2351 xmlRelaxNGAddValidError(xmlRelaxNGValidCtxtPtr ctxt,
2355 if (ctxt == NULL)
2357 if (ctxt->flags & FLAGS_NOERROR)
2366 if (((ctxt->flags & FLAGS_IGNORABLE) == 0) ||
2367 (ctxt->flags & FLAGS_NEGATIVE)) {
2374 if (ctxt->errNr != 0)
2375 xmlRelaxNGDumpValidError(ctxt);
2376 if (ctxt->state != NULL) {
2377 node = ctxt->state->node;
2378 seq = ctxt->state->seq;
2383 node = ctxt->pnode;
2385 xmlRelaxNGShowValidError(ctxt, err, node, seq, arg1, arg2);
2391 xmlRelaxNGValidErrorPush(ctxt, err, arg1, arg2, dup);
2401 static xmlChar *xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt,
2863 static int xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt,
3017 * ctxt: the RelaxNG parser context
3026 xmlRelaxNGCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
3031 if ((ctxt == NULL) || (def == NULL))
3037 xmlAutomataPtr oldam = ctxt->am;
3038 xmlAutomataStatePtr oldstate = ctxt->state;
3043 ctxt->am = xmlNewAutomata();
3044 if (ctxt->am == NULL)
3055 xmlAutomataSetFlags(ctxt->am, 1);
3057 ctxt->state = xmlAutomataGetInitState(ctxt->am);
3059 xmlRelaxNGCompile(ctxt, list);
3062 xmlAutomataSetFinalState(ctxt->am, ctxt->state);
3063 if (xmlAutomataIsDeterminist(ctxt->am))
3064 def->contModel = xmlAutomataCompile(ctxt->am);
3066 xmlFreeAutomata(ctxt->am);
3067 ctxt->state = oldstate;
3068 ctxt->am = oldam;
3072 if ((ctxt->am != NULL) && (def->name != NULL)) {
3073 ctxt->state = xmlAutomataNewTransition2(ctxt->am,
3074 ctxt->state, NULL,
3079 xmlAutomataPtr oldam = ctxt->am;
3080 xmlAutomataStatePtr oldstate = ctxt->state;
3085 ctxt->am = xmlNewAutomata();
3086 if (ctxt->am == NULL)
3088 xmlAutomataSetFlags(ctxt->am, 1);
3089 ctxt->state = xmlAutomataGetInitState(ctxt->am);
3091 xmlRelaxNGCompile(ctxt, list);
3094 xmlAutomataSetFinalState(ctxt->am, ctxt->state);
3095 def->contModel = xmlAutomataCompile(ctxt->am);
3108 xmlFreeAutomata(ctxt->am);
3109 ctxt->state = oldstate;
3110 ctxt->am = oldam;
3112 xmlAutomataPtr oldam = ctxt->am;
3119 ret = xmlRelaxNGTryCompile(ctxt, def);
3120 ctxt->am = oldam;
3124 ret = xmlRelaxNGCompile(ctxt, def->content);
3127 xmlAutomataStatePtr oldstate = ctxt->state;
3131 xmlRelaxNGCompile(ctxt, list);
3134 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
3140 ctxt->state =
3141 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
3142 oldstate = ctxt->state;
3145 xmlRelaxNGCompile(ctxt, list);
3148 ctxt->am, ctxt->state, oldstate);
3149 ctxt->state =
3150 xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
3158 xmlRelaxNGCompile(ctxt, list);
3161 oldstate = ctxt->state;
3164 xmlRelaxNGCompile(ctxt, list);
3167 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate);
3168 ctxt->state =
3169 xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
3174 xmlAutomataStatePtr oldstate = ctxt->state;
3178 ctxt->state = oldstate;
3179 ret = xmlRelaxNGCompile(ctxt, list);
3183 target = ctxt->state;
3185 xmlAutomataNewEpsilon(ctxt->am, ctxt->state,
3190 ctxt->state = target;
3201 ret = xmlRelaxNGCompile(ctxt, list);
3210 ctxt->state =
3211 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
3212 oldstate = ctxt->state;
3213 xmlRelaxNGCompile(ctxt, def->content);
3214 xmlAutomataNewTransition(ctxt->am, ctxt->state,
3215 ctxt->state, BAD_CAST "#text",
3217 ctxt->state =
3218 xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
3222 ctxt->state =
3223 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
3243 * ctxt: the RelaxNG parser context
3252 xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
3257 if ((ctxt == NULL) || (def == NULL))
3264 ctxt->am = NULL;
3265 ret = xmlRelaxNGCompile(ctxt, def);
3289 ret = xmlRelaxNGTryCompile(ctxt, def->content);
3312 ret = xmlRelaxNGTryCompile(ctxt, list);
3335 ctxt, xmlNodePtr node);
3337 ctxt, xmlNodePtr node);
3339 ctxt, xmlNodePtr nodes,
3342 ctxt, xmlNodePtr node);
3343 static xmlRelaxNGPtr xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt,
3345 static int xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
3348 ctxt, xmlNodePtr node,
3352 ctxt, xmlNodePtr nodes);
3353 static int xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
3462 * @ctxt: a Relax-NG parser context
3470 xmlRelaxNGGetDataTypeLibrary(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
3515 * @ctxt: a Relax-NG parser context
3523 xmlRelaxNGParseValue(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
3531 def = xmlRelaxNGNewDefine(ctxt, node);
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,
3579 xmlRngPErr(ctxt, node, XML_RNGP_TEXT_EXPECTED,
3585 xmlRngPErr(ctxt, node, XML_RNGP_VALUE_NO_CONTENT,
3593 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_VALUE,
3607 * @ctxt: a Relax-NG parser context
3615 xmlRelaxNGParseData(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
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,
3676 ctxt->idref = 1;
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);
3735 xmlRngPErr(ctxt, content, XML_RNGP_EXCEPT_NO_CONTENT,
3739 tmp2 = xmlRelaxNGParsePattern(ctxt, child);
3756 xmlRngPErr(ctxt, content, XML_RNGP_DATA_CONTENT,
3786 xmlRelaxNGValidCtxt ctxt;
3788 memset(&ctxt, 0, sizeof(xmlRelaxNGValidCtxt));
3790 ctxt.flags = FLAGS_IGNORABLE | FLAGS_NOERROR;
3811 if (xmlRelaxNGElementMatch(&ctxt, def2, &node)) {
3852 if (xmlRelaxNGElementMatch(&ctxt, def1, &node)) {
3870 * @ctxt: a Relax-NG parser context
3881 xmlRelaxNGCompareElemDefLists(xmlRelaxNGParserCtxtPtr ctxt
3905 * @ctxt: a Relax-NG parser context
3913 xmlRelaxNGGenerateAttributes(xmlRelaxNGParserCtxtPtr ctxt,
3922 if (ctxt->nbErrors != 0)
3980 * @ctxt: a Relax-NG parser context
3989 xmlRelaxNGGetElements(xmlRelaxNGParserCtxtPtr ctxt,
4000 if (ctxt->nbErrors != 0)
4014 xmlRngPErrMemory(ctxt, "getting element list\n");
4024 xmlRngPErrMemory(ctxt, "getting element list\n");
4080 * @ctxt: a Relax-NG parser context
4086 xmlRelaxNGCheckChoiceDeterminism(xmlRelaxNGParserCtxtPtr ctxt,
4107 if (ctxt->nbErrors != 0)
4122 xmlRngPErrMemory(ctxt, "building choice\n");
4136 list[i] = xmlRelaxNGGetElements(ctxt, cur, 0);
4190 ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
4216 * @ctxt: a Relax-NG parser context
4222 xmlRelaxNGCheckGroupAttrs(xmlRelaxNGParserCtxtPtr ctxt,
4241 if (ctxt->nbErrors != 0)
4259 xmlRngPErrMemory(ctxt, "building group\n");
4265 list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
4271 list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
4282 ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
4284 xmlRngPErr(ctxt, def->node, XML_RNGP_GROUP_ATTR_CONFLICT,
4301 * @ctxt: a Relax-NG parser context
4318 xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
4334 if (ctxt->nbErrors != 0)
4363 groups[nbgroups]->defs = xmlRelaxNGGetElements(ctxt, cur, 0);
4364 groups[nbgroups]->attrs = xmlRelaxNGGetElements(ctxt, cur, 1);
4388 ret = xmlRelaxNGCompareElemDefLists(ctxt, group->defs,
4391 xmlRngPErr(ctxt, def->node, XML_RNGP_ELEM_TEXT_CONFLICT,
4395 ret = xmlRelaxNGCompareElemDefLists(ctxt, group->attrs,
4398 xmlRngPErr(ctxt, def->node, XML_RNGP_ATTR_CONFLICT,
4461 xmlRngPErrMemory(ctxt, "in interleave computation\n");
4476 * @ctxt: a Relax-NG parser context
4484 xmlRelaxNGParseInterleave(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4490 def = xmlRelaxNGNewDefine(ctxt, node);
4496 if (ctxt->interleaves == NULL)
4497 ctxt->interleaves = xmlHashCreate(10);
4498 if (ctxt->interleaves == NULL) {
4499 xmlRngPErrMemory(ctxt, "create interleaves\n");
4503 snprintf(name, 32, "interleave%d", ctxt->nbInterleaves++);
4504 if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST name, def) < 0) {
4505 xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_ADD,
4512 xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_NO_CONTENT,
4517 cur = xmlRelaxNGParseElement(ctxt, child);
4519 cur = xmlRelaxNGParsePattern(ctxt, child);
4538 * @ctxt: a Relax-NG parser context
4546 xmlRelaxNGParseInclude(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4554 xmlRngPErr(ctxt, node, XML_RNGP_INCLUDE_EMPTY,
4560 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY, "Include document is empty\n",
4565 xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
4574 tmp = xmlRelaxNGParseGrammarContent(ctxt, root->children);
4579 tmp = xmlRelaxNGParseGrammarContent(ctxt, node->children);
4588 * @ctxt: a Relax-NG parser context
4596 xmlRelaxNGParseDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4605 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_NAME_MISSING,
4610 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_DEFINE_NAME,
4613 def = xmlRelaxNGNewDefine(ctxt, node);
4621 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_EMPTY,
4624 olddefine = ctxt->define;
4625 ctxt->define = name;
4627 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4628 ctxt->define = olddefine;
4630 if (ctxt->grammar->defs == NULL)
4631 ctxt->grammar->defs = xmlHashCreate(10);
4632 if (ctxt->grammar->defs == NULL) {
4633 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
4637 tmp = xmlHashAddEntry(ctxt->grammar->defs, name, def);
4641 prev = xmlHashLookup(ctxt->grammar->defs, name);
4643 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
4668 xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
4674 tmp = xmlHashAddEntry(ctxt->grammar->refs, name, def);
4679 xmlHashLookup(ctxt->grammar->refs, def->name);
4682 xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
4686 xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
4699 * @ctxt: the parser context
4707 xmlRelaxNGParseImportRefs(xmlRelaxNGParserCtxtPtr ctxt,
4709 if ((ctxt == NULL) || (grammar == NULL) || (ctxt->grammar == NULL))
4713 if (ctxt->grammar->refs == NULL)
4714 ctxt->grammar->refs = xmlHashCreate(10);
4715 if (ctxt->grammar->refs == NULL) {
4716 xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
4720 xmlHashScan(grammar->refs, xmlRelaxNGParseImportRef, ctxt);
4726 * @ctxt: the parser context
4734 xmlRelaxNGProcessExternalRef(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4744 def = xmlRelaxNGNewDefine(ctxt, node);
4755 xmlRngPErr(ctxt, node, XML_RNGP_EXTERNALREF_EMTPY,
4756 "xmlRelaxNGParse: %s is empty\n", ctxt->URL,
4785 oldflags = ctxt->flags;
4786 ctxt->flags |= XML_RELAXNG_IN_EXTERNALREF;
4787 docu->schema = xmlRelaxNGParseDocument(ctxt, root);
4788 ctxt->flags = oldflags;
4793 xmlRelaxNGParseImportRefs(ctxt, docu->schema->topgrammar);
4812 * @ctxt: a Relax-NG parser context
4821 xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4829 def = xmlRelaxNGParseElement(ctxt, node);
4831 def = xmlRelaxNGParseAttribute(ctxt, node);
4833 def = xmlRelaxNGNewDefine(ctxt, node);
4838 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_NOT_EMPTY,
4842 def = xmlRelaxNGNewDefine(ctxt, node);
4847 xmlRngPErr(ctxt, node, XML_RNGP_TEXT_HAS_CHILD,
4851 def = xmlRelaxNGNewDefine(ctxt, node);
4856 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4860 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4863 def = xmlRelaxNGNewDefine(ctxt, node);
4868 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4872 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4875 def = xmlRelaxNGNewDefine(ctxt, node);
4880 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4884 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4887 def = xmlRelaxNGNewDefine(ctxt, node);
4892 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4896 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4899 def = xmlRelaxNGNewDefine(ctxt, node);
4904 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4908 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4911 def = xmlRelaxNGNewDefine(ctxt, node);
4917 xmlRngPErr(ctxt, node, XML_RNGP_REF_NO_NAME, "ref has no name\n",
4922 xmlRngPErr(ctxt, node, XML_RNGP_REF_NAME_INVALID,
4928 xmlRngPErr(ctxt, node, XML_RNGP_REF_NOT_EMPTY, "ref is not empty\n",
4931 if (ctxt->grammar->refs == NULL)
4932 ctxt->grammar->refs = xmlHashCreate(10);
4933 if (ctxt->grammar->refs == NULL) {
4934 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4940 tmp = xmlHashAddEntry(ctxt->grammar->refs, def->name, def);
4945 xmlHashLookup(ctxt->grammar->refs, def->name);
4948 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4952 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4964 def = xmlRelaxNGParseData(ctxt, node);
4966 def = xmlRelaxNGParseValue(ctxt, node);
4968 def = xmlRelaxNGNewDefine(ctxt, node);
4973 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4977 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4980 def = xmlRelaxNGParseInterleave(ctxt, node);
4982 def = xmlRelaxNGProcessExternalRef(ctxt, node);
4984 def = xmlRelaxNGNewDefine(ctxt, node);
4989 xmlRngPErr(ctxt, node, XML_RNGP_NOTALLOWED_NOT_EMPTY,
5002 oldparent = ctxt->parentgrammar;
5003 old = ctxt->grammar;
5004 ctxt->parentgrammar = old;
5005 grammar = xmlRelaxNGParseGrammar(ctxt, node->children);
5007 ctxt->grammar = old;
5008 ctxt->parentgrammar = oldparent;
5021 if (ctxt->parentgrammar == NULL) {
5022 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_PARENT,
5027 def = xmlRelaxNGNewDefine(ctxt, node);
5033 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_NAME,
5038 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NAME_INVALID,
5044 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NOT_EMPTY,
5047 if (ctxt->parentgrammar->refs == NULL)
5048 ctxt->parentgrammar->refs = xmlHashCreate(10);
5049 if (ctxt->parentgrammar->refs == NULL) {
5050 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
5057 xmlHashAddEntry(ctxt->parentgrammar->refs, def->name, def);
5062 xmlHashLookup(ctxt->parentgrammar->refs, def->name);
5064 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
5076 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, "Mixed is empty\n",
5080 def = xmlRelaxNGParseInterleave(ctxt, node);
5085 tmp = xmlRelaxNGNewDefine(ctxt, node);
5093 tmp = xmlRelaxNGNewDefine(ctxt, node);
5102 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_CONSTRUCT,
5112 * @ctxt: a Relax-NG parser context
5120 xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
5126 ret = xmlRelaxNGNewDefine(ctxt, node);
5130 ret->parent = ctxt->def;
5133 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_EMPTY,
5138 old_flags = ctxt->flags;
5139 ctxt->flags |= XML_RELAXNG_IN_ATTRIBUTE;
5140 cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
5145 cur = xmlRelaxNGParsePattern(ctxt, child);
5172 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CONTENT,
5177 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_NOOP,
5186 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CHILDREN,
5189 ctxt->flags = old_flags;
5195 * @ctxt: a Relax-NG parser context
5204 xmlRelaxNGParseExceptNameClass(xmlRelaxNGParserCtxtPtr ctxt,
5211 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MISSING,
5216 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MULTIPLE,
5221 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_EMPTY, "except has no content\n",
5226 ret = xmlRelaxNGNewDefine(ctxt, node);
5232 cur = xmlRelaxNGNewDefine(ctxt, child);
5240 if (xmlRelaxNGParseNameClass(ctxt, child, cur) != NULL) {
5256 * @ctxt: a Relax-NG parser context
5265 xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node,
5276 ret = xmlRelaxNGNewDefine(ctxt, node);
5280 if (ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE)
5291 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
5295 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
5302 if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
5305 xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
5309 if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
5312 xmlRngPErr(ctxt, node, XML_RNGP_XMLNS_NAME,
5321 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
5329 xmlRngPErr(ctxt, node, XML_RNGP_NSNAME_NO_NS,
5332 if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
5336 xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
5342 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
5350 ret = xmlRelaxNGNewDefine(ctxt, node);
5357 xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_EMPTY,
5363 tmp = xmlRelaxNGParseNameClass(ctxt, child, ret);
5376 xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_CONTENT,
5398 * @ctxt: a Relax-NG parser context
5406 xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
5412 ret = xmlRelaxNGNewDefine(ctxt, node);
5416 ret->parent = ctxt->def;
5419 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_EMPTY,
5424 cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
5429 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NO_CONTENT,
5434 olddefine = ctxt->define;
5435 ctxt->define = NULL;
5438 cur = xmlRelaxNGParsePattern(ctxt, child);
5464 ret->content = xmlRelaxNGNewDefine(ctxt, node);
5481 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5486 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5491 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5496 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5504 ctxt->define = olddefine;
5510 * @ctxt: a Relax-NG parser context
5519 xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes,
5524 parent = ctxt->def;
5527 cur = xmlRelaxNGParseElement(ctxt, nodes);
5533 def = xmlRelaxNGNewDefine(ctxt, nodes);
5542 cur = xmlRelaxNGParsePattern(ctxt, nodes);
5559 * @ctxt: a Relax-NG parser context
5567 xmlRelaxNGParseStart(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
5573 xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY, "start has no children\n",
5578 def = xmlRelaxNGNewDefine(ctxt, nodes);
5583 xmlRngPErr(ctxt, nodes, XML_RNGP_EMPTY_CONTENT,
5587 def = xmlRelaxNGNewDefine(ctxt, nodes);
5592 xmlRngPErr(ctxt, nodes, XML_RNGP_NOTALLOWED_NOT_EMPTY,
5596 def = xmlRelaxNGParsePatterns(ctxt, nodes, 1);
5598 if (ctxt->grammar->start != NULL) {
5599 last = ctxt->grammar->start;
5604 ctxt->grammar->start = def;
5608 xmlRngPErr(ctxt, nodes, XML_RNGP_START_CONTENT,
5617 * @ctxt: a Relax-NG parser context
5625 xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
5631 xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_EMPTY,
5638 xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY,
5641 tmp = xmlRelaxNGParseStart(ctxt, nodes->children);
5646 tmp = xmlRelaxNGParseDefine(ctxt, nodes);
5650 tmp = xmlRelaxNGParseInclude(ctxt, nodes);
5654 xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
5667 * @ctxt: a Relax-NG parser context
5677 xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
5687 grammar = ctxt->grammar;
5689 xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
5695 xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
5709 xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
5714 xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
5723 * @ctxt: a Relax-NG parser context
5733 xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
5749 xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
5757 xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
5762 xmlRngPErr(ctxt, define->node, XML_RNGP_UNKNOWN_COMBINE,
5771 xmlRngPErr(ctxt, define->node, XML_RNGP_NEED_COMBINE,
5786 cur = xmlRelaxNGNewDefine(ctxt, define->node);
5801 tmp2 = xmlRelaxNGNewDefine(ctxt, tmp->content->node);
5821 if (ctxt->interleaves == NULL)
5822 ctxt->interleaves = xmlHashCreate(10);
5823 if (ctxt->interleaves == NULL) {
5824 xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5830 snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
5831 if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
5833 xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5843 * @ctxt: a Relax-NG parser context
5850 xmlRelaxNGCombineStart(xmlRelaxNGParserCtxtPtr ctxt,
5867 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_MISSING,
5879 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
5887 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
5892 xmlRngPErr(ctxt, cur->node, XML_RNGP_UNKNOWN_COMBINE,
5901 xmlRngPErr(ctxt, cur->node, XML_RNGP_NEED_COMBINE,
5916 cur = xmlRelaxNGNewDefine(ctxt, starts->node);
5926 if (ctxt->interleaves == NULL)
5927 ctxt->interleaves = xmlHashCreate(10);
5928 if (ctxt->interleaves == NULL) {
5929 xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5935 snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
5936 if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
5938 xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5948 * @ctxt: a Relax-NG parser context
5957 xmlRelaxNGCheckCycles(xmlRelaxNGParserCtxtPtr ctxt,
5967 ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
5970 xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_CYCLE,
5976 ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth + 1);
5978 ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
5987 * @ctxt: a Relax-NG parser context
5997 xmlRelaxNGTryUnlink(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
6021 * @ctxt: a Relax-NG parser context
6027 xmlRelaxNGSimplify(xmlRelaxNGParserCtxtPtr ctxt,
6037 xmlRelaxNGSimplify(ctxt, cur->content, cur);
6052 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6066 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6072 xmlRelaxNGSimplify(ctxt, cur->content, cur);
6074 xmlRelaxNGSimplify(ctxt, cur->attrs, cur);
6076 xmlRelaxNGSimplify(ctxt, cur->nameClass, cur);
6087 xmlRelaxNGGenerateAttributes(ctxt, cur->content);
6106 attronly = xmlRelaxNGGenerateAttributes(ctxt, tmp);
6146 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6160 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6174 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6238 * @ctxt: a Relax-NG parser context
6248 xmlRelaxNGCheckRules(xmlRelaxNGParserCtxtPtr ctxt,
6266 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_REF,
6272 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_REF,
6278 xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF,
6282 xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF,
6288 ret = xmlRelaxNGCheckRules(ctxt, cur->content,
6300 xmlRelaxNGCheckGroupAttrs(ctxt, cur);
6302 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ELEM,
6307 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ELEM,
6312 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
6317 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
6327 xmlRelaxNGCheckRules(ctxt, cur->attrs, nflags, cur->type);
6329 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_EMPTY,
6334 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6337 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_ERROR,
6345 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ATTR,
6350 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ATTR,
6355 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_GROUP_ATTR,
6360 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
6365 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ATTR,
6370 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ATTR,
6377 xmlRngPErr(ctxt, cur->node, XML_RNGP_ANYNAME_ATTR_ANCESTOR,
6381 xmlRngPErr(ctxt, cur->node, XML_RNGP_NSNAME_ATTR_ANCESTOR,
6387 xmlRelaxNGCheckRules(ctxt, cur->content, nflags, cur->type);
6392 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ONEMORE,
6397 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ONEMORE,
6403 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6408 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_LIST,
6413 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_LIST,
6418 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_LIST,
6424 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6428 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_GROUP,
6433 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_GROUP,
6442 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6447 xmlRelaxNGCheckGroupAttrs(ctxt, cur);
6450 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_INTERLEAVE,
6455 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
6460 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
6469 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6478 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6482 ctxt, cur->node, XML_RNGP_PAT_START_DATA,
6486 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6490 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_VALUE,
6494 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6498 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_TEXT,
6503 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_TEXT,
6508 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_TEXT,
6515 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_EMPTY,
6520 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_EMPTY,
6526 xmlRelaxNGCheckChoiceDeterminism(ctxt, cur);
6528 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6531 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6563 * @ctxt: a Relax-NG parser context
6572 xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
6580 ret = xmlRelaxNGNewGrammar(ctxt);
6587 ret->parent = ctxt->grammar;
6588 if (ctxt->grammar != NULL) {
6589 tmp = ctxt->grammar->children;
6591 ctxt->grammar->children = ret;
6599 old = ctxt->grammar;
6600 ctxt->grammar = ret;
6601 xmlRelaxNGParseGrammarContent(ctxt, nodes);
6602 ctxt->grammar = ret;
6603 if (ctxt->grammar == NULL) {
6604 xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
6606 } else if (ctxt->grammar->start == NULL) {
6607 xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_NO_START,
6614 xmlRelaxNGCombineStart(ctxt, ret);
6616 xmlHashScan(ret->defs, xmlRelaxNGCheckCombine, ctxt);
6623 xmlHashScan(ret->refs, xmlRelaxNGCheckReference, ctxt);
6629 ctxt->grammar = old;
6635 * @ctxt: a Relax-NG parser context
6645 xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
6651 if ((ctxt == NULL) || (node == NULL))
6654 schema = xmlRelaxNGNewRelaxNG(ctxt);
6658 olddefine = ctxt->define;
6659 ctxt->define = NULL;
6661 schema->topgrammar = xmlRelaxNGParseGrammar(ctxt, node->children);
6669 schema->topgrammar = ret = xmlRelaxNGNewGrammar(ctxt);
6677 ret->parent = ctxt->grammar;
6678 if (ctxt->grammar != NULL) {
6679 tmp = ctxt->grammar->children;
6681 ctxt->grammar->children = ret;
6688 old = ctxt->grammar;
6689 ctxt->grammar = ret;
6690 xmlRelaxNGParseStart(ctxt, node);
6692 ctxt->grammar = old;
6694 ctxt->define = olddefine;
6696 xmlRelaxNGCheckCycles(ctxt, schema->topgrammar->start, 0);
6697 if ((ctxt->flags & XML_RELAXNG_IN_EXTERNALREF) == 0) {
6698 xmlRelaxNGSimplify(ctxt, schema->topgrammar->start, NULL);
6704 xmlRelaxNGCheckRules(ctxt, schema->topgrammar->start,
6822 * @ctxt: the schema parser context
6827 xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxtPtr ctxt)
6829 if (ctxt == NULL)
6831 if (ctxt->URL != NULL)
6832 xmlFree(ctxt->URL);
6833 if (ctxt->doc != NULL)
6834 xmlRelaxNGFreeDocument(ctxt->doc);
6835 if (ctxt->interleaves != NULL)
6836 xmlHashFree(ctxt->interleaves, NULL);
6837 if (ctxt->documents != NULL)
6838 xmlRelaxNGFreeDocumentList(ctxt->documents);
6839 if (ctxt->includes != NULL)
6840 xmlRelaxNGFreeIncludeList(ctxt->includes);
6841 if (ctxt->docTab != NULL)
6842 xmlFree(ctxt->docTab);
6843 if (ctxt->incTab != NULL)
6844 xmlFree(ctxt->incTab);
6845 if (ctxt->defTab != NULL) {
6848 for (i = 0; i < ctxt->defNr; i++)
6849 xmlRelaxNGFreeDefine(ctxt->defTab[i]);
6850 xmlFree(ctxt->defTab);
6852 if ((ctxt->document != NULL) && (ctxt->freedoc))
6853 xmlFreeDoc(ctxt->document);
6854 xmlFree(ctxt);
6911 * @ctxt: a Relax-NG parser context
6917 xmlRelaxNGCleanupAttributes(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
6933 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6940 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6947 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6954 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6967 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_URI,
6972 xmlRngPErr(ctxt, node, XML_RNGP_URI_NOT_ABSOLUTE,
6977 xmlRngPErr(ctxt, node, XML_RNGP_URI_FRAGMENT,
6987 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_ATTRIBUTE,
6998 * @ctxt: a Relax-NG parser context
7005 xmlRelaxNGCleanupTree(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr root)
7028 xmlRngPErr(ctxt, cur, XML_RNGP_FOREIGN_ELEMENT,
7035 xmlRelaxNGCleanupAttributes(ctxt, cur);
7055 xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
7065 xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
7076 xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
7091 xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
7107 docu = xmlRelaxNGLoadExternalRef(ctxt, URL, ns);
7109 xmlRngPErr(ctxt, cur, XML_RNGP_EXTERNAL_REF_FAILURE,
7129 xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
7138 xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
7163 incl = xmlRelaxNGLoadInclude(ctxt, URL, cur, ns);
7167 xmlRngPErr(ctxt, cur, XML_RNGP_INCLUDE_FAILURE,
7205 xmlRngPErr(ctxt, cur, XML_RNGP_CREATE_FAILURE,
7264 xmlRngPErr(ctxt, cur,
7283 if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
7284 xmlRngPErr(ctxt, cur,
7292 int oldflags = ctxt->flags;
7300 ctxt->flags |= XML_RELAXNG_IN_ANYEXCEPT;
7301 xmlRelaxNGCleanupTree(ctxt, cur);
7302 ctxt->flags = oldflags;
7307 ctxt->flags |= XML_RELAXNG_IN_NSEXCEPT;
7308 xmlRelaxNGCleanupTree(ctxt, cur);
7309 ctxt->flags = oldflags;
7316 if (ctxt->flags & XML_RELAXNG_IN_ANYEXCEPT) {
7317 xmlRngPErr(ctxt, cur,
7321 } else if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
7322 xmlRngPErr(ctxt, cur,
7439 * @ctxt: a Relax-NG parser context
7448 xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt, xmlDocPtr doc)
7457 xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
7458 ctxt->URL, NULL);
7461 xmlRelaxNGCleanupTree(ctxt, root);
7467 * @ctxt: a Relax-NG parser context
7476 xmlRelaxNGParse(xmlRelaxNGParserCtxtPtr ctxt)
7484 if (ctxt == NULL)
7490 if (ctxt->URL != NULL) {
7491 doc = xmlReadFile((const char *) ctxt->URL,NULL,0);
7493 xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
7494 "xmlRelaxNGParse: could not load %s\n", ctxt->URL,
7498 } else if (ctxt->buffer != NULL) {
7499 doc = xmlReadMemory(ctxt->buffer, ctxt->size,NULL,NULL,0);
7501 xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
7507 ctxt->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
7508 } else if (ctxt->document != NULL) {
7509 doc = ctxt->document;
7511 xmlRngPErr(ctxt, NULL, XML_RNGP_EMPTY,
7515 ctxt->document = doc;
7520 doc = xmlRelaxNGCleanupDoc(ctxt, doc);
7522 xmlFreeDoc(ctxt->document);
7523 ctxt->document = NULL;
7532 xmlRngPErr(ctxt, (xmlNodePtr) doc,
7534 (ctxt->URL ? ctxt->URL : BAD_CAST "schemas"), NULL);
7536 xmlFreeDoc(ctxt->document);
7537 ctxt->document = NULL;
7540 ret = xmlRelaxNGParseDocument(ctxt, root);
7542 xmlFreeDoc(ctxt->document);
7543 ctxt->document = NULL;
7553 if (ctxt->interleaves != NULL) {
7554 xmlHashScan(ctxt->interleaves, xmlRelaxNGComputeInterleaves, ctxt);
7560 if (ctxt->nbErrors > 0) {
7562 ctxt->document = NULL;
7574 def = xmlRelaxNGNewDefine(ctxt, NULL);
7581 xmlRelaxNGTryCompile(ctxt, ret->topgrammar->start);
7588 ctxt->document = NULL;
7589 ret->documents = ctxt->documents;
7590 ctxt->documents = NULL;
7592 ret->includes = ctxt->includes;
7593 ctxt->includes = NULL;
7594 ret->defNr = ctxt->defNr;
7595 ret->defTab = ctxt->defTab;
7596 ctxt->defTab = NULL;
7597 if (ctxt->idref == 1)
7605 * @ctxt: a Relax-NG validation context
7613 xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
7617 if (ctxt == NULL)
7619 ctxt->error = err;
7620 ctxt->warning = warn;
7621 ctxt->serror = NULL;
7622 ctxt->userData = ctx;
7627 * @ctxt: a Relax-NG validation context
7637 xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
7641 if (ctxt == NULL)
7644 *err = ctxt->error;
7646 *warn = ctxt->warning;
7648 *ctx = ctxt->userData;
7654 * @ctxt: a Relax-NG parser context
7661 xmlRelaxNGSetParserStructuredErrors(xmlRelaxNGParserCtxtPtr ctxt,
7665 if (ctxt == NULL)
7667 ctxt->serror = serror;
7668 ctxt->error = NULL;
7669 ctxt->warning = NULL;
7670 ctxt->userData = ctx;
7916 static int xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
7933 xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata;
7941 if (ctxt == NULL) {
7949 if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
7950 ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
7953 if ((ctxt == NULL) || (define == NULL)) {
7955 if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
7956 ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
7960 if (ctxt->errNo == XML_RELAXNG_OK)
7961 ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
7964 ret = xmlRelaxNGValidateDefinition(ctxt, define);
7966 ctxt->perr = ret;
7971 * @ctxt: the RelaxNG validation context
7980 xmlRelaxNGValidateCompiledContent(xmlRelaxNGValidCtxtPtr ctxt,
7988 if ((ctxt == NULL) || (regexp == NULL))
7990 oldperr = ctxt->perr;
7992 xmlRelaxNGValidateCompiledCallback, ctxt);
7993 ctxt->perr = 0;
7996 ctxt->state->seq = cur;
8002 ret = xmlRegExecPushString(exec, BAD_CAST "#text", ctxt);
8011 cur->ns->href, ctxt);
8013 ret = xmlRegExecPushString(exec, cur->name, ctxt);
8032 ctxt->state->seq = NULL;
8039 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
8040 xmlRelaxNGDumpValidError(ctxt);
8049 if ((ret == 0) && (ctxt->perr != 0)) {
8050 ret = ctxt->perr;
8052 ctxt->perr = oldperr;
8061 static int xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
8063 static int xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt,
8065 static void xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt);
8069 * @ctxt: the validation context
8077 xmlRelaxNGElemPush(xmlRelaxNGValidCtxtPtr ctxt, xmlRegExecCtxtPtr exec)
8079 if (ctxt->elemTab == NULL) {
8080 ctxt->elemMax = 10;
8081 ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlMalloc(ctxt->elemMax *
8084 if (ctxt->elemTab == NULL) {
8085 xmlRngVErrMemory(ctxt, "validating\n");
8089 if (ctxt->elemNr >= ctxt->elemMax) {
8090 ctxt->elemMax *= 2;
8091 ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlRealloc(ctxt->elemTab,
8092 ctxt->elemMax *
8095 if (ctxt->elemTab == NULL) {
8096 xmlRngVErrMemory(ctxt, "validating\n");
8100 ctxt->elemTab[ctxt->elemNr++] = exec;
8101 ctxt->elem = exec;
8107 * @ctxt: the validation context
8114 xmlRelaxNGElemPop(xmlRelaxNGValidCtxtPtr ctxt)
8118 if (ctxt->elemNr <= 0)
8120 ctxt->elemNr--;
8121 ret = ctxt->elemTab[ctxt->elemNr];
8122 ctxt->elemTab[ctxt->elemNr] = NULL;
8123 if (ctxt->elemNr > 0)
8124 ctxt->elem = ctxt->elemTab[ctxt->elemNr - 1];
8126 ctxt->elem = NULL;
8146 xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata;
8156 if (ctxt == NULL) {
8160 node = ctxt->pnode;
8161 ctxt->pstate = 1;
8166 if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
8167 ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
8168 ctxt->pstate = -1;
8171 if ((ctxt == NULL) || (define == NULL)) {
8173 if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
8174 ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
8175 ctxt->pstate = -1;
8179 if (ctxt->errNo == XML_RELAXNG_OK)
8180 ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
8181 ctxt->pstate = -1;
8186 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
8187 xmlRelaxNGDumpValidError(ctxt);
8188 ctxt->pstate = -1;
8200 ctxt->pstate = 0;
8201 ctxt->pdef = define;
8205 xmlRelaxNGValidateProgressiveCallback, ctxt);
8207 ctxt->pstate = -1;
8210 xmlRelaxNGElemPush(ctxt, exec);
8215 state = xmlRelaxNGNewValidState(ctxt, node);
8217 ctxt->pstate = -1;
8220 oldstate = ctxt->state;
8221 ctxt->state = state;
8223 ret = xmlRelaxNGValidateAttributeList(ctxt, define->attrs);
8225 ctxt->pstate = -1;
8229 if (ctxt->state != NULL) {
8230 ctxt->state->seq = NULL;
8231 ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
8233 ctxt->pstate = -1;
8235 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
8236 } else if (ctxt->states != NULL) {
8239 oldflags = ctxt->flags;
8241 for (i = 0; i < ctxt->states->nbState; i++) {
8242 state = ctxt->states->tabState[i];
8243 ctxt->state = state;
8244 ctxt->state->seq = NULL;
8246 if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
8255 ctxt->flags |= FLAGS_IGNORABLE;
8256 xmlRelaxNGLogBestError(ctxt);
8258 for (i = 0; i < ctxt->states->nbState; i++) {
8259 xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[i]);
8261 xmlRelaxNGFreeStates(ctxt, ctxt->states);
8262 ctxt->states = NULL;
8264 ctxt->pstate = -1;
8265 ctxt->flags = oldflags;
8267 if (ctxt->pstate == -1) {
8268 if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
8269 xmlRelaxNGDumpValidError(ctxt);
8272 ctxt->state = oldstate;
8277 * @ctxt: the validation context
8287 xmlRelaxNGValidatePushElement(xmlRelaxNGValidCtxtPtr ctxt,
8293 if ((ctxt == NULL) || (elem == NULL))
8299 if (ctxt->elem == 0) {
8305 schema = ctxt->schema;
8317 ctxt->pdef = define;
8322 ctxt);
8326 xmlRelaxNGElemPush(ctxt, exec);
8328 ctxt->pnode = elem;
8329 ctxt->pstate = 0;
8332 xmlRegExecPushString2(ctxt->elem, elem->name, elem->ns->href,
8333 ctxt);
8335 ret = xmlRegExecPushString(ctxt->elem, elem->name, ctxt);
8340 if (ctxt->pstate == 0)
8342 else if (ctxt->pstate < 0)
8357 * @ctxt: the RelaxNG validation context
8366 xmlRelaxNGValidatePushCData(xmlRelaxNGValidCtxtPtr ctxt,
8371 if ((ctxt == NULL) || (ctxt->elem == NULL) || (data == NULL))
8386 ret = xmlRegExecPushString(ctxt->elem, BAD_CAST "#text", ctxt);
8400 * @ctxt: the RelaxNG validation context
8409 xmlRelaxNGValidatePopElement(xmlRelaxNGValidCtxtPtr ctxt,
8416 if ((ctxt == NULL) || (ctxt->elem == NULL) || (elem == NULL))
8424 exec = xmlRelaxNGElemPop(ctxt);
8448 * @ctxt: the validation context
8458 xmlRelaxNGValidateFullElement(xmlRelaxNGValidCtxtPtr ctxt,
8465 if ((ctxt == NULL) || (ctxt->pdef == NULL) || (elem == NULL))
8470 state = xmlRelaxNGNewValidState(ctxt, elem->parent);
8475 ctxt->state = state;
8476 ctxt->errNo = XML_RELAXNG_OK;
8477 ret = xmlRelaxNGValidateDefinition(ctxt, ctxt->pdef);
8478 if ((ret != 0) || (ctxt->errNo != XML_RELAXNG_OK))
8482 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
8483 ctxt->state = NULL;
8497 static int xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
8502 * @ctxt: a schema validation context
8510 xmlRelaxNGSkipIgnored(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
8523 ((ctxt->flags & FLAGS_MIXED_CONTENT) ||
8532 * @ctxt: a schema validation context
8541 xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt, const xmlChar * str)
8556 xmlRngVErrMemory(ctxt, "validating\n");
8578 * @ctxt: a Relax-NG validation context
8588 xmlRelaxNGValidateDatatype(xmlRelaxNGValidCtxtPtr ctxt,
8637 oldvalue = ctxt->state->value;
8638 oldendvalue = ctxt->state->endvalue;
8639 ctxt->state->value = (xmlChar *) value;
8640 ctxt->state->endvalue = NULL;
8641 ret = xmlRelaxNGValidateValue(ctxt, define->content);
8642 ctxt->state->value = (xmlChar *) oldvalue;
8643 ctxt->state->endvalue = (xmlChar *) oldendvalue;
8652 * @ctxt: a Relax-NG validation context
8659 xmlRelaxNGNextValue(xmlRelaxNGValidCtxtPtr ctxt)
8663 cur = ctxt->state->value;
8664 if ((cur == NULL) || (ctxt->state->endvalue == NULL)) {
8665 ctxt->state->value = NULL;
8666 ctxt->state->endvalue = NULL;
8671 while ((cur != ctxt->state->endvalue) && (*cur == 0))
8673 if (cur == ctxt->state->endvalue)
8674 ctxt->state->value = NULL;
8676 ctxt->state->value = cur;
8682 * @ctxt: a Relax-NG validation context
8690 xmlRelaxNGValidateValueList(xmlRelaxNGValidCtxtPtr ctxt,
8696 ret = xmlRelaxNGValidateValue(ctxt, defines);
8706 * @ctxt: a Relax-NG validation context
8714 xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
8720 value = ctxt->state->value;
8745 value, ctxt->state->node);
8764 nval = xmlRelaxNGNormalize(ctxt, define->value);
8765 nvalue = xmlRelaxNGNormalize(ctxt, value);
8777 xmlRelaxNGNextValue(ctxt);
8781 ret = xmlRelaxNGValidateDatatype(ctxt, value, define,
8782 ctxt->state->seq);
8784 xmlRelaxNGNextValue(ctxt);
8792 oldflags = ctxt->flags;
8793 ctxt->flags |= FLAGS_IGNORABLE;
8795 oldvalue = ctxt->state->value;
8797 ret = xmlRelaxNGValidateValue(ctxt, list);
8801 ctxt->state->value = oldvalue;
8804 ctxt->flags = oldflags;
8806 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
8807 xmlRelaxNGDumpValidError(ctxt);
8809 if (ctxt->errNr > 0)
8810 xmlRelaxNGPopErrors(ctxt, 0);
8822 oldvalue = ctxt->state->value;
8823 oldend = ctxt->state->endvalue;
8852 ctxt->state->endvalue = cur;
8854 while ((*cur == 0) && (cur != ctxt->state->endvalue))
8857 ctxt->state->value = cur;
8860 if (ctxt->state->value == ctxt->state->endvalue)
8861 ctxt->state->value = NULL;
8862 ret = xmlRelaxNGValidateValue(ctxt, list);
8867 ctxt->state->value, nb_values);
8877 if ((ret == 0) && (ctxt->state->value != NULL) &&
8878 (ctxt->state->value != ctxt->state->endvalue)) {
8880 ctxt->state->value);
8884 ctxt->state->value = oldvalue;
8885 ctxt->state->endvalue = oldend;
8889 ret = xmlRelaxNGValidateValueList(ctxt, define->content);
8897 if ((ctxt->state->value == NULL) ||
8898 (*ctxt->state->value == 0)) {
8902 oldflags = ctxt->flags;
8903 ctxt->flags |= FLAGS_IGNORABLE;
8904 cur = ctxt->state->value;
8906 while ((cur != NULL) && (cur != ctxt->state->endvalue) &&
8910 xmlRelaxNGValidateValueList(ctxt, define->content);
8912 ctxt->state->value = temp;
8916 cur = ctxt->state->value;
8918 ctxt->flags = oldflags;
8919 if (ctxt->errNr > 0)
8920 xmlRelaxNGPopErrors(ctxt, 0);
8926 if ((ctxt->state->value == NULL) ||
8927 (*ctxt->state->value == 0)) {
8931 oldflags = ctxt->flags;
8932 ctxt->flags |= FLAGS_IGNORABLE;
8933 temp = ctxt->state->value;
8934 ret = xmlRelaxNGValidateValue(ctxt, define->content);
8935 ctxt->flags = oldflags;
8937 ctxt->state->value = temp;
8938 if (ctxt->errNr > 0)
8939 xmlRelaxNGPopErrors(ctxt, 0);
8943 if (ctxt->errNr > 0)
8944 xmlRelaxNGPopErrors(ctxt, 0);
8952 ret = xmlRelaxNGValidateValue(ctxt, list);
8968 ret = xmlRelaxNGValidateValue(ctxt, list);
8984 ret = xmlRelaxNGValidateValue(ctxt, define->content);
8995 * @ctxt: a Relax-NG validation context
9003 xmlRelaxNGValidateValueContent(xmlRelaxNGValidCtxtPtr ctxt,
9009 ret = xmlRelaxNGValidateValue(ctxt, defines);
9019 * @ctxt: a Relax-NG validation context
9028 xmlRelaxNGAttributeMatch(xmlRelaxNGValidCtxtPtr ctxt,
9055 ret = xmlRelaxNGAttributeMatch(ctxt, list, prop);
9067 ret = xmlRelaxNGAttributeMatch(ctxt, list, prop);
9082 * @ctxt: a Relax-NG validation context
9090 xmlRelaxNGValidateAttribute(xmlRelaxNGValidCtxtPtr ctxt,
9098 if (ctxt->state->nbAttrLeft <= 0)
9101 for (i = 0; i < ctxt->state->nbAttrs; i++) {
9102 tmp = ctxt->state->attrs[i];
9115 oldvalue = ctxt->state->value;
9116 oldseq = ctxt->state->seq;
9117 ctxt->state->seq = (xmlNodePtr) prop;
9118 ctxt->state->value = value;
9119 ctxt->state->endvalue = NULL;
9120 ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
9121 if (ctxt->state->value != NULL)
9122 value = ctxt->state->value;
9125 ctxt->state->value = oldvalue;
9126 ctxt->state->seq = oldseq;
9131 ctxt->state->attrs[i] = NULL;
9132 ctxt->state->nbAttrLeft--;
9143 for (i = 0; i < ctxt->state->nbAttrs; i++) {
9144 tmp = ctxt->state->attrs[i];
9146 (xmlRelaxNGAttributeMatch(ctxt, define, tmp) == 1)) {
9153 oldvalue = ctxt->state->value;
9154 oldseq = ctxt->state->seq;
9155 ctxt->state->seq = (xmlNodePtr) prop;
9156 ctxt->state->value = value;
9157 ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
9158 if (ctxt->state->value != NULL)
9159 value = ctxt->state->value;
9162 ctxt->state->value = oldvalue;
9163 ctxt->state->seq = oldseq;
9168 ctxt->state->attrs[i] = NULL;
9169 ctxt->state->nbAttrLeft--;
9192 * @ctxt: a Relax-NG validation context
9200 xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
9210 if (xmlRelaxNGValidateAttribute(ctxt, cur) != 0)
9221 if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
9222 res = xmlRelaxNGValidateDefinition(ctxt, cur);
9275 * @ctxt: a Relax-NG validation context
9283 xmlRelaxNGValidateInterleave(xmlRelaxNGValidCtxtPtr ctxt,
9287 int errNr = ctxt->errNr;
9306 oldflags = ctxt->flags;
9308 ctxt->flags |= FLAGS_MIXED_CONTENT;
9313 if (ctxt->state != NULL)
9314 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
9315 ctxt->state->seq);
9317 ret = xmlRelaxNGValidateDefinition(ctxt,
9321 ret = xmlRelaxNGValidateDefinition(ctxt,
9325 if (ctxt->state != NULL)
9326 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
9327 ctxt->state->
9330 ctxt->flags = oldflags;
9341 xmlRngVErrMemory(ctxt, "validating\n");
9347 xmlRngVErrMemory(ctxt, "validating\n");
9356 cur = ctxt->state->seq;
9357 cur = xmlRelaxNGSkipIgnored(ctxt, cur);
9360 ctxt->state->seq = cur;
9423 cur = xmlRelaxNGSkipIgnored(ctxt, cur->next);
9431 oldstate = ctxt->state;
9433 ctxt->state = xmlRelaxNGCopyValidState(ctxt, oldstate);
9434 if (ctxt->state == NULL) {
9443 ctxt->state->seq = list[i];
9444 ret = xmlRelaxNGValidateDefinition(ctxt, group->rule);
9447 if (ctxt->state != NULL) {
9448 cur = ctxt->state->seq;
9449 cur = xmlRelaxNGSkipIgnored(ctxt, cur);
9450 xmlRelaxNGFreeValidState(ctxt, oldstate);
9451 oldstate = ctxt->state;
9452 ctxt->state = NULL;
9456 ctxt->state = oldstate;
9459 } else if (ctxt->states != NULL) {
9469 for (j = 0; j < ctxt->states->nbState; j++) {
9470 cur = ctxt->states->tabState[j]->seq;
9471 cur = xmlRelaxNGSkipIgnored(ctxt, cur);
9474 lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9478 if (ctxt->states->tabState[j]->nbAttrLeft <= lowattr) {
9480 lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9487 lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9490 if (ctxt->states->tabState[j]->nbAttrLeft <= lowattr) {
9492 lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9500 if (ctxt->states->nbState > 0) {
9501 xmlRelaxNGFreeValidState(ctxt, oldstate);
9503 oldstate = ctxt->states->tabState[best];
9504 ctxt->states->tabState[best] = NULL;
9507 ctxt->states->tabState[ctxt->states->nbState - 1];
9508 ctxt->states->tabState[ctxt->states->nbState - 1] = NULL;
9509 ctxt->states->nbState--;
9512 for (j = 0; j < ctxt->states->nbState ; j++) {
9513 xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[j]);
9515 xmlRelaxNGFreeStates(ctxt, ctxt->states);
9516 ctxt->states = NULL;
9525 ctxt->state = oldstate;
9536 if (ctxt->state != NULL)
9537 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
9538 ctxt->state = oldstate;
9539 ctxt->state->seq = lastelem;
9547 ctxt->flags = oldflags;
9559 if (ctxt->errNr > errNr)
9560 xmlRelaxNGPopErrors(ctxt, errNr);
9570 * @ctxt: a Relax-NG validation context
9578 xmlRelaxNGValidateDefinitionList(xmlRelaxNGValidCtxtPtr ctxt,
9590 if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
9591 res = xmlRelaxNGValidateDefinition(ctxt, defines);
9608 * @ctxt: a Relax-NG validation context
9617 xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
9653 if (ctxt != NULL) {
9654 oldflags = ctxt->flags;
9655 ctxt->flags |= FLAGS_IGNORABLE;
9660 ret = xmlRelaxNGElementMatch(ctxt, list, elem);
9662 if (ctxt != NULL)
9663 ctxt->flags = oldflags;
9667 if (ctxt != NULL)
9668 ctxt->flags = oldflags;
9674 if (ctxt != NULL) {
9675 ctxt->flags = oldflags;
9680 if (ctxt != NULL) {
9681 oldflags = ctxt->flags;
9682 ctxt->flags |= FLAGS_IGNORABLE;
9687 ret = xmlRelaxNGElementMatch(ctxt, list, elem);
9689 if (ctxt != NULL)
9690 ctxt->flags = oldflags;
9694 if (ctxt != NULL)
9695 ctxt->flags = oldflags;
9700 if (ctxt != NULL) {
9702 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9703 xmlRelaxNGDumpValidError(ctxt);
9705 if (ctxt->errNr > 0)
9706 xmlRelaxNGPopErrors(ctxt, 0);
9710 if (ctxt != NULL) {
9711 ctxt->flags = oldflags;
9721 * @ctxt: a Relax-NG validation context
9723 * Find the "best" state in the ctxt->states list of states to report
9731 xmlRelaxNGBestState(xmlRelaxNGValidCtxtPtr ctxt)
9738 if ((ctxt == NULL) || (ctxt->states == NULL) ||
9739 (ctxt->states->nbState <= 0))
9742 for (i = 0; i < ctxt->states->nbState; i++) {
9743 state = ctxt->states->tabState[i];
9764 * @ctxt: a Relax-NG validation context
9766 * Find the "best" state in the ctxt->states list of states to report
9770 xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt)
9774 if ((ctxt == NULL) || (ctxt->states == NULL) ||
9775 (ctxt->states->nbState <= 0))
9778 best = xmlRelaxNGBestState(ctxt);
9779 if ((best >= 0) && (best < ctxt->states->nbState)) {
9780 ctxt->state = ctxt->states->tabState[best];
9782 xmlRelaxNGValidateElementEnd(ctxt, 1);
9788 * @ctxt: a Relax-NG validation context
9798 xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt, int dolog)
9803 state = ctxt->state;
9805 state->seq = xmlRelaxNGSkipIgnored(ctxt, state->seq);
9828 * @ctxt: a Relax-NG validation context
9836 xmlRelaxNGValidateState(xmlRelaxNGValidCtxtPtr ctxt,
9848 if (ctxt->state != NULL) {
9849 node = ctxt->state->seq;
9854 for (i = 0; i < ctxt->depth; i++)
9865 ctxt->depth++;
9868 xmlRelaxNGSkipIgnored(ctxt, node);
9881 ctxt->state->seq = node;
9884 errNr = ctxt->errNr;
9885 node = xmlRelaxNGSkipIgnored(ctxt, node);
9889 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9890 xmlRelaxNGDumpValidError(ctxt);
9896 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9897 xmlRelaxNGDumpValidError(ctxt);
9905 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
9906 if (ctxt->errNr > errNr)
9907 xmlRelaxNGPopErrors(ctxt, errNr);
9908 if (ctxt->errNr != 0) {
9909 while ((ctxt->err != NULL) &&
9910 (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME)
9911 && (xmlStrEqual(ctxt->err->arg2, node->name)))
9913 ((ctxt->err->err ==
9915 && (xmlStrEqual(ctxt->err->arg1, node->name)))
9916 || (ctxt->err->err == XML_RELAXNG_ERR_NOELEM)
9917 || (ctxt->err->err ==
9919 xmlRelaxNGValidErrorPop(ctxt);
9924 ret = xmlRelaxNGElementMatch(ctxt, define, node);
9927 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9928 xmlRelaxNGDumpValidError(ctxt);
9932 if (ctxt->errNr != 0) {
9933 if (ctxt->errNr > errNr)
9934 xmlRelaxNGPopErrors(ctxt, errNr);
9935 while ((ctxt->err != NULL) &&
9936 (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME) &&
9937 (xmlStrEqual(ctxt->err->arg2, node->name))) ||
9938 ((ctxt->err->err == XML_RELAXNG_ERR_ELEMEXTRANS) &&
9939 (xmlStrEqual(ctxt->err->arg1, node->name))) ||
9940 (ctxt->err->err == XML_RELAXNG_ERR_NOELEM) ||
9941 (ctxt->err->err == XML_RELAXNG_ERR_NOTELEM)))
9942 xmlRelaxNGValidErrorPop(ctxt);
9944 errNr = ctxt->errNr;
9946 oldflags = ctxt->flags;
9947 if (ctxt->flags & FLAGS_MIXED_CONTENT) {
9948 ctxt->flags -= FLAGS_MIXED_CONTENT;
9950 state = xmlRelaxNGNewValidState(ctxt, node);
9953 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9954 xmlRelaxNGDumpValidError(ctxt);
9958 oldstate = ctxt->state;
9959 ctxt->state = state;
9961 tmp = xmlRelaxNGValidateAttributeList(ctxt, define->attrs);
9968 xmlRelaxNGValidStatePtr nstate, tmpstate = ctxt->state;
9969 xmlRelaxNGStatesPtr tmpstates = ctxt->states;
9972 nstate = xmlRelaxNGNewValidState(ctxt, node);
9973 ctxt->state = nstate;
9974 ctxt->states = NULL;
9976 tmp = xmlRelaxNGValidateCompiledContent(ctxt,
9978 ctxt->state->seq);
9979 nseq = ctxt->state->seq;
9980 ctxt->state = tmpstate;
9981 ctxt->states = tmpstates;
9982 xmlRelaxNGFreeValidState(ctxt, nstate);
9992 if (ctxt->states != NULL) {
9995 ctxt->states->nbState; i++) {
9996 state = ctxt->states->tabState[i];
9997 ctxt->state = state;
9998 ctxt->state->seq = nseq;
10000 if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
10009 ctxt->flags |= FLAGS_IGNORABLE;
10010 xmlRelaxNGLogBestError(ctxt);
10012 for (i = 0; i < ctxt->states->nbState; i++) {
10013 xmlRelaxNGFreeValidState(ctxt,
10014 ctxt->states->
10017 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10018 ctxt->flags = oldflags;
10019 ctxt->states = NULL;
10023 state = ctxt->state;
10024 if (ctxt->state != NULL)
10025 ctxt->state->seq = nseq;
10027 ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
10028 xmlRelaxNGFreeValidState(ctxt, state);
10032 tmp = xmlRelaxNGValidateDefinitionList(ctxt,
10037 if (ctxt->state == NULL) {
10038 ctxt->state = oldstate;
10041 ctxt->state = NULL;
10049 if (ctxt->states != NULL) {
10052 for (i = 0; i < ctxt->states->nbState; i++) {
10053 state = ctxt->states->tabState[i];
10054 ctxt->state = state;
10056 if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
10065 ctxt->flags |= FLAGS_IGNORABLE;
10066 xmlRelaxNGLogBestError(ctxt);
10068 for (i = 0; i < ctxt->states->nbState; i++) {
10069 xmlRelaxNGFreeValidState(ctxt,
10070 ctxt->states->tabState[i]);
10071 ctxt->states->tabState[i] = NULL;
10073 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10074 ctxt->flags = oldflags;
10075 ctxt->states = NULL;
10079 state = ctxt->state;
10081 ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
10082 xmlRelaxNGFreeValidState(ctxt, state);
10088 ctxt->flags = oldflags;
10089 ctxt->state = oldstate;
10091 oldstate->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
10093 if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
10094 xmlRelaxNGDumpValidError(ctxt);
10102 if (ctxt->errNr > errNr)
10103 xmlRelaxNGPopErrors(ctxt, errNr);
10123 errNr = ctxt->errNr;
10124 oldflags = ctxt->flags;
10125 ctxt->flags |= FLAGS_IGNORABLE;
10126 oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
10128 xmlRelaxNGValidateDefinitionList(ctxt,
10131 if (ctxt->state != NULL)
10132 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10133 ctxt->state = oldstate;
10134 ctxt->flags = oldflags;
10136 if (ctxt->errNr > errNr)
10137 xmlRelaxNGPopErrors(ctxt, errNr);
10140 if (ctxt->states != NULL) {
10141 xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
10143 ctxt->states = xmlRelaxNGNewStates(ctxt, 1);
10144 if (ctxt->states == NULL) {
10145 xmlRelaxNGFreeValidState(ctxt, oldstate);
10146 ctxt->flags = oldflags;
10148 if (ctxt->errNr > errNr)
10149 xmlRelaxNGPopErrors(ctxt, errNr);
10152 xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
10153 xmlRelaxNGAddStates(ctxt, ctxt->states, ctxt->state);
10154 ctxt->state = NULL;
10156 ctxt->flags = oldflags;
10158 if (ctxt->errNr > errNr)
10159 xmlRelaxNGPopErrors(ctxt, errNr);
10163 errNr = ctxt->errNr;
10164 ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
10168 if (ctxt->errNr > errNr)
10169 xmlRelaxNGPopErrors(ctxt, errNr);
10176 errNr = ctxt->errNr;
10177 res = xmlRelaxNGNewStates(ctxt, 1);
10185 if (ctxt->state != NULL) {
10186 xmlRelaxNGAddStates(ctxt, res,
10187 xmlRelaxNGCopyValidState(ctxt,
10188 ctxt->
10191 for (j = 0; j < ctxt->states->nbState; j++) {
10192 xmlRelaxNGAddStates(ctxt, res,
10193 xmlRelaxNGCopyValidState(ctxt,
10194 ctxt->states->tabState[j]));
10197 oldflags = ctxt->flags;
10198 ctxt->flags |= FLAGS_IGNORABLE;
10203 if (ctxt->states != NULL) {
10204 states = ctxt->states;
10206 ctxt->state = states->tabState[i];
10207 ctxt->states = NULL;
10208 ret = xmlRelaxNGValidateDefinitionList(ctxt,
10212 if (ctxt->state != NULL) {
10213 tmp = xmlRelaxNGAddStates(ctxt, res,
10214 ctxt->state);
10215 ctxt->state = NULL;
10218 } else if (ctxt->states != NULL) {
10219 for (j = 0; j < ctxt->states->nbState;
10222 xmlRelaxNGAddStates(ctxt, res,
10223 ctxt->states->tabState[j]);
10227 xmlRelaxNGFreeStates(ctxt,
10228 ctxt->states);
10229 ctxt->states = NULL;
10232 if (ctxt->state != NULL) {
10233 xmlRelaxNGFreeValidState(ctxt,
10234 ctxt->state);
10235 ctxt->state = NULL;
10240 ret = xmlRelaxNGValidateDefinitionList(ctxt,
10244 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10245 ctxt->state = NULL;
10248 if (ctxt->state != NULL) {
10249 tmp = xmlRelaxNGAddStates(ctxt, res,
10250 ctxt->state);
10251 ctxt->state = NULL;
10254 } else if (ctxt->states != NULL) {
10255 for (j = 0; j < ctxt->states->nbState; j++) {
10256 tmp = xmlRelaxNGAddStates(ctxt, res,
10257 ctxt->states->tabState[j]);
10262 states = ctxt->states;
10264 xmlRelaxNGFreeStates(ctxt,
10265 ctxt->states);
10267 ctxt->states = NULL;
10277 ctxt->state = xmlRelaxNGCopyValidState(ctxt,
10283 xmlRelaxNGNewStates(ctxt,
10285 states = ctxt->states;
10293 xmlRelaxNGAddStates(ctxt, states,
10295 (ctxt, res->tabState[i]));
10296 ctxt->states = states;
10301 xmlRelaxNGFreeStates(ctxt, states);
10303 ctxt->states = res;
10304 ctxt->flags = oldflags;
10309 if (ctxt->errNr > errNr)
10310 xmlRelaxNGPopErrors(ctxt, errNr);
10319 node = xmlRelaxNGSkipIgnored(ctxt, node);
10321 errNr = ctxt->errNr;
10361 ret = xmlRelaxNGValidateDefinition(ctxt, list);
10368 oldflags = ctxt->flags;
10369 ctxt->flags |= FLAGS_IGNORABLE;
10372 oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
10373 ret = xmlRelaxNGValidateDefinition(ctxt, list);
10376 states = xmlRelaxNGNewStates(ctxt, 1);
10378 if (ctxt->state != NULL) {
10379 xmlRelaxNGAddStates(ctxt, states, ctxt->state);
10380 } else if (ctxt->states != NULL) {
10381 for (i = 0; i < ctxt->states->nbState; i++) {
10382 xmlRelaxNGAddStates(ctxt, states,
10383 ctxt->states->
10386 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10387 ctxt->states = NULL;
10390 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10392 ctxt->state = oldstate;
10396 xmlRelaxNGFreeValidState(ctxt, oldstate);
10397 ctxt->states = states;
10398 ctxt->state = NULL;
10401 ctxt->states = NULL;
10403 ctxt->flags = oldflags;
10405 if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
10406 xmlRelaxNGDumpValidError(ctxt);
10409 if (ctxt->errNr > errNr)
10410 xmlRelaxNGPopErrors(ctxt, errNr);
10416 ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
10419 ret = xmlRelaxNGValidateInterleave(ctxt, define);
10422 ret = xmlRelaxNGValidateAttribute(ctxt, define);
10429 ret = xmlRelaxNGValidateDefinition(ctxt, define->content);
10457 xmlRngVErrMemory(ctxt, "validating\n");
10462 ret = xmlRelaxNGValidateDatatype(ctxt, content, define,
10463 ctxt->state->seq);
10467 ctxt->state->seq = NULL;
10500 xmlRngVErrMemory(ctxt, "validating\n");
10505 oldvalue = ctxt->state->value;
10506 ctxt->state->value = content;
10507 ret = xmlRelaxNGValidateValue(ctxt, define);
10508 ctxt->state->value = oldvalue;
10512 ctxt->state->seq = NULL;
10551 xmlRngVErrMemory(ctxt, "validating\n");
10557 oldvalue = ctxt->state->value;
10558 oldendvalue = ctxt->state->endvalue;
10559 ctxt->state->value = content;
10560 ctxt->state->endvalue = content + len;
10561 ret = xmlRelaxNGValidateValue(ctxt, define);
10562 ctxt->state->value = oldvalue;
10563 ctxt->state->endvalue = oldendvalue;
10567 ctxt->state->seq = node->next;
10578 ctxt->depth--;
10580 for (i = 0; i < ctxt->depth; i++)
10596 * @ctxt: a Relax-NG validation context
10604 xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
10611 * We should NOT have both ctxt->state and ctxt->states
10613 if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10614 TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10615 ctxt->state = NULL;
10618 if ((ctxt->states == NULL) || (ctxt->states->nbState == 1)) {
10619 if (ctxt->states != NULL) {
10620 ctxt->state = ctxt->states->tabState[0];
10621 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10622 ctxt->states = NULL;
10624 ret = xmlRelaxNGValidateState(ctxt, define);
10625 if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10626 TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10627 ctxt->state = NULL;
10629 if ((ctxt->states != NULL) && (ctxt->states->nbState == 1)) {
10630 ctxt->state = ctxt->states->tabState[0];
10631 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10632 ctxt->states = NULL;
10637 states = ctxt->states;
10638 ctxt->states = NULL;
10641 oldflags = ctxt->flags;
10642 ctxt->flags |= FLAGS_IGNORABLE;
10644 ctxt->state = states->tabState[i];
10645 ctxt->states = NULL;
10646 ret = xmlRelaxNGValidateState(ctxt, define);
10648 * We should NOT have both ctxt->state and ctxt->states
10650 if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10651 TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10652 ctxt->state = NULL;
10655 if (ctxt->states == NULL) {
10658 xmlRelaxNGAddStates(ctxt, res, ctxt->state);
10659 ctxt->state = NULL;
10662 states->tabState[j++] = ctxt->state;
10663 ctxt->state = NULL;
10668 res = ctxt->states;
10669 ctxt->states = NULL;
10671 xmlRelaxNGAddStates(ctxt, res,
10675 for (k = 0; k < ctxt->states->nbState; k++)
10676 xmlRelaxNGAddStates(ctxt, res,
10677 ctxt->states->tabState[k]);
10678 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10679 ctxt->states = NULL;
10683 if (ctxt->state != NULL) {
10684 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10685 ctxt->state = NULL;
10686 } else if (ctxt->states != NULL) {
10687 for (k = 0; k < ctxt->states->nbState; k++)
10688 xmlRelaxNGFreeValidState(ctxt,
10689 ctxt->states->tabState[k]);
10690 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10691 ctxt->states = NULL;
10695 ctxt->flags = oldflags;
10697 xmlRelaxNGFreeStates(ctxt, states);
10698 ctxt->states = res;
10702 ctxt->states = states;
10705 ctxt->state = states->tabState[0];
10706 xmlRelaxNGFreeStates(ctxt, states);
10710 xmlRelaxNGFreeStates(ctxt, states);
10711 if (ctxt->states != NULL) {
10712 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10713 ctxt->states = NULL;
10716 if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10717 TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10718 ctxt->state = NULL;
10725 * @ctxt: a Relax-NG validation context
10733 xmlRelaxNGValidateDocument(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
10741 if ((ctxt == NULL) || (ctxt->schema == NULL) || (doc == NULL))
10744 ctxt->errNo = XML_RELAXNG_OK;
10745 schema = ctxt->schema;
10751 state = xmlRelaxNGNewValidState(ctxt, NULL);
10752 ctxt->state = state;
10753 ret = xmlRelaxNGValidateDefinition(ctxt, grammar->start);
10754 if ((ctxt->state != NULL) && (state->seq != NULL)) {
10755 state = ctxt->state;
10757 node = xmlRelaxNGSkipIgnored(ctxt, node);
10764 } else if (ctxt->states != NULL) {
10768 for (i = 0; i < ctxt->states->nbState; i++) {
10769 state = ctxt->states->tabState[i];
10771 node = xmlRelaxNGSkipIgnored(ctxt, node);
10774 xmlRelaxNGFreeValidState(ctxt, state);
10783 if (ctxt->state != NULL) {
10784 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10785 ctxt->state = NULL;
10788 xmlRelaxNGDumpValidError(ctxt);
10790 else if (ctxt->errNr != 0) {
10791 ctxt->error(ctxt->userData,
10793 ctxt->errNr);
10794 xmlRelaxNGDumpValidError(ctxt);
10798 if (ctxt->idref == 1) {
10803 vctxt.error = ctxt->error;
10804 vctxt.warning = ctxt->warning;
10805 vctxt.userData = ctxt->userData;
10811 if ((ret == 0) && (ctxt->errNo != XML_RELAXNG_OK))
10914 * @ctxt: the schema validation context
10919 xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxtPtr ctxt)
10923 if (ctxt == NULL)
10925 if (ctxt->states != NULL)
10926 xmlRelaxNGFreeStates(NULL, ctxt->states);
10927 if (ctxt->freeState != NULL) {
10928 for (k = 0; k < ctxt->freeState->nbState; k++) {
10929 xmlRelaxNGFreeValidState(NULL, ctxt->freeState->tabState[k]);
10931 xmlRelaxNGFreeStates(NULL, ctxt->freeState);
10933 if (ctxt->freeStates != NULL) {
10934 for (k = 0; k < ctxt->freeStatesNr; k++) {
10935 xmlRelaxNGFreeStates(NULL, ctxt->freeStates[k]);
10937 xmlFree(ctxt->freeStates);
10939 if (ctxt->errTab != NULL)
10940 xmlFree(ctxt->errTab);
10941 if (ctxt->elemTab != NULL) {
10944 exec = xmlRelaxNGElemPop(ctxt);
10947 exec = xmlRelaxNGElemPop(ctxt);
10949 xmlFree(ctxt->elemTab);
10951 xmlFree(ctxt);
10956 * @ctxt: a Relax-NG validation context
10964 xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
10968 if (ctxt == NULL)
10970 ctxt->error = err;
10971 ctxt->warning = warn;
10972 ctxt->userData = ctx;
10973 ctxt->serror = NULL;
10978 * @ctxt: a Relax-NG validation context
10985 xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt,
10988 if (ctxt == NULL)
10990 ctxt->serror = serror;
10991 ctxt->error = NULL;
10992 ctxt->warning = NULL;
10993 ctxt->userData = ctx;
10998 * @ctxt: a Relax-NG validation context
11008 xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
11012 if (ctxt == NULL)
11015 *err = ctxt->error;
11017 *warn = ctxt->warning;
11019 *ctx = ctxt->userData;
11025 * @ctxt: a Relax-NG validation context
11034 xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
11038 if ((ctxt == NULL) || (doc == NULL))
11041 ctxt->doc = doc;
11043 ret = xmlRelaxNGValidateDocument(ctxt, doc);
