Lines Matching refs:ctxt
428 * @ctxt: an Relax-NG parser context
434 xmlRngPErrMemory(xmlRelaxNGParserCtxtPtr ctxt, const char *extra)
440 if (ctxt != NULL) {
441 if (ctxt->serror != NULL)
442 schannel = ctxt->serror;
444 channel = ctxt->error;
445 data = ctxt->userData;
446 ctxt->nbErrors++;
463 * @ctxt: a Relax-NG validation context
469 xmlRngVErrMemory(xmlRelaxNGValidCtxtPtr ctxt, const char *extra)
475 if (ctxt != NULL) {
476 if (ctxt->serror != NULL)
477 schannel = ctxt->serror;
479 channel = ctxt->error;
480 data = ctxt->userData;
481 ctxt->nbErrors++;
498 * @ctxt: a Relax-NG parser context
508 xmlRngPErr(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node, int error,
515 if (ctxt != NULL) {
516 if (ctxt->serror != NULL)
517 schannel = ctxt->serror;
519 channel = ctxt->error;
520 data = ctxt->userData;
521 ctxt->nbErrors++;
532 * @ctxt: a Relax-NG validation context
542 xmlRngVErr(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node, int error,
549 if (ctxt != NULL) {
550 if (ctxt->serror != NULL)
551 schannel = ctxt->serror;
553 channel = ctxt->error;
554 data = ctxt->userData;
555 ctxt->nbErrors++;
663 static int xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt
667 static void xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
750 * @ctxt: a Relax-NG validation context (optional)
757 xmlRelaxNGNewRelaxNG(xmlRelaxNGParserCtxtPtr ctxt)
763 xmlRngPErrMemory(ctxt, NULL);
829 * @ctxt: a Relax-NG validation context (optional)
836 xmlRelaxNGNewGrammar(xmlRelaxNGParserCtxtPtr ctxt)
842 xmlRngPErrMemory(ctxt, NULL);
880 * @ctxt: a Relax-NG validation context
888 xmlRelaxNGNewDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
892 if (ctxt->defMax == 0) {
893 ctxt->defMax = 16;
894 ctxt->defNr = 0;
895 ctxt->defTab = (xmlRelaxNGDefinePtr *)
896 xmlMalloc(ctxt->defMax * sizeof(xmlRelaxNGDefinePtr));
897 if (ctxt->defTab == NULL) {
898 xmlRngPErrMemory(ctxt, "allocating define\n");
901 } else if (ctxt->defMax <= ctxt->defNr) {
904 ctxt->defMax *= 2;
905 tmp = (xmlRelaxNGDefinePtr *) xmlRealloc(ctxt->defTab,
906 ctxt->defMax *
910 xmlRngPErrMemory(ctxt, "allocating define\n");
913 ctxt->defTab = tmp;
917 xmlRngPErrMemory(ctxt, "allocating define\n");
921 ctxt->defTab[ctxt->defNr++] = ret;
996 * @ctxt: a Relax-NG validation context
1004 xmlRelaxNGNewStates(xmlRelaxNGValidCtxtPtr ctxt, int size)
1008 if ((ctxt != NULL) &&
1009 (ctxt->freeState != NULL) && (ctxt->freeStatesNr > 0)) {
1010 ctxt->freeStatesNr--;
1011 ret = ctxt->freeStates[ctxt->freeStatesNr];
1023 xmlRngVErrMemory(ctxt, "allocating states\n");
1032 xmlRngVErrMemory(ctxt, "allocating states\n");
1041 * @ctxt: a Relax-NG validation context
1051 xmlRelaxNGAddStatesUniq(xmlRelaxNGValidCtxtPtr ctxt,
1068 xmlRngVErrMemory(ctxt, "adding states\n");
1080 * @ctxt: a Relax-NG validation context
1089 xmlRelaxNGAddStates(xmlRelaxNGValidCtxtPtr ctxt,
1108 xmlRngVErrMemory(ctxt, "adding states\n");
1115 if (xmlRelaxNGEqualValidState(ctxt, state, states->tabState[i])) {
1116 xmlRelaxNGFreeValidState(ctxt, state);
1126 * @ctxt: a Relax-NG validation context
1132 xmlRelaxNGFreeStates(xmlRelaxNGValidCtxtPtr ctxt,
1137 if ((ctxt != NULL) && (ctxt->freeStates == NULL)) {
1138 ctxt->freeStatesMax = 40;
1139 ctxt->freeStatesNr = 0;
1140 ctxt->freeStates = (xmlRelaxNGStatesPtr *)
1141 xmlMalloc(ctxt->freeStatesMax * sizeof(xmlRelaxNGStatesPtr));
1142 if (ctxt->freeStates == NULL) {
1143 xmlRngVErrMemory(ctxt, "storing states\n");
1145 } else if ((ctxt != NULL)
1146 && (ctxt->freeStatesNr >= ctxt->freeStatesMax)) {
1149 tmp = (xmlRelaxNGStatesPtr *) xmlRealloc(ctxt->freeStates,
1150 2 * ctxt->freeStatesMax *
1154 xmlRngVErrMemory(ctxt, "storing states\n");
1159 ctxt->freeStates = tmp;
1160 ctxt->freeStatesMax *= 2;
1162 if ((ctxt == NULL) || (ctxt->freeStates == NULL)) {
1166 ctxt->freeStates[ctxt->freeStatesNr++] = states;
1172 * @ctxt: a Relax-NG validation context
1180 xmlRelaxNGNewValidState(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node)
1189 root = xmlDocGetRootElement(ctxt->doc);
1202 if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
1203 ctxt->freeState->nbState--;
1204 ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
1210 xmlRngVErrMemory(ctxt, "allocating states\n");
1218 ret->node = (xmlNodePtr) ctxt->doc;
1234 xmlRngVErrMemory(ctxt, "allocating states\n");
1243 xmlRngVErrMemory(ctxt, "allocating states\n");
1267 * @ctxt: a Relax-NG validation context
1275 xmlRelaxNGCopyValidState(xmlRelaxNGValidCtxtPtr ctxt,
1284 if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
1285 ctxt->freeState->nbState--;
1286 ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
1292 xmlRngVErrMemory(ctxt, "allocating states\n");
1308 xmlRngVErrMemory(ctxt, "allocating states\n");
1318 xmlRngVErrMemory(ctxt, "allocating states\n");
1333 * @ctxt: a Relax-NG validation context
1342 xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
1379 xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
1385 if ((ctxt != NULL) && (ctxt->freeState == NULL)) {
1386 ctxt->freeState = xmlRelaxNGNewStates(ctxt, 40);
1388 if ((ctxt == NULL) || (ctxt->freeState == NULL)) {
1393 xmlRelaxNGAddStatesUniq(ctxt, ctxt->freeState, state);
1405 * @ctxt: a RelaxNG parser context
1414 xmlRelaxParserSetFlag(xmlRelaxNGParserCtxtPtr ctxt, int flags)
1416 if (ctxt == NULL) return(-1);
1418 ctxt->crng |= XML_RELAXNGP_FREE_DOC;
1422 ctxt->crng |= XML_RELAXNGP_CRNG;
1434 static xmlDocPtr xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt,
1439 * @ctxt: the parser context
1447 xmlRelaxNGIncludePush(xmlRelaxNGParserCtxtPtr ctxt,
1450 if (ctxt->incTab == NULL) {
1451 ctxt->incMax = 4;
1452 ctxt->incNr = 0;
1453 ctxt->incTab =
1454 (xmlRelaxNGIncludePtr *) xmlMalloc(ctxt->incMax *
1455 sizeof(ctxt->incTab[0]));
1456 if (ctxt->incTab == NULL) {
1457 xmlRngPErrMemory(ctxt, "allocating include\n");
1461 if (ctxt->incNr >= ctxt->incMax) {
1462 ctxt->incMax *= 2;
1463 ctxt->incTab =
1464 (xmlRelaxNGIncludePtr *) xmlRealloc(ctxt->incTab,
1465 ctxt->incMax *
1466 sizeof(ctxt->incTab[0]));
1467 if (ctxt->incTab == NULL) {
1468 xmlRngPErrMemory(ctxt, "allocating include\n");
1472 ctxt->incTab[ctxt->incNr] = value;
1473 ctxt->inc = value;
1474 return (ctxt->incNr++);
1479 * @ctxt: the parser context
1486 xmlRelaxNGIncludePop(xmlRelaxNGParserCtxtPtr ctxt)
1490 if (ctxt->incNr <= 0)
1492 ctxt->incNr--;
1493 if (ctxt->incNr > 0)
1494 ctxt->inc = ctxt->incTab[ctxt->incNr - 1];
1496 ctxt->inc = NULL;
1497 ret = ctxt->incTab[ctxt->incNr];
1498 ctxt->incTab[ctxt->incNr] = NULL;
1504 * @ctxt: the parser context
1514 xmlRelaxNGRemoveRedefine(xmlRelaxNGParserCtxtPtr ctxt,
1561 if (xmlRelaxNGRemoveRedefine(ctxt, href,
1580 * @ctxt: the parser context
1592 xmlRelaxNGLoadInclude(xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * URL,
1608 for (i = 0; i < ctxt->incNr; i++) {
1609 if (xmlStrEqual(ctxt->incTab[i]->href, URL)) {
1610 xmlRngPErr(ctxt, NULL, XML_RNGP_INCLUDE_RECURSE,
1622 xmlRngPErr(ctxt, node, XML_RNGP_PARSE_ERROR,
1635 xmlRngPErrMemory(ctxt, "allocating include\n");
1642 ret->next = ctxt->includes;
1643 ctxt->includes = ret;
1660 xmlRelaxNGIncludePush(ctxt, ret);
1670 doc = xmlRelaxNGCleanupDoc(ctxt, doc);
1672 ctxt->inc = NULL;
1679 xmlRelaxNGIncludePop(ctxt);
1689 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY,
1695 xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
1710 xmlRelaxNGRemoveRedefine(ctxt, URL, root->children, NULL);
1712 xmlRngPErr(ctxt, node, XML_RNGP_START_MISSING,
1721 xmlRngPErr(ctxt, node, XML_RNGP_NAME_MISSING,
1728 found = xmlRelaxNGRemoveRedefine(ctxt, URL,
1731 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_MISSING,
1747 * @ctxt: the validation context
1758 xmlRelaxNGValidErrorPush(xmlRelaxNGValidCtxtPtr ctxt,
1766 "Pushing error %d at %d on stack\n", err, ctxt->errNr);
1768 if (ctxt->errTab == NULL) {
1769 ctxt->errMax = 8;
1770 ctxt->errNr = 0;
1771 ctxt->errTab =
1772 (xmlRelaxNGValidErrorPtr) xmlMalloc(ctxt->errMax *
1775 if (ctxt->errTab == NULL) {
1776 xmlRngVErrMemory(ctxt, "pushing error\n");
1779 ctxt->err = NULL;
1781 if (ctxt->errNr >= ctxt->errMax) {
1782 ctxt->errMax *= 2;
1783 ctxt->errTab =
1784 (xmlRelaxNGValidErrorPtr) xmlRealloc(ctxt->errTab,
1785 ctxt->errMax *
1788 if (ctxt->errTab == NULL) {
1789 xmlRngVErrMemory(ctxt, "pushing error\n");
1792 ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
1794 if ((ctxt->err != NULL) && (ctxt->state != NULL) &&
1795 (ctxt->err->node == ctxt->state->node) && (ctxt->err->err == err))
1796 return (ctxt->errNr);
1797 cur = &ctxt->errTab[ctxt->errNr];
1808 if (ctxt->state != NULL) {
1809 cur->node = ctxt->state->node;
1810 cur->seq = ctxt->state->seq;
1815 ctxt->err = cur;
1816 return (ctxt->errNr++);
1821 * @ctxt: the validation context
1826 xmlRelaxNGValidErrorPop(xmlRelaxNGValidCtxtPtr ctxt)
1830 if (ctxt->errNr <= 0) {
1831 ctxt->err = NULL;
1834 ctxt->errNr--;
1835 if (ctxt->errNr > 0)
1836 ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
1838 ctxt->err = NULL;
1839 cur = &ctxt->errTab[ctxt->errNr];
1853 * @ctxt: the parser context
1861 xmlRelaxNGDocumentPush(xmlRelaxNGParserCtxtPtr ctxt,
1864 if (ctxt->docTab == NULL) {
1865 ctxt->docMax = 4;
1866 ctxt->docNr = 0;
1867 ctxt->docTab =
1868 (xmlRelaxNGDocumentPtr *) xmlMalloc(ctxt->docMax *
1869 sizeof(ctxt->docTab[0]));
1870 if (ctxt->docTab == NULL) {
1871 xmlRngPErrMemory(ctxt, "adding document\n");
1875 if (ctxt->docNr >= ctxt->docMax) {
1876 ctxt->docMax *= 2;
1877 ctxt->docTab =
1878 (xmlRelaxNGDocumentPtr *) xmlRealloc(ctxt->docTab,
1879 ctxt->docMax *
1880 sizeof(ctxt->docTab[0]));
1881 if (ctxt->docTab == NULL) {
1882 xmlRngPErrMemory(ctxt, "adding document\n");
1886 ctxt->docTab[ctxt->docNr] = value;
1887 ctxt->doc = value;
1888 return (ctxt->docNr++);
1893 * @ctxt: the parser context
1900 xmlRelaxNGDocumentPop(xmlRelaxNGParserCtxtPtr ctxt)
1904 if (ctxt->docNr <= 0)
1906 ctxt->docNr--;
1907 if (ctxt->docNr > 0)
1908 ctxt->doc = ctxt->docTab[ctxt->docNr - 1];
1910 ctxt->doc = NULL;
1911 ret = ctxt->docTab[ctxt->docNr];
1912 ctxt->docTab[ctxt->docNr] = NULL;
1918 * @ctxt: the parser context
1929 xmlRelaxNGLoadExternalRef(xmlRelaxNGParserCtxtPtr ctxt,
1940 for (i = 0; i < ctxt->docNr; i++) {
1941 if (xmlStrEqual(ctxt->docTab[i]->href, URL)) {
1942 xmlRngPErr(ctxt, NULL, XML_RNGP_EXTERNALREF_RECURSE,
1954 xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
1964 xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_ERR_NO_MEMORY,
1972 ret->next = ctxt->documents;
1973 ctxt->documents = ret;
1990 xmlRelaxNGDocumentPush(ctxt, ret);
1995 doc = xmlRelaxNGCleanupDoc(ctxt, doc);
1997 ctxt->doc = NULL;
2001 xmlRelaxNGDocumentPop(ctxt);
2012 #define VALID_ERR(a) xmlRelaxNGAddValidError(ctxt, a, NULL, NULL, 0);
2013 #define VALID_ERR2(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 0);
2014 #define VALID_ERR3(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 0);
2015 #define VALID_ERR2P(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 1);
2016 #define VALID_ERR3P(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 1);
2219 * @ctxt: the validation context
2229 xmlRelaxNGShowValidError(xmlRelaxNGValidCtxtPtr ctxt,
2236 if (ctxt->flags & FLAGS_NOERROR)
2246 if (ctxt->errNo == XML_RELAXNG_OK)
2247 ctxt->errNo = err;
2248 xmlRngVErr(ctxt, (child == NULL ? node : child), err,
2255 * @ctxt: the validation context
2261 xmlRelaxNGPopErrors(xmlRelaxNGValidCtxtPtr ctxt, int level)
2270 for (i = level; i < ctxt->errNr; i++) {
2271 err = &ctxt->errTab[i];
2282 ctxt->errNr = level;
2283 if (ctxt->errNr <= 0)
2284 ctxt->err = NULL;
2289 * @ctxt: the validation context
2294 xmlRelaxNGDumpValidError(xmlRelaxNGValidCtxtPtr ctxt)
2301 "Dumping error stack %d errors\n", ctxt->errNr);
2303 for (i = 0, k = 0; i < ctxt->errNr; i++) {
2304 err = &ctxt->errTab[i];
2307 dup = &ctxt->errTab[j];
2314 xmlRelaxNGShowValidError(ctxt, err->err, err->node, err->seq,
2329 ctxt->errNr = 0;
2334 * @ctxt: the validation context
2344 xmlRelaxNGAddValidError(xmlRelaxNGValidCtxtPtr ctxt,
2348 if (ctxt == NULL)
2350 if (ctxt->flags & FLAGS_NOERROR)
2359 if (((ctxt->flags & FLAGS_IGNORABLE) == 0) ||
2360 (ctxt->flags & FLAGS_NEGATIVE)) {
2367 if (ctxt->errNr != 0)
2368 xmlRelaxNGDumpValidError(ctxt);
2369 if (ctxt->state != NULL) {
2370 node = ctxt->state->node;
2371 seq = ctxt->state->seq;
2375 xmlRelaxNGShowValidError(ctxt, err, node, seq, arg1, arg2);
2381 xmlRelaxNGValidErrorPush(ctxt, err, arg1, arg2, dup);
2391 static xmlChar *xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt,
2852 static int xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt,
3006 * ctxt: the RelaxNG parser context
3015 xmlRelaxNGCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
3020 if ((ctxt == NULL) || (def == NULL))
3026 xmlAutomataPtr oldam = ctxt->am;
3027 xmlAutomataStatePtr oldstate = ctxt->state;
3032 ctxt->am = xmlNewAutomata();
3033 if (ctxt->am == NULL)
3035 ctxt->state = xmlAutomataGetInitState(ctxt->am);
3037 xmlRelaxNGCompile(ctxt, list);
3040 xmlAutomataSetFinalState(ctxt->am, ctxt->state);
3041 def->contModel = xmlAutomataCompile(ctxt->am);
3044 xmlFreeAutomata(ctxt->am);
3045 ctxt->state = oldstate;
3046 ctxt->am = oldam;
3050 if ((ctxt->am != NULL) && (def->name != NULL)) {
3051 ctxt->state = xmlAutomataNewTransition2(ctxt->am,
3052 ctxt->state, NULL,
3057 xmlAutomataPtr oldam = ctxt->am;
3058 xmlAutomataStatePtr oldstate = ctxt->state;
3063 ctxt->am = xmlNewAutomata();
3064 if (ctxt->am == NULL)
3066 ctxt->state = xmlAutomataGetInitState(ctxt->am);
3068 xmlRelaxNGCompile(ctxt, list);
3071 xmlAutomataSetFinalState(ctxt->am, ctxt->state);
3072 def->contModel = xmlAutomataCompile(ctxt->am);
3080 xmlFreeAutomata(ctxt->am);
3081 ctxt->state = oldstate;
3082 ctxt->am = oldam;
3084 xmlAutomataPtr oldam = ctxt->am;
3091 ret = xmlRelaxNGTryCompile(ctxt, def);
3092 ctxt->am = oldam;
3096 ret = xmlRelaxNGCompile(ctxt, def->content);
3099 xmlAutomataStatePtr oldstate = ctxt->state;
3101 xmlRelaxNGCompile(ctxt, def->content);
3102 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
3108 ctxt->state =
3109 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
3110 oldstate = ctxt->state;
3113 xmlRelaxNGCompile(ctxt, list);
3116 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate);
3117 ctxt->state =
3118 xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
3126 xmlRelaxNGCompile(ctxt, list);
3129 oldstate = ctxt->state;
3132 xmlRelaxNGCompile(ctxt, list);
3135 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate);
3136 ctxt->state =
3137 xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
3142 xmlAutomataStatePtr oldstate = ctxt->state;
3146 ctxt->state = oldstate;
3147 ret = xmlRelaxNGCompile(ctxt, list);
3151 target = ctxt->state;
3153 xmlAutomataNewEpsilon(ctxt->am, ctxt->state,
3158 ctxt->state = target;
3169 ret = xmlRelaxNGCompile(ctxt, list);
3178 ctxt->state =
3179 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
3180 oldstate = ctxt->state;
3181 xmlRelaxNGCompile(ctxt, def->content);
3182 xmlAutomataNewTransition(ctxt->am, ctxt->state,
3183 ctxt->state, BAD_CAST "#text",
3185 ctxt->state =
3186 xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
3190 ctxt->state =
3191 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
3211 * ctxt: the RelaxNG parser context
3220 xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
3225 if ((ctxt == NULL) || (def == NULL))
3232 ctxt->am = NULL;
3233 ret = xmlRelaxNGCompile(ctxt, def);
3257 ret = xmlRelaxNGTryCompile(ctxt, def->content);
3280 ret = xmlRelaxNGTryCompile(ctxt, list);
3303 ctxt, xmlNodePtr node);
3305 ctxt, xmlNodePtr node);
3307 ctxt, xmlNodePtr nodes,
3310 ctxt, xmlNodePtr node);
3311 static xmlRelaxNGPtr xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt,
3313 static int xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
3316 ctxt, xmlNodePtr node,
3320 ctxt, xmlNodePtr nodes);
3321 static int xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
3430 * @ctxt: a Relax-NG parser context
3438 xmlRelaxNGGetDataTypeLibrary(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
3480 * @ctxt: a Relax-NG parser context
3488 xmlRelaxNGParseValue(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
3496 def = xmlRelaxNGNewDefine(ctxt, node);
3505 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
3508 library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
3519 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
3526 xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
3532 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
3544 xmlRngPErr(ctxt, node, XML_RNGP_TEXT_EXPECTED,
3550 xmlRngPErr(ctxt, node, XML_RNGP_VALUE_NO_CONTENT,
3558 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_VALUE,
3572 * @ctxt: a Relax-NG parser context
3580 xmlRelaxNGParseData(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
3592 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_MISSING, "data has no type\n", NULL,
3598 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
3601 library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
3606 def = xmlRelaxNGNewDefine(ctxt, node);
3618 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
3625 xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
3631 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
3641 ctxt->idref = 1;
3655 xmlRngPErr(ctxt, node, XML_RNGP_PARAM_FORBIDDEN,
3663 param = xmlRelaxNGNewDefine(ctxt, node);
3668 xmlRngPErr(ctxt, node, XML_RNGP_PARAM_NAME_MISSING,
3692 except = xmlRelaxNGNewDefine(ctxt, node);
3700 xmlRngPErr(ctxt, content, XML_RNGP_EXCEPT_NO_CONTENT,
3704 tmp2 = xmlRelaxNGParsePattern(ctxt, child);
3721 xmlRngPErr(ctxt, content, XML_RNGP_DATA_CONTENT,
3751 xmlRelaxNGValidCtxt ctxt;
3753 memset(&ctxt, 0, sizeof(xmlRelaxNGValidCtxt));
3755 ctxt.flags = FLAGS_IGNORABLE | FLAGS_NOERROR;
3776 if (xmlRelaxNGElementMatch(&ctxt, def2, &node)) {
3813 if (xmlRelaxNGElementMatch(&ctxt, def1, &node)) {
3831 * @ctxt: a Relax-NG parser context
3842 xmlRelaxNGCompareElemDefLists(xmlRelaxNGParserCtxtPtr ctxt
3866 * @ctxt: a Relax-NG parser context
3874 xmlRelaxNGGenerateAttributes(xmlRelaxNGParserCtxtPtr ctxt,
3883 if (ctxt->nbErrors != 0)
3941 * @ctxt: a Relax-NG parser context
3950 xmlRelaxNGGetElements(xmlRelaxNGParserCtxtPtr ctxt,
3961 if (ctxt->nbErrors != 0)
3975 xmlRngPErrMemory(ctxt, "getting element list\n");
3985 xmlRngPErrMemory(ctxt, "getting element list\n");
4041 * @ctxt: a Relax-NG parser context
4047 xmlRelaxNGCheckChoiceDeterminism(xmlRelaxNGParserCtxtPtr ctxt,
4068 if (ctxt->nbErrors != 0)
4083 xmlRngPErrMemory(ctxt, "building choice\n");
4097 list[i] = xmlRelaxNGGetElements(ctxt, cur, 0);
4151 ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
4177 * @ctxt: a Relax-NG parser context
4183 xmlRelaxNGCheckGroupAttrs(xmlRelaxNGParserCtxtPtr ctxt,
4202 if (ctxt->nbErrors != 0)
4220 xmlRngPErrMemory(ctxt, "building group\n");
4226 list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
4232 list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
4243 ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
4245 xmlRngPErr(ctxt, def->node, XML_RNGP_GROUP_ATTR_CONFLICT,
4262 * @ctxt: a Relax-NG parser context
4276 xmlRelaxNGParserCtxtPtr ctxt,
4294 if (ctxt->nbErrors != 0)
4323 groups[nbgroups]->defs = xmlRelaxNGGetElements(ctxt, cur, 0);
4324 groups[nbgroups]->attrs = xmlRelaxNGGetElements(ctxt, cur, 1);
4348 ret = xmlRelaxNGCompareElemDefLists(ctxt, group->defs,
4351 xmlRngPErr(ctxt, def->node, XML_RNGP_ELEM_TEXT_CONFLICT,
4355 ret = xmlRelaxNGCompareElemDefLists(ctxt, group->attrs,
4358 xmlRngPErr(ctxt, def->node, XML_RNGP_ATTR_CONFLICT,
4421 xmlRngPErrMemory(ctxt, "in interleave computation\n");
4436 * @ctxt: a Relax-NG parser context
4444 xmlRelaxNGParseInterleave(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4450 def = xmlRelaxNGNewDefine(ctxt, node);
4456 if (ctxt->interleaves == NULL)
4457 ctxt->interleaves = xmlHashCreate(10);
4458 if (ctxt->interleaves == NULL) {
4459 xmlRngPErrMemory(ctxt, "create interleaves\n");
4463 snprintf(name, 32, "interleave%d", ctxt->nbInterleaves++);
4464 if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST name, def) < 0) {
4465 xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_ADD,
4472 xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_NO_CONTENT,
4477 cur = xmlRelaxNGParseElement(ctxt, child);
4479 cur = xmlRelaxNGParsePattern(ctxt, child);
4498 * @ctxt: a Relax-NG parser context
4506 xmlRelaxNGParseInclude(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4514 xmlRngPErr(ctxt, node, XML_RNGP_INCLUDE_EMPTY,
4520 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY, "Include document is empty\n",
4525 xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
4534 tmp = xmlRelaxNGParseGrammarContent(ctxt, root->children);
4539 tmp = xmlRelaxNGParseGrammarContent(ctxt, node->children);
4548 * @ctxt: a Relax-NG parser context
4556 xmlRelaxNGParseDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4565 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_NAME_MISSING,
4570 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_DEFINE_NAME,
4573 def = xmlRelaxNGNewDefine(ctxt, node);
4581 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_EMPTY,
4584 olddefine = ctxt->define;
4585 ctxt->define = name;
4587 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4588 ctxt->define = olddefine;
4590 if (ctxt->grammar->defs == NULL)
4591 ctxt->grammar->defs = xmlHashCreate(10);
4592 if (ctxt->grammar->defs == NULL) {
4593 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
4597 tmp = xmlHashAddEntry(ctxt->grammar->defs, name, def);
4601 prev = xmlHashLookup(ctxt->grammar->defs, name);
4603 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
4620 * @ctxt: the parser context
4628 xmlRelaxNGProcessExternalRef(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4638 def = xmlRelaxNGNewDefine(ctxt, node);
4649 xmlRngPErr(ctxt, node, XML_RNGP_EXTERNALREF_EMTPY,
4650 "xmlRelaxNGParse: %s is empty\n", ctxt->URL,
4679 oldflags = ctxt->flags;
4680 ctxt->flags |= XML_RELAXNG_IN_EXTERNALREF;
4681 docu->schema = xmlRelaxNGParseDocument(ctxt, root);
4682 ctxt->flags = oldflags;
4704 * @ctxt: a Relax-NG parser context
4713 xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4721 def = xmlRelaxNGParseElement(ctxt, node);
4723 def = xmlRelaxNGParseAttribute(ctxt, node);
4725 def = xmlRelaxNGNewDefine(ctxt, node);
4730 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_NOT_EMPTY,
4734 def = xmlRelaxNGNewDefine(ctxt, node);
4739 xmlRngPErr(ctxt, node, XML_RNGP_TEXT_HAS_CHILD,
4743 def = xmlRelaxNGNewDefine(ctxt, node);
4748 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4752 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4755 def = xmlRelaxNGNewDefine(ctxt, node);
4760 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4764 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4767 def = xmlRelaxNGNewDefine(ctxt, node);
4772 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4776 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4779 def = xmlRelaxNGNewDefine(ctxt, node);
4784 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4788 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4791 def = xmlRelaxNGNewDefine(ctxt, node);
4796 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4800 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4803 def = xmlRelaxNGNewDefine(ctxt, node);
4809 xmlRngPErr(ctxt, node, XML_RNGP_REF_NO_NAME, "ref has no name\n",
4814 xmlRngPErr(ctxt, node, XML_RNGP_REF_NAME_INVALID,
4820 xmlRngPErr(ctxt, node, XML_RNGP_REF_NOT_EMPTY, "ref is not empty\n",
4823 if (ctxt->grammar->refs == NULL)
4824 ctxt->grammar->refs = xmlHashCreate(10);
4825 if (ctxt->grammar->refs == NULL) {
4826 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4832 tmp = xmlHashAddEntry(ctxt->grammar->refs, def->name, def);
4837 xmlHashLookup(ctxt->grammar->refs, def->name);
4840 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4844 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4856 def = xmlRelaxNGParseData(ctxt, node);
4858 def = xmlRelaxNGParseValue(ctxt, node);
4860 def = xmlRelaxNGNewDefine(ctxt, node);
4865 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4869 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4872 def = xmlRelaxNGParseInterleave(ctxt, node);
4874 def = xmlRelaxNGProcessExternalRef(ctxt, node);
4876 def = xmlRelaxNGNewDefine(ctxt, node);
4881 xmlRngPErr(ctxt, node, XML_RNGP_NOTALLOWED_NOT_EMPTY,
4894 oldparent = ctxt->parentgrammar;
4895 old = ctxt->grammar;
4896 ctxt->parentgrammar = old;
4897 grammar = xmlRelaxNGParseGrammar(ctxt, node->children);
4899 ctxt->grammar = old;
4900 ctxt->parentgrammar = oldparent;
4913 if (ctxt->parentgrammar == NULL) {
4914 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_PARENT,
4919 def = xmlRelaxNGNewDefine(ctxt, node);
4925 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_NAME,
4930 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NAME_INVALID,
4936 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NOT_EMPTY,
4939 if (ctxt->parentgrammar->refs == NULL)
4940 ctxt->parentgrammar->refs = xmlHashCreate(10);
4941 if (ctxt->parentgrammar->refs == NULL) {
4942 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
4949 xmlHashAddEntry(ctxt->parentgrammar->refs, def->name, def);
4954 xmlHashLookup(ctxt->parentgrammar->refs, def->name);
4956 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
4968 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, "Mixed is empty\n",
4972 def = xmlRelaxNGParseInterleave(ctxt, node);
4977 tmp = xmlRelaxNGNewDefine(ctxt, node);
4985 tmp = xmlRelaxNGNewDefine(ctxt, node);
4994 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_CONSTRUCT,
5004 * @ctxt: a Relax-NG parser context
5012 xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
5018 ret = xmlRelaxNGNewDefine(ctxt, node);
5022 ret->parent = ctxt->def;
5025 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_EMPTY,
5030 old_flags = ctxt->flags;
5031 ctxt->flags |= XML_RELAXNG_IN_ATTRIBUTE;
5032 cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
5037 cur = xmlRelaxNGParsePattern(ctxt, child);
5064 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CONTENT,
5069 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_NOOP,
5078 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CHILDREN,
5081 ctxt->flags = old_flags;
5087 * @ctxt: a Relax-NG parser context
5096 xmlRelaxNGParseExceptNameClass(xmlRelaxNGParserCtxtPtr ctxt,
5103 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MISSING,
5108 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MULTIPLE,
5113 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_EMPTY, "except has no content\n",
5118 ret = xmlRelaxNGNewDefine(ctxt, node);
5124 cur = xmlRelaxNGNewDefine(ctxt, child);
5132 if (xmlRelaxNGParseNameClass(ctxt, child, cur) != NULL) {
5148 * @ctxt: a Relax-NG parser context
5157 xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node,
5168 ret = xmlRelaxNGNewDefine(ctxt, node);
5172 if (ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE)
5183 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
5187 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
5194 if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
5197 xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
5201 if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
5204 xmlRngPErr(ctxt, node, XML_RNGP_XMLNS_NAME,
5213 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
5221 xmlRngPErr(ctxt, node, XML_RNGP_NSNAME_NO_NS,
5224 if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
5228 xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
5234 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
5242 ret = xmlRelaxNGNewDefine(ctxt, node);
5249 xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_EMPTY,
5255 tmp = xmlRelaxNGParseNameClass(ctxt, child, ret);
5268 xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_CONTENT,
5289 * @ctxt: a Relax-NG parser context
5297 xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
5303 ret = xmlRelaxNGNewDefine(ctxt, node);
5307 ret->parent = ctxt->def;
5310 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_EMPTY,
5315 cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
5320 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NO_CONTENT,
5325 olddefine = ctxt->define;
5326 ctxt->define = NULL;
5329 cur = xmlRelaxNGParsePattern(ctxt, child);
5355 ret->content = xmlRelaxNGNewDefine(ctxt, node);
5372 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5377 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5382 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5387 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5395 ctxt->define = olddefine;
5401 * @ctxt: a Relax-NG parser context
5410 xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes,
5415 parent = ctxt->def;
5418 cur = xmlRelaxNGParseElement(ctxt, nodes);
5424 def = xmlRelaxNGNewDefine(ctxt, nodes);
5433 cur = xmlRelaxNGParsePattern(ctxt, nodes);
5450 * @ctxt: a Relax-NG parser context
5458 xmlRelaxNGParseStart(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
5464 xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY, "start has no children\n",
5469 def = xmlRelaxNGNewDefine(ctxt, nodes);
5474 xmlRngPErr(ctxt, nodes, XML_RNGP_EMPTY_CONTENT,
5478 def = xmlRelaxNGNewDefine(ctxt, nodes);
5483 xmlRngPErr(ctxt, nodes, XML_RNGP_NOTALLOWED_NOT_EMPTY,
5487 def = xmlRelaxNGParsePatterns(ctxt, nodes, 1);
5489 if (ctxt->grammar->start != NULL) {
5490 last = ctxt->grammar->start;
5495 ctxt->grammar->start = def;
5499 xmlRngPErr(ctxt, nodes, XML_RNGP_START_CONTENT,
5508 * @ctxt: a Relax-NG parser context
5516 xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
5522 xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_EMPTY,
5529 xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY,
5532 tmp = xmlRelaxNGParseStart(ctxt, nodes->children);
5537 tmp = xmlRelaxNGParseDefine(ctxt, nodes);
5541 tmp = xmlRelaxNGParseInclude(ctxt, nodes);
5545 xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
5558 * @ctxt: a Relax-NG parser context
5566 xmlRelaxNGParserCtxtPtr ctxt,
5572 grammar = ctxt->grammar;
5574 xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
5580 xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
5594 xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
5599 xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
5608 * @ctxt: a Relax-NG parser context
5616 xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * name)
5633 xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
5641 xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
5646 xmlRngPErr(ctxt, define->node, XML_RNGP_UNKNOWN_COMBINE,
5655 xmlRngPErr(ctxt, define->node, XML_RNGP_NEED_COMBINE,
5670 cur = xmlRelaxNGNewDefine(ctxt, define->node);
5685 tmp2 = xmlRelaxNGNewDefine(ctxt, tmp->content->node);
5705 if (ctxt->interleaves == NULL)
5706 ctxt->interleaves = xmlHashCreate(10);
5707 if (ctxt->interleaves == NULL) {
5708 xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5714 snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
5715 if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
5717 xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5727 * @ctxt: a Relax-NG parser context
5734 xmlRelaxNGCombineStart(xmlRelaxNGParserCtxtPtr ctxt,
5751 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_MISSING,
5763 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
5771 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
5776 xmlRngPErr(ctxt, cur->node, XML_RNGP_UNKNOWN_COMBINE,
5785 xmlRngPErr(ctxt, cur->node, XML_RNGP_NEED_COMBINE,
5800 cur = xmlRelaxNGNewDefine(ctxt, starts->node);
5810 if (ctxt->interleaves == NULL)
5811 ctxt->interleaves = xmlHashCreate(10);
5812 if (ctxt->interleaves == NULL) {
5813 xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5819 snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
5820 if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
5822 xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5832 * @ctxt: a Relax-NG parser context
5841 xmlRelaxNGCheckCycles(xmlRelaxNGParserCtxtPtr ctxt,
5851 ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
5854 xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_CYCLE,
5860 ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth + 1);
5862 ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
5871 * @ctxt: a Relax-NG parser context
5881 xmlRelaxNGTryUnlink(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
5905 * @ctxt: a Relax-NG parser context
5911 xmlRelaxNGSimplify(xmlRelaxNGParserCtxtPtr ctxt,
5921 xmlRelaxNGSimplify(ctxt, cur->content, cur);
5936 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
5950 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
5956 xmlRelaxNGSimplify(ctxt, cur->content, cur);
5958 xmlRelaxNGSimplify(ctxt, cur->attrs, cur);
5960 xmlRelaxNGSimplify(ctxt, cur->nameClass, cur);
5971 xmlRelaxNGGenerateAttributes(ctxt, cur->content);
5990 attronly = xmlRelaxNGGenerateAttributes(ctxt, tmp);
6030 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6044 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6058 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6122 * @ctxt: a Relax-NG parser context
6132 xmlRelaxNGCheckRules(xmlRelaxNGParserCtxtPtr ctxt,
6150 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_REF,
6156 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_REF,
6162 ret = xmlRelaxNGCheckRules(ctxt, cur->content,
6174 xmlRelaxNGCheckGroupAttrs(ctxt, cur);
6176 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ELEM,
6181 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ELEM,
6186 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
6191 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
6201 xmlRelaxNGCheckRules(ctxt, cur->attrs, nflags, cur->type);
6203 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_EMPTY,
6208 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6211 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_ERROR,
6219 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ATTR,
6224 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ATTR,
6229 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_GROUP_ATTR,
6234 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
6239 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ATTR,
6244 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ATTR,
6251 xmlRngPErr(ctxt, cur->node, XML_RNGP_ANYNAME_ATTR_ANCESTOR,
6255 xmlRngPErr(ctxt, cur->node, XML_RNGP_NSNAME_ATTR_ANCESTOR,
6261 xmlRelaxNGCheckRules(ctxt, cur->content, nflags, cur->type);
6266 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ONEMORE,
6271 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ONEMORE,
6277 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6282 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_LIST,
6287 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_LIST,
6292 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_LIST,
6298 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6302 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_GROUP,
6307 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_GROUP,
6316 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6321 xmlRelaxNGCheckGroupAttrs(ctxt, cur);
6324 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_INTERLEAVE,
6329 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
6334 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
6343 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6352 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6356 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_DATA,
6360 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6364 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_VALUE,
6368 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6372 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_TEXT,
6377 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_TEXT,
6382 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_TEXT,
6389 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_EMPTY,
6394 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_EMPTY,
6400 xmlRelaxNGCheckChoiceDeterminism(ctxt, cur);
6402 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6405 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6433 * @ctxt: a Relax-NG parser context
6442 xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
6450 ret = xmlRelaxNGNewGrammar(ctxt);
6457 ret->parent = ctxt->grammar;
6458 if (ctxt->grammar != NULL) {
6459 tmp = ctxt->grammar->children;
6461 ctxt->grammar->children = ret;
6469 old = ctxt->grammar;
6470 ctxt->grammar = ret;
6471 xmlRelaxNGParseGrammarContent(ctxt, nodes);
6472 ctxt->grammar = ret;
6473 if (ctxt->grammar == NULL) {
6474 xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
6476 } else if (ctxt->grammar->start == NULL) {
6477 xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_NO_START,
6484 xmlRelaxNGCombineStart(ctxt, ret);
6487 ctxt);
6495 ctxt);
6498 ctxt->grammar = old;
6504 * @ctxt: a Relax-NG parser context
6514 xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
6520 if ((ctxt == NULL) || (node == NULL))
6523 schema = xmlRelaxNGNewRelaxNG(ctxt);
6527 olddefine = ctxt->define;
6528 ctxt->define = NULL;
6530 schema->topgrammar = xmlRelaxNGParseGrammar(ctxt, node->children);
6534 schema->topgrammar = ret = xmlRelaxNGNewGrammar(ctxt);
6541 ret->parent = ctxt->grammar;
6542 if (ctxt->grammar != NULL) {
6543 tmp = ctxt->grammar->children;
6545 ctxt->grammar->children = ret;
6552 old = ctxt->grammar;
6553 ctxt->grammar = ret;
6554 xmlRelaxNGParseStart(ctxt, node);
6556 ctxt->grammar = old;
6558 ctxt->define = olddefine;
6560 xmlRelaxNGCheckCycles(ctxt, schema->topgrammar->start, 0);
6561 if ((ctxt->flags & XML_RELAXNG_IN_EXTERNALREF) == 0) {
6562 xmlRelaxNGSimplify(ctxt, schema->topgrammar->start, NULL);
6568 xmlRelaxNGCheckRules(ctxt, schema->topgrammar->start,
6686 * @ctxt: the schema parser context
6691 xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxtPtr ctxt)
6693 if (ctxt == NULL)
6695 if (ctxt->URL != NULL)
6696 xmlFree(ctxt->URL);
6697 if (ctxt->doc != NULL)
6698 xmlRelaxNGFreeDocument(ctxt->doc);
6699 if (ctxt->interleaves != NULL)
6700 xmlHashFree(ctxt->interleaves, NULL);
6701 if (ctxt->documents != NULL)
6702 xmlRelaxNGFreeDocumentList(ctxt->documents);
6703 if (ctxt->includes != NULL)
6704 xmlRelaxNGFreeIncludeList(ctxt->includes);
6705 if (ctxt->docTab != NULL)
6706 xmlFree(ctxt->docTab);
6707 if (ctxt->incTab != NULL)
6708 xmlFree(ctxt->incTab);
6709 if (ctxt->defTab != NULL) {
6712 for (i = 0; i < ctxt->defNr; i++)
6713 xmlRelaxNGFreeDefine(ctxt->defTab[i]);
6714 xmlFree(ctxt->defTab);
6716 if ((ctxt->document != NULL) && (ctxt->freedoc))
6717 xmlFreeDoc(ctxt->document);
6718 xmlFree(ctxt);
6775 * @ctxt: a Relax-NG parser context
6781 xmlRelaxNGCleanupAttributes(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
6797 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6804 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6811 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6818 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6831 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_URI,
6836 xmlRngPErr(ctxt, node, XML_RNGP_URI_NOT_ABSOLUTE,
6841 xmlRngPErr(ctxt, node, XML_RNGP_URI_FRAGMENT,
6851 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_ATTRIBUTE,
6862 * @ctxt: a Relax-NG parser context
6869 xmlRelaxNGCleanupTree(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr root)
6892 xmlRngPErr(ctxt, cur, XML_RNGP_FOREIGN_ELEMENT,
6899 xmlRelaxNGCleanupAttributes(ctxt, cur);
6919 xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
6929 xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
6940 xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
6955 xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
6971 docu = xmlRelaxNGLoadExternalRef(ctxt, URL, ns);
6973 xmlRngPErr(ctxt, cur, XML_RNGP_EXTERNAL_REF_FAILURE,
6993 xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
7002 xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
7027 incl = xmlRelaxNGLoadInclude(ctxt, URL, cur, ns);
7031 xmlRngPErr(ctxt, cur, XML_RNGP_INCLUDE_FAILURE,
7069 xmlRngPErr(ctxt, cur, XML_RNGP_CREATE_FAILURE,
7128 xmlRngPErr(ctxt, cur,
7147 if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
7148 xmlRngPErr(ctxt, cur,
7156 int oldflags = ctxt->flags;
7164 ctxt->flags |= XML_RELAXNG_IN_ANYEXCEPT;
7165 xmlRelaxNGCleanupTree(ctxt, cur);
7166 ctxt->flags = oldflags;
7171 ctxt->flags |= XML_RELAXNG_IN_NSEXCEPT;
7172 xmlRelaxNGCleanupTree(ctxt, cur);
7173 ctxt->flags = oldflags;
7180 if (ctxt->flags & XML_RELAXNG_IN_ANYEXCEPT) {
7181 xmlRngPErr(ctxt, cur,
7185 } else if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
7186 xmlRngPErr(ctxt, cur,
7302 * @ctxt: a Relax-NG parser context
7311 xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt, xmlDocPtr doc)
7320 xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
7321 ctxt->URL, NULL);
7324 xmlRelaxNGCleanupTree(ctxt, root);
7330 * @ctxt: a Relax-NG parser context
7339 xmlRelaxNGParse(xmlRelaxNGParserCtxtPtr ctxt)
7347 if (ctxt == NULL)
7353 if (ctxt->URL != NULL) {
7354 doc = xmlReadFile((const char *) ctxt->URL,NULL,0);
7356 xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
7357 "xmlRelaxNGParse: could not load %s\n", ctxt->URL,
7361 } else if (ctxt->buffer != NULL) {
7362 doc = xmlReadMemory(ctxt->buffer, ctxt->size,NULL,NULL,0);
7364 xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
7370 ctxt->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
7371 } else if (ctxt->document != NULL) {
7372 doc = ctxt->document;
7374 xmlRngPErr(ctxt, NULL, XML_RNGP_EMPTY,
7378 ctxt->document = doc;
7383 doc = xmlRelaxNGCleanupDoc(ctxt, doc);
7385 xmlFreeDoc(ctxt->document);
7386 ctxt->document = NULL;
7395 xmlRngPErr(ctxt, (xmlNodePtr) doc,
7397 (ctxt->URL ? ctxt->URL : BAD_CAST "schemas"), NULL);
7399 xmlFreeDoc(ctxt->document);
7400 ctxt->document = NULL;
7403 ret = xmlRelaxNGParseDocument(ctxt, root);
7405 xmlFreeDoc(ctxt->document);
7406 ctxt->document = NULL;
7416 if (ctxt->interleaves != NULL) {
7417 xmlHashScan(ctxt->interleaves,
7418 (xmlHashScanner) xmlRelaxNGComputeInterleaves, ctxt);
7424 if (ctxt->nbErrors > 0) {
7426 ctxt->document = NULL;
7438 def = xmlRelaxNGNewDefine(ctxt, NULL);
7445 xmlRelaxNGTryCompile(ctxt, ret->topgrammar->start);
7452 ctxt->document = NULL;
7453 ret->documents = ctxt->documents;
7454 ctxt->documents = NULL;
7456 ret->includes = ctxt->includes;
7457 ctxt->includes = NULL;
7458 ret->defNr = ctxt->defNr;
7459 ret->defTab = ctxt->defTab;
7460 ctxt->defTab = NULL;
7461 if (ctxt->idref == 1)
7469 * @ctxt: a Relax-NG validation context
7477 xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
7481 if (ctxt == NULL)
7483 ctxt->error = err;
7484 ctxt->warning = warn;
7485 ctxt->serror = NULL;
7486 ctxt->userData = ctx;
7491 * @ctxt: a Relax-NG validation context
7501 xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
7505 if (ctxt == NULL)
7508 *err = ctxt->error;
7510 *warn = ctxt->warning;
7512 *ctx = ctxt->userData;
7518 * @ctxt: a Relax-NG parser context
7525 xmlRelaxNGSetParserStructuredErrors(xmlRelaxNGParserCtxtPtr ctxt,
7529 if (ctxt == NULL)
7531 ctxt->serror = serror;
7532 ctxt->error = NULL;
7533 ctxt->warning = NULL;
7534 ctxt->userData = ctx;
7780 static int xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
7797 xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata;
7805 if (ctxt == NULL) {
7813 if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
7814 ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
7817 if ((ctxt == NULL) || (define == NULL)) {
7819 if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
7820 ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
7824 if (ctxt->errNo == XML_RELAXNG_OK)
7825 ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
7828 ret = xmlRelaxNGValidateDefinition(ctxt, define);
7830 ctxt->perr = ret;
7835 * @ctxt: the RelaxNG validation context
7844 xmlRelaxNGValidateCompiledContent(xmlRelaxNGValidCtxtPtr ctxt,
7852 if ((ctxt == NULL) || (regexp == NULL))
7854 oldperr = ctxt->perr;
7856 xmlRelaxNGValidateCompiledCallback, ctxt);
7857 ctxt->perr = 0;
7860 ctxt->state->seq = cur;
7866 ret = xmlRegExecPushString(exec, BAD_CAST "#text", ctxt);
7875 cur->ns->href, ctxt);
7877 ret = xmlRegExecPushString(exec, cur->name, ctxt);
7896 ctxt->state->seq = NULL;
7903 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
7904 xmlRelaxNGDumpValidError(ctxt);
7913 if ((ret == 0) && (ctxt->perr != 0)) {
7914 ret = ctxt->perr;
7916 ctxt->perr = oldperr;
7925 static int xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
7927 static int xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt,
7929 static void xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt);
7933 * @ctxt: the validation context
7941 xmlRelaxNGElemPush(xmlRelaxNGValidCtxtPtr ctxt, xmlRegExecCtxtPtr exec)
7943 if (ctxt->elemTab == NULL) {
7944 ctxt->elemMax = 10;
7945 ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlMalloc(ctxt->elemMax *
7948 if (ctxt->elemTab == NULL) {
7949 xmlRngVErrMemory(ctxt, "validating\n");
7953 if (ctxt->elemNr >= ctxt->elemMax) {
7954 ctxt->elemMax *= 2;
7955 ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlRealloc(ctxt->elemTab,
7956 ctxt->elemMax *
7959 if (ctxt->elemTab == NULL) {
7960 xmlRngVErrMemory(ctxt, "validating\n");
7964 ctxt->elemTab[ctxt->elemNr++] = exec;
7965 ctxt->elem = exec;
7971 * @ctxt: the validation context
7978 xmlRelaxNGElemPop(xmlRelaxNGValidCtxtPtr ctxt)
7982 if (ctxt->elemNr <= 0)
7984 ctxt->elemNr--;
7985 ret = ctxt->elemTab[ctxt->elemNr];
7986 ctxt->elemTab[ctxt->elemNr] = NULL;
7987 if (ctxt->elemNr > 0)
7988 ctxt->elem = ctxt->elemTab[ctxt->elemNr - 1];
7990 ctxt->elem = NULL;
8010 xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata;
8020 if (ctxt == NULL) {
8024 node = ctxt->pnode;
8025 ctxt->pstate = 1;
8030 if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
8031 ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
8032 ctxt->pstate = -1;
8035 if ((ctxt == NULL) || (define == NULL)) {
8037 if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
8038 ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
8039 ctxt->pstate = -1;
8043 if (ctxt->errNo == XML_RELAXNG_OK)
8044 ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
8045 ctxt->pstate = -1;
8050 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
8051 xmlRelaxNGDumpValidError(ctxt);
8052 ctxt->pstate = -1;
8064 ctxt->pstate = 0;
8065 ctxt->pdef = define;
8069 xmlRelaxNGValidateProgressiveCallback, ctxt);
8071 ctxt->pstate = -1;
8074 xmlRelaxNGElemPush(ctxt, exec);
8079 state = xmlRelaxNGNewValidState(ctxt, node);
8081 ctxt->pstate = -1;
8084 oldstate = ctxt->state;
8085 ctxt->state = state;
8087 ret = xmlRelaxNGValidateAttributeList(ctxt, define->attrs);
8089 ctxt->pstate = -1;
8093 if (ctxt->state != NULL) {
8094 ctxt->state->seq = NULL;
8095 ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
8097 ctxt->pstate = -1;
8099 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
8100 } else if (ctxt->states != NULL) {
8103 oldflags = ctxt->flags;
8105 for (i = 0; i < ctxt->states->nbState; i++) {
8106 state = ctxt->states->tabState[i];
8107 ctxt->state = state;
8108 ctxt->state->seq = NULL;
8110 if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
8119 ctxt->flags |= FLAGS_IGNORABLE;
8120 xmlRelaxNGLogBestError(ctxt);
8122 for (i = 0; i < ctxt->states->nbState; i++) {
8123 xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[i]);
8125 xmlRelaxNGFreeStates(ctxt, ctxt->states);
8126 ctxt->states = NULL;
8128 ctxt->pstate = -1;
8129 ctxt->flags = oldflags;
8131 if (ctxt->pstate == -1) {
8132 if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
8133 xmlRelaxNGDumpValidError(ctxt);
8136 ctxt->state = oldstate;
8141 * @ctxt: the validation context
8151 xmlRelaxNGValidatePushElement(xmlRelaxNGValidCtxtPtr ctxt,
8157 if ((ctxt == NULL) || (elem == NULL))
8163 if (ctxt->elem == 0) {
8169 schema = ctxt->schema;
8181 ctxt->pdef = define;
8186 ctxt);
8190 xmlRelaxNGElemPush(ctxt, exec);
8192 ctxt->pnode = elem;
8193 ctxt->pstate = 0;
8196 xmlRegExecPushString2(ctxt->elem, elem->name, elem->ns->href,
8197 ctxt);
8199 ret = xmlRegExecPushString(ctxt->elem, elem->name, ctxt);
8204 if (ctxt->pstate == 0)
8206 else if (ctxt->pstate < 0)
8221 * @ctxt: the RelaxNG validation context
8230 xmlRelaxNGValidatePushCData(xmlRelaxNGValidCtxtPtr ctxt,
8235 if ((ctxt == NULL) || (ctxt->elem == NULL) || (data == NULL))
8250 ret = xmlRegExecPushString(ctxt->elem, BAD_CAST "#text", ctxt);
8264 * @ctxt: the RelaxNG validation context
8273 xmlRelaxNGValidatePopElement(xmlRelaxNGValidCtxtPtr ctxt,
8280 if ((ctxt == NULL) || (ctxt->elem == NULL) || (elem == NULL))
8288 exec = xmlRelaxNGElemPop(ctxt);
8312 * @ctxt: the validation context
8322 xmlRelaxNGValidateFullElement(xmlRelaxNGValidCtxtPtr ctxt,
8329 if ((ctxt == NULL) || (ctxt->pdef == NULL) || (elem == NULL))
8334 state = xmlRelaxNGNewValidState(ctxt, elem->parent);
8339 ctxt->state = state;
8340 ctxt->errNo = XML_RELAXNG_OK;
8341 ret = xmlRelaxNGValidateDefinition(ctxt, ctxt->pdef);
8342 if ((ret != 0) || (ctxt->errNo != XML_RELAXNG_OK))
8346 xmlRelaxNGFreeValidState(ctxt, state);
8347 ctxt->state = NULL;
8361 static int xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
8366 * @ctxt: a schema validation context
8374 xmlRelaxNGSkipIgnored(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
8387 ((ctxt->flags & FLAGS_MIXED_CONTENT) ||
8396 * @ctxt: a schema validation context
8405 xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt, const xmlChar * str)
8420 xmlRngVErrMemory(ctxt, "validating\n");
8442 * @ctxt: a Relax-NG validation context
8452 xmlRelaxNGValidateDatatype(xmlRelaxNGValidCtxtPtr ctxt,
8501 oldvalue = ctxt->state->value;
8502 oldendvalue = ctxt->state->endvalue;
8503 ctxt->state->value = (xmlChar *) value;
8504 ctxt->state->endvalue = NULL;
8505 ret = xmlRelaxNGValidateValue(ctxt, define->content);
8506 ctxt->state->value = (xmlChar *) oldvalue;
8507 ctxt->state->endvalue = (xmlChar *) oldendvalue;
8516 * @ctxt: a Relax-NG validation context
8523 xmlRelaxNGNextValue(xmlRelaxNGValidCtxtPtr ctxt)
8527 cur = ctxt->state->value;
8528 if ((cur == NULL) || (ctxt->state->endvalue == NULL)) {
8529 ctxt->state->value = NULL;
8530 ctxt->state->endvalue = NULL;
8535 while ((cur != ctxt->state->endvalue) && (*cur == 0))
8537 if (cur == ctxt->state->endvalue)
8538 ctxt->state->value = NULL;
8540 ctxt->state->value = cur;
8546 * @ctxt: a Relax-NG validation context
8554 xmlRelaxNGValidateValueList(xmlRelaxNGValidCtxtPtr ctxt,
8560 ret = xmlRelaxNGValidateValue(ctxt, defines);
8570 * @ctxt: a Relax-NG validation context
8578 xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
8584 value = ctxt->state->value;
8609 value, ctxt->state->node);
8628 nval = xmlRelaxNGNormalize(ctxt, define->value);
8629 nvalue = xmlRelaxNGNormalize(ctxt, value);
8641 xmlRelaxNGNextValue(ctxt);
8645 ret = xmlRelaxNGValidateDatatype(ctxt, value, define,
8646 ctxt->state->seq);
8648 xmlRelaxNGNextValue(ctxt);
8656 oldflags = ctxt->flags;
8657 ctxt->flags |= FLAGS_IGNORABLE;
8659 oldvalue = ctxt->state->value;
8661 ret = xmlRelaxNGValidateValue(ctxt, list);
8665 ctxt->state->value = oldvalue;
8668 ctxt->flags = oldflags;
8670 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
8671 xmlRelaxNGDumpValidError(ctxt);
8673 if (ctxt->errNr > 0)
8674 xmlRelaxNGPopErrors(ctxt, 0);
8686 oldvalue = ctxt->state->value;
8687 oldend = ctxt->state->endvalue;
8716 ctxt->state->endvalue = cur;
8718 while ((*cur == 0) && (cur != ctxt->state->endvalue))
8721 ctxt->state->value = cur;
8724 if (ctxt->state->value == ctxt->state->endvalue)
8725 ctxt->state->value = NULL;
8726 ret = xmlRelaxNGValidateValue(ctxt, list);
8731 ctxt->state->value, nb_values);
8741 if ((ret == 0) && (ctxt->state->value != NULL) &&
8742 (ctxt->state->value != ctxt->state->endvalue)) {
8744 ctxt->state->value);
8748 ctxt->state->value = oldvalue;
8749 ctxt->state->endvalue = oldend;
8753 ret = xmlRelaxNGValidateValueList(ctxt, define->content);
8761 oldflags = ctxt->flags;
8762 ctxt->flags |= FLAGS_IGNORABLE;
8763 cur = ctxt->state->value;
8765 while ((cur != NULL) && (cur != ctxt->state->endvalue) &&
8769 xmlRelaxNGValidateValueList(ctxt, define->content);
8771 ctxt->state->value = temp;
8775 cur = ctxt->state->value;
8777 ctxt->flags = oldflags;
8778 if (ctxt->errNr > 0)
8779 xmlRelaxNGPopErrors(ctxt, 0);
8787 ret = xmlRelaxNGValidateValue(ctxt, list);
8803 ret = xmlRelaxNGValidateValue(ctxt, list);
8815 ret = xmlRelaxNGValidateValue(ctxt, define->content);
8825 * @ctxt: a Relax-NG validation context
8833 xmlRelaxNGValidateValueContent(xmlRelaxNGValidCtxtPtr ctxt,
8839 ret = xmlRelaxNGValidateValue(ctxt, defines);
8849 * @ctxt: a Relax-NG validation context
8858 xmlRelaxNGAttributeMatch(xmlRelaxNGValidCtxtPtr ctxt,
8885 ret = xmlRelaxNGAttributeMatch(ctxt, list, prop);
8899 * @ctxt: a Relax-NG validation context
8907 xmlRelaxNGValidateAttribute(xmlRelaxNGValidCtxtPtr ctxt,
8915 if (ctxt->state->nbAttrLeft <= 0)
8918 for (i = 0; i < ctxt->state->nbAttrs; i++) {
8919 tmp = ctxt->state->attrs[i];
8932 oldvalue = ctxt->state->value;
8933 oldseq = ctxt->state->seq;
8934 ctxt->state->seq = (xmlNodePtr) prop;
8935 ctxt->state->value = value;
8936 ctxt->state->endvalue = NULL;
8937 ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
8938 if (ctxt->state->value != NULL)
8939 value = ctxt->state->value;
8942 ctxt->state->value = oldvalue;
8943 ctxt->state->seq = oldseq;
8948 ctxt->state->attrs[i] = NULL;
8949 ctxt->state->nbAttrLeft--;
8960 for (i = 0; i < ctxt->state->nbAttrs; i++) {
8961 tmp = ctxt->state->attrs[i];
8963 (xmlRelaxNGAttributeMatch(ctxt, define, tmp) == 1)) {
8970 oldvalue = ctxt->state->value;
8971 oldseq = ctxt->state->seq;
8972 ctxt->state->seq = (xmlNodePtr) prop;
8973 ctxt->state->value = value;
8974 ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
8975 if (ctxt->state->value != NULL)
8976 value = ctxt->state->value;
8979 ctxt->state->value = oldvalue;
8980 ctxt->state->seq = oldseq;
8985 ctxt->state->attrs[i] = NULL;
8986 ctxt->state->nbAttrLeft--;
9009 * @ctxt: a Relax-NG validation context
9017 xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
9027 if (xmlRelaxNGValidateAttribute(ctxt, cur) != 0)
9038 if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
9039 res = xmlRelaxNGValidateDefinition(ctxt, cur);
9092 * @ctxt: a Relax-NG validation context
9100 xmlRelaxNGValidateInterleave(xmlRelaxNGValidCtxtPtr ctxt,
9104 int errNr = ctxt->errNr;
9123 oldflags = ctxt->flags;
9125 ctxt->flags |= FLAGS_MIXED_CONTENT;
9130 if (ctxt->state != NULL)
9131 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
9132 ctxt->state->seq);
9134 ret = xmlRelaxNGValidateDefinition(ctxt,
9138 ret = xmlRelaxNGValidateDefinition(ctxt,
9142 if (ctxt->state != NULL)
9143 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
9144 ctxt->state->
9147 ctxt->flags = oldflags;
9158 xmlRngVErrMemory(ctxt, "validating\n");
9164 xmlRngVErrMemory(ctxt, "validating\n");
9173 cur = ctxt->state->seq;
9174 cur = xmlRelaxNGSkipIgnored(ctxt, cur);
9177 ctxt->state->seq = cur;
9240 cur = xmlRelaxNGSkipIgnored(ctxt, cur->next);
9248 oldstate = ctxt->state;
9250 ctxt->state = xmlRelaxNGCopyValidState(ctxt, oldstate);
9256 ctxt->state->seq = list[i];
9257 ret = xmlRelaxNGValidateDefinition(ctxt, group->rule);
9260 if (ctxt->state != NULL) {
9261 cur = ctxt->state->seq;
9262 cur = xmlRelaxNGSkipIgnored(ctxt, cur);
9263 xmlRelaxNGFreeValidState(ctxt, oldstate);
9264 oldstate = ctxt->state;
9265 ctxt->state = NULL;
9269 ctxt->state = oldstate;
9272 } else if (ctxt->states != NULL) {
9282 for (j = 0; j < ctxt->states->nbState; j++) {
9283 cur = ctxt->states->tabState[j]->seq;
9284 cur = xmlRelaxNGSkipIgnored(ctxt, cur);
9287 lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9291 if (ctxt->states->tabState[j]->nbAttrLeft <= lowattr) {
9293 lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9300 lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9303 if (ctxt->states->tabState[j]->nbAttrLeft <= lowattr) {
9305 lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9313 if (ctxt->states->nbState > 0) {
9314 xmlRelaxNGFreeValidState(ctxt, oldstate);
9316 oldstate = ctxt->states->tabState[best];
9317 ctxt->states->tabState[best] = NULL;
9320 ctxt->states->tabState[ctxt->states->nbState - 1];
9321 ctxt->states->tabState[ctxt->states->nbState - 1] = NULL;
9324 for (j = 0; j < ctxt->states->nbState ; j++) {
9325 xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[j]);
9327 xmlRelaxNGFreeStates(ctxt, ctxt->states);
9328 ctxt->states = NULL;
9332 ctxt->state = oldstate;
9343 if (ctxt->state != NULL)
9344 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
9345 ctxt->state = oldstate;
9346 ctxt->state->seq = lastelem;
9354 ctxt->flags = oldflags;
9366 if (ctxt->errNr > errNr)
9367 xmlRelaxNGPopErrors(ctxt, errNr);
9377 * @ctxt: a Relax-NG validation context
9385 xmlRelaxNGValidateDefinitionList(xmlRelaxNGValidCtxtPtr ctxt,
9397 if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
9398 res = xmlRelaxNGValidateDefinition(ctxt, defines);
9415 * @ctxt: a Relax-NG validation context
9424 xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
9460 if (ctxt != NULL) {
9461 oldflags = ctxt->flags;
9462 ctxt->flags |= FLAGS_IGNORABLE;
9467 ret = xmlRelaxNGElementMatch(ctxt, list, elem);
9469 if (ctxt != NULL)
9470 ctxt->flags = oldflags;
9474 if (ctxt != NULL)
9475 ctxt->flags = oldflags;
9481 if (ctxt != NULL) {
9482 ctxt->flags = oldflags;
9487 if (ctxt != NULL) {
9488 oldflags = ctxt->flags;
9489 ctxt->flags |= FLAGS_IGNORABLE;
9494 ret = xmlRelaxNGElementMatch(ctxt, list, elem);
9496 if (ctxt != NULL)
9497 ctxt->flags = oldflags;
9501 if (ctxt != NULL)
9502 ctxt->flags = oldflags;
9507 if (ctxt != NULL) {
9509 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9510 xmlRelaxNGDumpValidError(ctxt);
9512 if (ctxt->errNr > 0)
9513 xmlRelaxNGPopErrors(ctxt, 0);
9517 if (ctxt != NULL) {
9518 ctxt->flags = oldflags;
9528 * @ctxt: a Relax-NG validation context
9530 * Find the "best" state in the ctxt->states list of states to report
9538 xmlRelaxNGBestState(xmlRelaxNGValidCtxtPtr ctxt)
9545 if ((ctxt == NULL) || (ctxt->states == NULL) ||
9546 (ctxt->states->nbState <= 0))
9549 for (i = 0; i < ctxt->states->nbState; i++) {
9550 state = ctxt->states->tabState[i];
9571 * @ctxt: a Relax-NG validation context
9573 * Find the "best" state in the ctxt->states list of states to report
9577 xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt)
9581 if ((ctxt == NULL) || (ctxt->states == NULL) ||
9582 (ctxt->states->nbState <= 0))
9585 best = xmlRelaxNGBestState(ctxt);
9586 if ((best >= 0) && (best < ctxt->states->nbState)) {
9587 ctxt->state = ctxt->states->tabState[best];
9589 xmlRelaxNGValidateElementEnd(ctxt, 1);
9595 * @ctxt: a Relax-NG validation context
9605 xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt, int dolog)
9610 state = ctxt->state;
9612 state->seq = xmlRelaxNGSkipIgnored(ctxt, state->seq);
9635 * @ctxt: a Relax-NG validation context
9643 xmlRelaxNGValidateState(xmlRelaxNGValidCtxtPtr ctxt,
9655 if (ctxt->state != NULL) {
9656 node = ctxt->state->seq;
9661 for (i = 0; i < ctxt->depth; i++)
9672 ctxt->depth++;
9675 node = xmlRelaxNGSkipIgnored(ctxt, node);
9688 ctxt->state->seq = node;
9691 errNr = ctxt->errNr;
9692 node = xmlRelaxNGSkipIgnored(ctxt, node);
9696 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9697 xmlRelaxNGDumpValidError(ctxt);
9703 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9704 xmlRelaxNGDumpValidError(ctxt);
9712 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
9713 if (ctxt->errNr > errNr)
9714 xmlRelaxNGPopErrors(ctxt, errNr);
9715 if (ctxt->errNr != 0) {
9716 while ((ctxt->err != NULL) &&
9717 (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME)
9718 && (xmlStrEqual(ctxt->err->arg2, node->name)))
9720 ((ctxt->err->err ==
9722 && (xmlStrEqual(ctxt->err->arg1, node->name)))
9723 || (ctxt->err->err == XML_RELAXNG_ERR_NOELEM)
9724 || (ctxt->err->err ==
9726 xmlRelaxNGValidErrorPop(ctxt);
9731 ret = xmlRelaxNGElementMatch(ctxt, define, node);
9734 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9735 xmlRelaxNGDumpValidError(ctxt);
9739 if (ctxt->errNr != 0) {
9740 if (ctxt->errNr > errNr)
9741 xmlRelaxNGPopErrors(ctxt, errNr);
9742 while ((ctxt->err != NULL) &&
9743 (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME) &&
9744 (xmlStrEqual(ctxt->err->arg2, node->name))) ||
9745 ((ctxt->err->err == XML_RELAXNG_ERR_ELEMEXTRANS) &&
9746 (xmlStrEqual(ctxt->err->arg1, node->name))) ||
9747 (ctxt->err->err == XML_RELAXNG_ERR_NOELEM) ||
9748 (ctxt->err->err == XML_RELAXNG_ERR_NOTELEM)))
9749 xmlRelaxNGValidErrorPop(ctxt);
9751 errNr = ctxt->errNr;
9753 oldflags = ctxt->flags;
9754 if (ctxt->flags & FLAGS_MIXED_CONTENT) {
9755 ctxt->flags -= FLAGS_MIXED_CONTENT;
9757 state = xmlRelaxNGNewValidState(ctxt, node);
9760 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9761 xmlRelaxNGDumpValidError(ctxt);
9765 oldstate = ctxt->state;
9766 ctxt->state = state;
9768 tmp = xmlRelaxNGValidateAttributeList(ctxt, define->attrs);
9775 xmlRelaxNGValidStatePtr nstate, tmpstate = ctxt->state;
9776 xmlRelaxNGStatesPtr tmpstates = ctxt->states;
9779 nstate = xmlRelaxNGNewValidState(ctxt, node);
9780 ctxt->state = nstate;
9781 ctxt->states = NULL;
9783 tmp = xmlRelaxNGValidateCompiledContent(ctxt,
9785 ctxt->state->seq);
9786 nseq = ctxt->state->seq;
9787 ctxt->state = tmpstate;
9788 ctxt->states = tmpstates;
9789 xmlRelaxNGFreeValidState(ctxt, nstate);
9799 if (ctxt->states != NULL) {
9802 for (i = 0; i < ctxt->states->nbState; i++) {
9803 state = ctxt->states->tabState[i];
9804 ctxt->state = state;
9805 ctxt->state->seq = nseq;
9807 if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
9816 ctxt->flags |= FLAGS_IGNORABLE;
9817 xmlRelaxNGLogBestError(ctxt);
9819 for (i = 0; i < ctxt->states->nbState; i++) {
9820 xmlRelaxNGFreeValidState(ctxt,
9821 ctxt->states->
9824 xmlRelaxNGFreeStates(ctxt, ctxt->states);
9825 ctxt->flags = oldflags;
9826 ctxt->states = NULL;
9830 state = ctxt->state;
9831 if (ctxt->state != NULL)
9832 ctxt->state->seq = nseq;
9834 ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
9835 xmlRelaxNGFreeValidState(ctxt, state);
9839 tmp = xmlRelaxNGValidateDefinitionList(ctxt,
9844 if (ctxt->state == NULL) {
9845 ctxt->state = oldstate;
9848 ctxt->state = NULL;
9856 if (ctxt->states != NULL) {
9859 for (i = 0; i < ctxt->states->nbState; i++) {
9860 state = ctxt->states->tabState[i];
9861 ctxt->state = state;
9863 if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
9872 ctxt->flags |= FLAGS_IGNORABLE;
9873 xmlRelaxNGLogBestError(ctxt);
9875 for (i = 0; i < ctxt->states->nbState; i++) {
9876 xmlRelaxNGFreeValidState(ctxt,
9877 ctxt->states->
9880 xmlRelaxNGFreeStates(ctxt, ctxt->states);
9881 ctxt->flags = oldflags;
9882 ctxt->states = NULL;
9886 state = ctxt->state;
9888 ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
9889 xmlRelaxNGFreeValidState(ctxt, state);
9895 ctxt->flags = oldflags;
9896 ctxt->state = oldstate;
9898 oldstate->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
9900 if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
9901 xmlRelaxNGDumpValidError(ctxt);
9909 if (ctxt->errNr > errNr)
9910 xmlRelaxNGPopErrors(ctxt, errNr);
9930 errNr = ctxt->errNr;
9931 oldflags = ctxt->flags;
9932 ctxt->flags |= FLAGS_IGNORABLE;
9933 oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
9935 xmlRelaxNGValidateDefinitionList(ctxt,
9938 if (ctxt->state != NULL)
9939 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
9940 ctxt->state = oldstate;
9941 ctxt->flags = oldflags;
9943 if (ctxt->errNr > errNr)
9944 xmlRelaxNGPopErrors(ctxt, errNr);
9947 if (ctxt->states != NULL) {
9948 xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
9950 ctxt->states = xmlRelaxNGNewStates(ctxt, 1);
9951 if (ctxt->states == NULL) {
9952 xmlRelaxNGFreeValidState(ctxt, oldstate);
9953 ctxt->flags = oldflags;
9955 if (ctxt->errNr > errNr)
9956 xmlRelaxNGPopErrors(ctxt, errNr);
9959 xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
9960 xmlRelaxNGAddStates(ctxt, ctxt->states, ctxt->state);
9961 ctxt->state = NULL;
9963 ctxt->flags = oldflags;
9965 if (ctxt->errNr > errNr)
9966 xmlRelaxNGPopErrors(ctxt, errNr);
9970 errNr = ctxt->errNr;
9971 ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
9975 if (ctxt->errNr > errNr)
9976 xmlRelaxNGPopErrors(ctxt, errNr);
9983 errNr = ctxt->errNr;
9984 res = xmlRelaxNGNewStates(ctxt, 1);
9992 if (ctxt->state != NULL) {
9993 xmlRelaxNGAddStates(ctxt, res,
9994 xmlRelaxNGCopyValidState(ctxt,
9995 ctxt->
9998 for (j = 0; j < ctxt->states->nbState; j++) {
9999 xmlRelaxNGAddStates(ctxt, res,
10000 xmlRelaxNGCopyValidState(ctxt,
10001 ctxt->
10007 oldflags = ctxt->flags;
10008 ctxt->flags |= FLAGS_IGNORABLE;
10013 if (ctxt->states != NULL) {
10014 states = ctxt->states;
10016 ctxt->state = states->tabState[i];
10017 ctxt->states = NULL;
10018 ret = xmlRelaxNGValidateDefinitionList(ctxt,
10022 if (ctxt->state != NULL) {
10023 tmp = xmlRelaxNGAddStates(ctxt, res,
10024 ctxt->state);
10025 ctxt->state = NULL;
10028 } else if (ctxt->states != NULL) {
10029 for (j = 0; j < ctxt->states->nbState;
10032 xmlRelaxNGAddStates(ctxt, res,
10033 ctxt->
10040 xmlRelaxNGFreeStates(ctxt,
10041 ctxt->states);
10042 ctxt->states = NULL;
10045 if (ctxt->state != NULL) {
10046 xmlRelaxNGFreeValidState(ctxt,
10047 ctxt->state);
10048 ctxt->state = NULL;
10053 ret = xmlRelaxNGValidateDefinitionList(ctxt,
10057 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10058 ctxt->state = NULL;
10061 if (ctxt->state != NULL) {
10062 tmp = xmlRelaxNGAddStates(ctxt, res,
10063 ctxt->state);
10064 ctxt->state = NULL;
10067 } else if (ctxt->states != NULL) {
10068 for (j = 0; j < ctxt->states->nbState; j++) {
10069 tmp = xmlRelaxNGAddStates(ctxt, res,
10070 ctxt->
10077 states = ctxt->states;
10079 xmlRelaxNGFreeStates(ctxt,
10080 ctxt->states);
10082 ctxt->states = NULL;
10092 ctxt->state = xmlRelaxNGCopyValidState(ctxt,
10098 xmlRelaxNGNewStates(ctxt,
10100 states = ctxt->states;
10108 xmlRelaxNGAddStates(ctxt, states,
10110 (ctxt,
10112 ctxt->states = states;
10117 xmlRelaxNGFreeStates(ctxt, states);
10119 ctxt->states = res;
10120 ctxt->flags = oldflags;
10125 if (ctxt->errNr > errNr)
10126 xmlRelaxNGPopErrors(ctxt, errNr);
10135 node = xmlRelaxNGSkipIgnored(ctxt, node);
10137 errNr = ctxt->errNr;
10177 ret = xmlRelaxNGValidateDefinition(ctxt, list);
10184 oldflags = ctxt->flags;
10185 ctxt->flags |= FLAGS_IGNORABLE;
10188 oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
10189 ret = xmlRelaxNGValidateDefinition(ctxt, list);
10192 states = xmlRelaxNGNewStates(ctxt, 1);
10194 if (ctxt->state != NULL) {
10195 xmlRelaxNGAddStates(ctxt, states, ctxt->state);
10196 } else if (ctxt->states != NULL) {
10197 for (i = 0; i < ctxt->states->nbState; i++) {
10198 xmlRelaxNGAddStates(ctxt, states,
10199 ctxt->states->
10202 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10203 ctxt->states = NULL;
10206 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10208 ctxt->state = oldstate;
10212 xmlRelaxNGFreeValidState(ctxt, oldstate);
10213 ctxt->states = states;
10214 ctxt->state = NULL;
10217 ctxt->states = NULL;
10219 ctxt->flags = oldflags;
10221 if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
10222 xmlRelaxNGDumpValidError(ctxt);
10225 if (ctxt->errNr > errNr)
10226 xmlRelaxNGPopErrors(ctxt, errNr);
10232 ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
10235 ret = xmlRelaxNGValidateInterleave(ctxt, define);
10238 ret = xmlRelaxNGValidateAttribute(ctxt, define);
10245 ret = xmlRelaxNGValidateDefinition(ctxt, define->content);
10273 xmlRngVErrMemory(ctxt, "validating\n");
10278 ret = xmlRelaxNGValidateDatatype(ctxt, content, define,
10279 ctxt->state->seq);
10283 ctxt->state->seq = NULL;
10316 xmlRngVErrMemory(ctxt, "validating\n");
10321 oldvalue = ctxt->state->value;
10322 ctxt->state->value = content;
10323 ret = xmlRelaxNGValidateValue(ctxt, define);
10324 ctxt->state->value = oldvalue;
10328 ctxt->state->seq = NULL;
10367 xmlRngVErrMemory(ctxt, "validating\n");
10373 oldvalue = ctxt->state->value;
10374 oldendvalue = ctxt->state->endvalue;
10375 ctxt->state->value = content;
10376 ctxt->state->endvalue = content + len;
10377 ret = xmlRelaxNGValidateValue(ctxt, define);
10378 ctxt->state->value = oldvalue;
10379 ctxt->state->endvalue = oldendvalue;
10383 ctxt->state->seq = node->next;
10394 ctxt->depth--;
10396 for (i = 0; i < ctxt->depth; i++)
10412 * @ctxt: a Relax-NG validation context
10420 xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
10427 * We should NOT have both ctxt->state and ctxt->states
10429 if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10430 TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10431 ctxt->state = NULL;
10434 if ((ctxt->states == NULL) || (ctxt->states->nbState == 1)) {
10435 if (ctxt->states != NULL) {
10436 ctxt->state = ctxt->states->tabState[0];
10437 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10438 ctxt->states = NULL;
10440 ret = xmlRelaxNGValidateState(ctxt, define);
10441 if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10442 TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10443 ctxt->state = NULL;
10445 if ((ctxt->states != NULL) && (ctxt->states->nbState == 1)) {
10446 ctxt->state = ctxt->states->tabState[0];
10447 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10448 ctxt->states = NULL;
10453 states = ctxt->states;
10454 ctxt->states = NULL;
10457 oldflags = ctxt->flags;
10458 ctxt->flags |= FLAGS_IGNORABLE;
10460 ctxt->state = states->tabState[i];
10461 ctxt->states = NULL;
10462 ret = xmlRelaxNGValidateState(ctxt, define);
10464 * We should NOT have both ctxt->state and ctxt->states
10466 if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10467 TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10468 ctxt->state = NULL;
10471 if (ctxt->states == NULL) {
10474 xmlRelaxNGAddStates(ctxt, res, ctxt->state);
10475 ctxt->state = NULL;
10478 states->tabState[j++] = ctxt->state;
10479 ctxt->state = NULL;
10484 res = ctxt->states;
10485 ctxt->states = NULL;
10487 xmlRelaxNGAddStates(ctxt, res,
10491 for (k = 0; k < ctxt->states->nbState; k++)
10492 xmlRelaxNGAddStates(ctxt, res,
10493 ctxt->states->tabState[k]);
10494 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10495 ctxt->states = NULL;
10499 if (ctxt->state != NULL) {
10500 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10501 ctxt->state = NULL;
10502 } else if (ctxt->states != NULL) {
10503 for (k = 0; k < ctxt->states->nbState; k++)
10504 xmlRelaxNGFreeValidState(ctxt,
10505 ctxt->states->tabState[k]);
10506 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10507 ctxt->states = NULL;
10511 ctxt->flags = oldflags;
10513 xmlRelaxNGFreeStates(ctxt, states);
10514 ctxt->states = res;
10518 ctxt->states = states;
10521 ctxt->state = states->tabState[0];
10522 xmlRelaxNGFreeStates(ctxt, states);
10526 xmlRelaxNGFreeStates(ctxt, states);
10527 if (ctxt->states != NULL) {
10528 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10529 ctxt->states = NULL;
10532 if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10533 TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10534 ctxt->state = NULL;
10541 * @ctxt: a Relax-NG validation context
10549 xmlRelaxNGValidateDocument(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
10557 if ((ctxt == NULL) || (ctxt->schema == NULL) || (doc == NULL))
10560 ctxt->errNo = XML_RELAXNG_OK;
10561 schema = ctxt->schema;
10567 state = xmlRelaxNGNewValidState(ctxt, NULL);
10568 ctxt->state = state;
10569 ret = xmlRelaxNGValidateDefinition(ctxt, grammar->start);
10570 if ((ctxt->state != NULL) && (state->seq != NULL)) {
10571 state = ctxt->state;
10573 node = xmlRelaxNGSkipIgnored(ctxt, node);
10580 } else if (ctxt->states != NULL) {
10584 for (i = 0; i < ctxt->states->nbState; i++) {
10585 state = ctxt->states->tabState[i];
10587 node = xmlRelaxNGSkipIgnored(ctxt, node);
10590 xmlRelaxNGFreeValidState(ctxt, state);
10599 if (ctxt->state != NULL) {
10600 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10601 ctxt->state = NULL;
10604 xmlRelaxNGDumpValidError(ctxt);
10606 else if (ctxt->errNr != 0) {
10607 ctxt->error(ctxt->userData,
10609 ctxt->errNr);
10610 xmlRelaxNGDumpValidError(ctxt);
10614 if (ctxt->idref == 1) {
10619 vctxt.error = ctxt->error;
10620 vctxt.warning = ctxt->warning;
10621 vctxt.userData = ctxt->userData;
10627 if ((ret == 0) && (ctxt->errNo != XML_RELAXNG_OK))
10676 * @ctxt: the schema validation context
10681 xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxtPtr ctxt)
10685 if (ctxt == NULL)
10687 if (ctxt->states != NULL)
10688 xmlRelaxNGFreeStates(NULL, ctxt->states);
10689 if (ctxt->freeState != NULL) {
10690 for (k = 0; k < ctxt->freeState->nbState; k++) {
10691 xmlRelaxNGFreeValidState(NULL, ctxt->freeState->tabState[k]);
10693 xmlRelaxNGFreeStates(NULL, ctxt->freeState);
10695 if (ctxt->freeStates != NULL) {
10696 for (k = 0; k < ctxt->freeStatesNr; k++) {
10697 xmlRelaxNGFreeStates(NULL, ctxt->freeStates[k]);
10699 xmlFree(ctxt->freeStates);
10701 if (ctxt->errTab != NULL)
10702 xmlFree(ctxt->errTab);
10703 if (ctxt->elemTab != NULL) {
10706 exec = xmlRelaxNGElemPop(ctxt);
10709 exec = xmlRelaxNGElemPop(ctxt);
10711 xmlFree(ctxt->elemTab);
10713 xmlFree(ctxt);
10718 * @ctxt: a Relax-NG validation context
10726 xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
10730 if (ctxt == NULL)
10732 ctxt->error = err;
10733 ctxt->warning = warn;
10734 ctxt->userData = ctx;
10735 ctxt->serror = NULL;
10740 * @ctxt: a Relax-NG validation context
10747 xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt,
10750 if (ctxt == NULL)
10752 ctxt->serror = serror;
10753 ctxt->error = NULL;
10754 ctxt->warning = NULL;
10755 ctxt->userData = ctx;
10760 * @ctxt: a Relax-NG validation context
10770 xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
10774 if (ctxt == NULL)
10777 *err = ctxt->error;
10779 *warn = ctxt->warning;
10781 *ctx = ctxt->userData;
10787 * @ctxt: a Relax-NG validation context
10796 xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
10800 if ((ctxt == NULL) || (doc == NULL))
10803 ctxt->doc = doc;
10805 ret = xmlRelaxNGValidateDocument(ctxt, doc);