Lines Matching refs:ctxt
85 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info);
113 xmlParserEntityCheck(xmlParserCtxtPtr ctxt, size_t size,
118 if (ctxt == NULL)
120 if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
131 if (ctxt->input != NULL) {
132 consumed = ctxt->input->consumed +
133 (ctxt->input->cur - ctxt->input->base);
135 consumed += ctxt->sizeentities;
149 if (ctxt->input != NULL) {
150 consumed = ctxt->input->consumed +
151 (ctxt->input->cur - ctxt->input->base);
153 consumed += ctxt->sizeentities;
156 (ctxt->nbentities * 3 < XML_PARSER_NON_LINEAR * consumed))
167 if (ctxt->input != NULL) {
168 consumed = ctxt->input->consumed +
169 (ctxt->input->cur - ctxt->input->base);
171 consumed += ctxt->sizeentities;
185 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
215 /* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
216 xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
243 * @ctxt: an XML parser context
250 xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
253 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
254 (ctxt->instate == XML_PARSER_EOF))
256 if (ctxt != NULL)
257 ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
259 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
260 ctxt->errNo, XML_ERR_FATAL, NULL, 0,
264 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
265 ctxt->errNo, XML_ERR_FATAL, NULL, 0,
269 if (ctxt != NULL) {
270 ctxt->wellFormed = 0;
271 if (ctxt->recovery == 0)
272 ctxt->disableSAX = 1;
278 * @ctxt: an XML parser context
285 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)
289 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
290 (ctxt->instate == XML_PARSER_EOF))
471 if (ctxt != NULL)
472 ctxt->errNo = error;
473 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
476 if (ctxt != NULL) {
477 ctxt->wellFormed = 0;
478 if (ctxt->recovery == 0)
479 ctxt->disableSAX = 1;
485 * @ctxt: an XML parser context
492 xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
495 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
496 (ctxt->instate == XML_PARSER_EOF))
498 if (ctxt != NULL)
499 ctxt->errNo = error;
500 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
502 if (ctxt != NULL) {
503 ctxt->wellFormed = 0;
504 if (ctxt->recovery == 0)
505 ctxt->disableSAX = 1;
511 * @ctxt: an XML parser context
520 xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
525 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
526 (ctxt->instate == XML_PARSER_EOF))
528 if ((ctxt != NULL) && (ctxt->sax != NULL) &&
529 (ctxt->sax->initialized == XML_SAX2_MAGIC))
530 schannel = ctxt->sax->serror;
532 (ctxt->sax) ? ctxt->sax->warning : NULL,
533 ctxt->userData,
534 ctxt, NULL, XML_FROM_PARSER, error,
542 * @ctxt: an XML parser context
550 xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
555 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
556 (ctxt->instate == XML_PARSER_EOF))
558 if (ctxt != NULL) {
559 ctxt->errNo = error;
560 if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
561 schannel = ctxt->sax->serror;
564 ctxt->vctxt.error, ctxt->vctxt.userData,
565 ctxt, NULL, XML_FROM_DTD, error,
569 if (ctxt != NULL) {
570 ctxt->valid = 0;
576 * @ctxt: an XML parser context
584 xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
587 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
588 (ctxt->instate == XML_PARSER_EOF))
590 if (ctxt != NULL)
591 ctxt->errNo = error;
593 ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
595 if (ctxt != NULL) {
596 ctxt->wellFormed = 0;
597 if (ctxt->recovery == 0)
598 ctxt->disableSAX = 1;
604 * @ctxt: an XML parser context
614 xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
618 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
619 (ctxt->instate == XML_PARSER_EOF))
621 if (ctxt != NULL)
622 ctxt->errNo = error;
624 ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
627 if (ctxt != NULL) {
628 ctxt->wellFormed = 0;
629 if (ctxt->recovery == 0)
630 ctxt->disableSAX = 1;
636 * @ctxt: an XML parser context
644 xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
647 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
648 (ctxt->instate == XML_PARSER_EOF))
650 if (ctxt != NULL)
651 ctxt->errNo = error;
652 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
656 if (ctxt != NULL) {
657 ctxt->wellFormed = 0;
658 if (ctxt->recovery == 0)
659 ctxt->disableSAX = 1;
665 * @ctxt: an XML parser context
673 xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
676 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
677 (ctxt->instate == XML_PARSER_EOF))
679 if (ctxt != NULL)
680 ctxt->errNo = error;
681 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
689 * @ctxt: an XML parser context
698 xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
703 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
704 (ctxt->instate == XML_PARSER_EOF))
706 if (ctxt != NULL)
707 ctxt->errNo = error;
708 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
712 if (ctxt != NULL)
713 ctxt->nsWellFormed = 0;
936 * @ctxt: an XML parser context
941 xmlDetectSAX2(xmlParserCtxtPtr ctxt) {
942 if (ctxt == NULL) return;
944 if ((ctxt->sax) && (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
945 ((ctxt->sax->startElementNs != NULL) ||
946 (ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1;
948 ctxt->sax2 = 1;
951 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
952 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
953 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
954 if ((ctxt->str_xml==NULL) || (ctxt->str_xmlns==NULL) ||
955 (ctxt->str_xml_ns == NULL)) {
956 xmlErrMemory(ctxt, NULL);
970 * @ctxt: an XML parser context
978 xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
987 if (ctxt->attsDefault == NULL) {
988 ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
989 if (ctxt->attsDefault == NULL)
999 name = xmlDictLookup(ctxt->dict, fullname, -1);
1002 name = xmlDictLookup(ctxt->dict, name, -1);
1003 prefix = xmlDictLookup(ctxt->dict, fullname, len);
1009 defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
1017 xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, defaults, NULL);
1027 xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, defaults, NULL);
1036 name = xmlDictLookup(ctxt->dict, fullattr, -1);
1039 name = xmlDictLookup(ctxt->dict, name, -1);
1040 prefix = xmlDictLookup(ctxt->dict, fullattr, len);
1047 value = xmlDictLookup(ctxt->dict, value, len);
1055 xmlErrMemory(ctxt, NULL);
1061 * @ctxt: an XML parser context
1069 xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
1074 if (ctxt->attsSpecial == NULL) {
1075 ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
1076 if (ctxt->attsSpecial == NULL)
1080 if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1083 xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
1088 xmlErrMemory(ctxt, NULL);
1101 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data;
1104 xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL);
1110 * @ctxt: an XML parser context
1117 xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt)
1119 if (ctxt->attsSpecial == NULL)
1122 xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt);
1124 if (xmlHashSize(ctxt->attsSpecial) == 0) {
1125 xmlHashFree(ctxt->attsSpecial, NULL);
1126 ctxt->attsSpecial = NULL;
1209 xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
1215 * @ctxt: an XML parser context
1225 nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL)
1227 if (ctxt->options & XML_PARSE_NSCLEAN) {
1229 for (i = 0;i < ctxt->nsNr;i += 2) {
1230 if (ctxt->nsTab[i] == prefix) {
1232 if (ctxt->nsTab[i + 1] == URL)
1239 if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) {
1240 ctxt->nsMax = 10;
1241 ctxt->nsNr = 0;
1242 ctxt->nsTab = (const xmlChar **)
1243 xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
1244 if (ctxt->nsTab == NULL) {
1245 xmlErrMemory(ctxt, NULL);
1246 ctxt->nsMax = 0;
1249 } else if (ctxt->nsNr >= ctxt->nsMax) {
1250 ctxt->nsMax *= 2;
1251 ctxt->nsTab = (const xmlChar **)
1252 xmlRealloc((char *) ctxt->nsTab,
1253 ctxt->nsMax * sizeof(ctxt->nsTab[0]));
1254 if (ctxt->nsTab == NULL) {
1255 xmlErrMemory(ctxt, NULL);
1256 ctxt->nsMax /= 2;
1260 ctxt->nsTab[ctxt->nsNr++] = prefix;
1261 ctxt->nsTab[ctxt->nsNr++] = URL;
1262 return (ctxt->nsNr);
1266 * @ctxt: an XML parser context
1274 nsPop(xmlParserCtxtPtr ctxt, int nr)
1278 if (ctxt->nsTab == NULL) return(0);
1279 if (ctxt->nsNr < nr) {
1281 nr = ctxt->nsNr;
1283 if (ctxt->nsNr <= 0)
1287 ctxt->nsNr--;
1288 ctxt->nsTab[ctxt->nsNr] = NULL;
1295 xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
1300 if (ctxt->atts == NULL) {
1305 ctxt->atts = atts;
1308 ctxt->attallocs = attallocs;
1309 ctxt->maxatts = maxatts;
1310 } else if (nr + 5 > ctxt->maxatts) {
1312 atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts,
1315 ctxt->atts = atts;
1316 attallocs = (int *) xmlRealloc((void *) ctxt->attallocs,
1319 ctxt->attallocs = attallocs;
1320 ctxt->maxatts = maxatts;
1322 return(ctxt->maxatts);
1324 xmlErrMemory(ctxt, NULL);
1330 * @ctxt: an XML parser context
1338 inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
1340 if ((ctxt == NULL) || (value == NULL))
1342 if (ctxt->inputNr >= ctxt->inputMax) {
1343 ctxt->inputMax *= 2;
1344 ctxt->inputTab =
1345 (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
1346 ctxt->inputMax *
1347 sizeof(ctxt->inputTab[0]));
1348 if (ctxt->inputTab == NULL) {
1349 xmlErrMemory(ctxt, NULL);
1353 ctxt->inputTab[ctxt->inputNr] = value;
1354 ctxt->input = value;
1355 return (ctxt->inputNr++);
1359 * @ctxt: an XML parser context
1366 inputPop(xmlParserCtxtPtr ctxt)
1370 if (ctxt == NULL)
1372 if (ctxt->inputNr <= 0)
1374 ctxt->inputNr--;
1375 if (ctxt->inputNr > 0)
1376 ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
1378 ctxt->input = NULL;
1379 ret = ctxt->inputTab[ctxt->inputNr];
1380 ctxt->inputTab[ctxt->inputNr] = NULL;
1385 * @ctxt: an XML parser context
1393 nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
1395 if (ctxt == NULL) return(0);
1396 if (ctxt->nodeNr >= ctxt->nodeMax) {
1399 tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
1400 ctxt->nodeMax * 2 *
1401 sizeof(ctxt->nodeTab[0]));
1403 xmlErrMemory(ctxt, NULL);
1406 ctxt->nodeTab = tmp;
1407 ctxt->nodeMax *= 2;
1409 if (((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) {
1410 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
1413 ctxt->instate = XML_PARSER_EOF;
1416 ctxt->nodeTab[ctxt->nodeNr] = value;
1417 ctxt->node = value;
1418 return (ctxt->nodeNr++);
1422 * @ctxt: an XML parser context
1429 nodePop(xmlParserCtxtPtr ctxt)
1433 if (ctxt == NULL) return(NULL);
1434 if (ctxt->nodeNr <= 0)
1436 ctxt->nodeNr--;
1437 if (ctxt->nodeNr > 0)
1438 ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
1440 ctxt->node = NULL;
1441 ret = ctxt->nodeTab[ctxt->nodeNr];
1442 ctxt->nodeTab[ctxt->nodeNr] = NULL;
1449 * @ctxt: an XML parser context
1459 nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
1462 if (ctxt->nameNr >= ctxt->nameMax) {
1465 ctxt->nameMax *= 2;
1466 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1467 ctxt->nameMax *
1468 sizeof(ctxt->nameTab[0]));
1470 ctxt->nameMax /= 2;
1473 ctxt->nameTab = tmp;
1474 tmp2 = (void **) xmlRealloc((void * *)ctxt->pushTab,
1475 ctxt->nameMax * 3 *
1476 sizeof(ctxt->pushTab[0]));
1478 ctxt->nameMax /= 2;
1481 ctxt->pushTab = tmp2;
1483 ctxt->nameTab[ctxt->nameNr] = value;
1484 ctxt->name = value;
1485 ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix;
1486 ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI;
1487 ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr;
1488 return (ctxt->nameNr++);
1490 xmlErrMemory(ctxt, NULL);
1495 * @ctxt: an XML parser context
1502 nameNsPop(xmlParserCtxtPtr ctxt)
1506 if (ctxt->nameNr <= 0)
1508 ctxt->nameNr--;
1509 if (ctxt->nameNr > 0)
1510 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1512 ctxt->name = NULL;
1513 ret = ctxt->nameTab[ctxt->nameNr];
1514 ctxt->nameTab[ctxt->nameNr] = NULL;
1521 * @ctxt: an XML parser context
1529 namePush(xmlParserCtxtPtr ctxt, const xmlChar * value)
1531 if (ctxt == NULL) return (-1);
1533 if (ctxt->nameNr >= ctxt->nameMax) {
1535 ctxt->nameMax *= 2;
1536 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1537 ctxt->nameMax *
1538 sizeof(ctxt->nameTab[0]));
1540 ctxt->nameMax /= 2;
1543 ctxt->nameTab = tmp;
1545 ctxt->nameTab[ctxt->nameNr] = value;
1546 ctxt->name = value;
1547 return (ctxt->nameNr++);
1549 xmlErrMemory(ctxt, NULL);
1554 * @ctxt: an XML parser context
1561 namePop(xmlParserCtxtPtr ctxt)
1565 if ((ctxt == NULL) || (ctxt->nameNr <= 0))
1567 ctxt->nameNr--;
1568 if (ctxt->nameNr > 0)
1569 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1571 ctxt->name = NULL;
1572 ret = ctxt->nameTab[ctxt->nameNr];
1573 ctxt->nameTab[ctxt->nameNr] = NULL;
1577 static int spacePush(xmlParserCtxtPtr ctxt, int val) {
1578 if (ctxt->spaceNr >= ctxt->spaceMax) {
1579 ctxt->spaceMax *= 2;
1580 ctxt->spaceTab = (int *) xmlRealloc(ctxt->spaceTab,
1581 ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
1582 if (ctxt->spaceTab == NULL) {
1583 xmlErrMemory(ctxt, NULL);
1587 ctxt->spaceTab[ctxt->spaceNr] = val;
1588 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
1589 return(ctxt->spaceNr++);
1592 static int spacePop(xmlParserCtxtPtr ctxt) {
1594 if (ctxt->spaceNr <= 0) return(0);
1595 ctxt->spaceNr--;
1596 if (ctxt->spaceNr > 0)
1597 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
1599 ctxt->space = &ctxt->spaceTab[0];
1600 ret = ctxt->spaceTab[ctxt->spaceNr];
1601 ctxt->spaceTab[ctxt->spaceNr] = -1;
1640 #define RAW (*ctxt->input->cur)
1641 #define CUR (*ctxt->input->cur)
1642 #define NXT(val) ctxt->input->cur[(val)]
1643 #define CUR_PTR ctxt->input->cur
1664 ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val); \
1665 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1666 if ((*ctxt->input->cur == 0) && \
1667 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
1668 xmlPopInput(ctxt); \
1674 if (*(ctxt->input->cur) == '\n') { \
1675 ctxt->input->line++; ctxt->input->col = 1; \
1676 } else ctxt->input->col++; \
1677 ctxt->nbChars++; \
1678 ctxt->input->cur++; \
1680 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1681 if ((*ctxt->input->cur == 0) && \
1682 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
1683 xmlPopInput(ctxt); \
1686 #define SHRINK if ((ctxt->progressive == 0) && \
1687 (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
1688 (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
1689 xmlSHRINK (ctxt);
1691 static void xmlSHRINK (xmlParserCtxtPtr ctxt) {
1692 xmlParserInputShrink(ctxt->input);
1693 if ((*ctxt->input->cur == 0) &&
1694 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1695 xmlPopInput(ctxt);
1698 #define GROW if ((ctxt->progressive == 0) && \
1699 (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \
1700 xmlGROW (ctxt);
1702 static void xmlGROW (xmlParserCtxtPtr ctxt) {
1703 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
1704 if ((*ctxt->input->cur == 0) &&
1705 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1706 xmlPopInput(ctxt);
1709 #define SKIP_BLANKS xmlSkipBlankChars(ctxt)
1711 #define NEXT xmlNextChar(ctxt)
1714 ctxt->input->col++; \
1715 ctxt->input->cur++; \
1716 ctxt->nbChars++; \
1717 if (*ctxt->input->cur == 0) \
1718 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); \
1722 if (*(ctxt->input->cur) == '\n') { \
1723 ctxt->input->line++; ctxt->input->col = 1; \
1724 } else ctxt->input->col++; \
1725 ctxt->input->cur += l; \
1726 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1729 #define CUR_CHAR(l) xmlCurrentChar(ctxt, &l)
1730 #define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
1738 * @ctxt: the XML parser context
1747 xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
1754 if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) {
1759 cur = ctxt->input->cur;
1762 ctxt->input->line++; ctxt->input->col = 1;
1767 ctxt->input->cur = cur;
1768 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
1769 cur = ctxt->input->cur;
1772 ctxt->input->cur = cur;
1782 while ((cur == 0) && (ctxt->inputNr > 1) &&
1783 (ctxt->instate != XML_PARSER_COMMENT)) {
1784 xmlPopInput(ctxt);
1790 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);
1804 * @ctxt: an XML parser context
1806 * xmlPopInput: the current input pointed by ctxt->input came to an end
1812 xmlPopInput(xmlParserCtxtPtr ctxt) {
1813 if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0);
1816 "Popping input %d\n", ctxt->inputNr);
1817 xmlFreeInputStream(inputPop(ctxt));
1818 if ((*ctxt->input->cur == 0) &&
1819 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1820 return(xmlPopInput(ctxt));
1826 * @ctxt: an XML parser context
1833 xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
1837 if ((ctxt->input != NULL) && (ctxt->input->filename))
1839 "%s(%d): ", ctxt->input->filename,
1840 ctxt->input->line);
1842 "Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
1844 inputPush(ctxt, input);
1850 * @ctxt: an XML parser context
1864 xmlParseCharRef(xmlParserCtxtPtr ctxt) {
1888 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
1900 ctxt->input->col++;
1901 ctxt->nbChars ++;
1902 ctxt->input->cur++;
1915 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
1927 ctxt->input->col++;
1928 ctxt->nbChars ++;
1929 ctxt->input->cur++;
1932 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
1943 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
1952 * @ctxt: an XML parser context
1969 xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
1989 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2008 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2021 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2034 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2043 * @ctxt: an XML parser context
2055 xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
2060 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
2067 input = xmlNewInputStream(ctxt);
2074 xmlErrMemory(ctxt, NULL);
2093 * @ctxt: the parser context
2124 xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
2130 switch(ctxt->instate) {
2140 xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
2145 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
2156 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
2175 if ((ctxt->external == 0) && (ctxt->inputNr == 1))
2185 name = xmlParseName(ctxt);
2190 xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL);
2194 if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL))
2195 entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
2206 if ((ctxt->standalone == 1) ||
2207 ((ctxt->hasExternalSubset == 0) &&
2208 (ctxt->hasPErefs == 0))) {
2209 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
2219 if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
2220 xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
2224 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
2227 ctxt->valid = 0;
2229 } else if (ctxt->input->free != deallocblankswrapper) {
2230 input = xmlNewBlanksWrapperInputStream(ctxt, entity);
2231 xmlPushInput(ctxt, input);
2243 input = xmlNewEntityInputStream(ctxt, entity);
2244 xmlPushInput(ctxt, input);
2256 if ((ctxt->input->end - ctxt->input->cur)>=4) {
2263 xmlSwitchEncoding(ctxt, enc);
2270 xmlParseTextDecl(ctxt);
2273 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
2279 xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
2299 * @ctxt: the parser context
2317 xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2328 if ((ctxt == NULL) || (str == NULL) || (len < 0))
2332 if (ctxt->depth > 40) {
2333 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
2357 int val = xmlParseStringCharRef(ctxt, &str);
2369 ent = xmlParseStringEntityRef(ctxt, &str);
2370 if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
2373 ctxt->nbentities += ent->owner;
2382 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
2388 ctxt->depth++;
2389 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2391 ctxt->depth--;
2397 if (xmlParserEntityCheck(ctxt, nbchars, ent, 0)) {
2422 ent = xmlParseStringPEReference(ctxt, &str);
2423 if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
2426 ctxt->nbentities += ent->owner;
2430 ctxt->depth++;
2431 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2433 ctxt->depth--;
2439 if (xmlParserEntityCheck(ctxt, nbchars, ent, 0)) {
2465 xmlErrMemory(ctxt, NULL);
2474 * @ctxt: the parser context
2491 xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
2493 if ((ctxt == NULL) || (str == NULL)) return(NULL);
2494 return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what,
2506 * @ctxt: an XML parser context
2516 static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2525 if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
2531 if ((ctxt->space == NULL) || (*(ctxt->space) == 1) ||
2532 (*(ctxt->space) == -2))
2546 if (ctxt->node == NULL) return(0);
2547 if (ctxt->myDoc != NULL) {
2548 ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
2557 if ((ctxt->node->children == NULL) &&
2560 lastChild = xmlGetLastChild(ctxt->node);
2562 if ((ctxt->node->type != XML_ELEMENT_NODE) &&
2563 (ctxt->node->content != NULL)) return(0);
2566 else if ((ctxt->node->children != NULL) &&
2567 (xmlNodeIsText(ctxt->node->children)))
2581 * @ctxt: an XML parser context
2598 xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix) {
2637 xmlErrMemory(ctxt, NULL);
2650 xmlErrMemory(ctxt, NULL);
2696 xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
2716 xmlErrMemory(ctxt, NULL);
2728 xmlErrMemory(ctxt, NULL);
2757 static const xmlChar * xmlParseNameComplex(xmlParserCtxtPtr ctxt);
2758 static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
2763 * @ctxt: an XML parser context
2778 xmlParseName(xmlParserCtxtPtr ctxt) {
2788 in = ctxt->input->cur;
2800 count = in - ctxt->input->cur;
2801 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
2802 ctxt->input->cur = in;
2803 ctxt->nbChars += count;
2804 ctxt->input->col += count;
2806 xmlErrMemory(ctxt, NULL);
2810 return(xmlParseNameComplex(ctxt));
2815 * @ctxt: an XML parser context
2825 xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
2832 in = ctxt->input->cur;
2836 ctxt->input->col++;
2840 ctxt->input->cur = in;
2844 ret = xmlParseName (ctxt);
2853 xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
2883 if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
2884 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
2885 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
2890 * @ctxt: an XML parser context
2907 xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
2937 xmlErrMemory(ctxt, NULL);
2953 xmlErrMemory(ctxt, NULL);
2974 * @ctxt: an XML parser context
2986 xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
3017 xmlErrMemory(ctxt, NULL);
3037 xmlErrMemory(ctxt, NULL);
3058 * @ctxt: an XML parser context
3070 xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
3083 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
3088 xmlErrMemory(ctxt, NULL);
3096 ctxt->instate = XML_PARSER_ENTITY_VALUE;
3097 input = ctxt->input;
3111 (ctxt->input != input))) {
3118 xmlErrMemory(ctxt, NULL);
3129 while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */
3130 xmlPopInput(ctxt);
3153 name = xmlParseStringName(ctxt, &cur);
3155 xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
3159 if ((tmp == '%') && (ctxt->inSubset == 1) &&
3160 (ctxt->inputNr == 1)) {
3161 xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
3175 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
3185 ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
3198 * @ctxt: an XML parser context
3209 xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) {
3219 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3224 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3227 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
3248 int val = xmlParseCharRef(ctxt);
3251 if (ctxt->replaceEntities) {
3277 ent = xmlParseEntityRef(ctxt);
3278 ctxt->nbentities++;
3280 ctxt->nbentities += ent->owner;
3286 if ((ctxt->replaceEntities == 0) &&
3297 (ctxt->replaceEntities != 0)) {
3301 rep = xmlStringDecodeEntities(ctxt, ent->content,
3332 rep = xmlStringDecodeEntities(ctxt, ent->content,
3378 xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
3381 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
3384 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
3395 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
3404 xmlErrMemory(ctxt, NULL);
3410 * @ctxt: an XML parser context
3443 xmlParseAttValue(xmlParserCtxtPtr ctxt) {
3444 if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL);
3445 return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
3450 * @ctxt: an XML parser context
3460 xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
3466 int state = ctxt->instate;
3477 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
3483 xmlErrMemory(ctxt, NULL);
3486 ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
3496 xmlErrMemory(ctxt, NULL);
3497 ctxt->instate = (xmlParserInputState) state;
3517 ctxt->instate = (xmlParserInputState) state;
3519 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
3528 * @ctxt: an XML parser context
3538 xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
3545 xmlParserInputState oldstate = ctxt->instate;
3555 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
3560 xmlErrMemory(ctxt, NULL);
3563 ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
3572 xmlErrMemory(ctxt, NULL);
3594 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
3598 ctxt->instate = oldstate;
3602 void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
3644 * @ctxt: an XML parser context
3659 xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
3662 int line = ctxt->input->line;
3663 int col = ctxt->input->col;
3673 in = ctxt->input->cur;
3676 while (*in == 0x20) { in++; ctxt->input->col++; }
3679 ctxt->input->line++; ctxt->input->col = 1;
3685 nbchar = in - ctxt->input->cur;
3687 const xmlChar *tmp = ctxt->input->cur;
3688 ctxt->input->cur = in;
3690 if ((ctxt->sax != NULL) &&
3691 (ctxt->sax->ignorableWhitespace !=
3692 ctxt->sax->characters)) {
3693 if (areBlanks(ctxt, tmp, nbchar, 1)) {
3694 if (ctxt->sax->ignorableWhitespace != NULL)
3695 ctxt->sax->ignorableWhitespace(ctxt->userData,
3698 if (ctxt->sax->characters != NULL)
3699 ctxt->sax->characters(ctxt->userData,
3701 if (*ctxt->space == -1)
3702 *ctxt->space = -2;
3704 } else if ((ctxt->sax != NULL) &&
3705 (ctxt->sax->characters != NULL)) {
3706 ctxt->sax->characters(ctxt->userData,
3714 ccol = ctxt->input->col;
3719 ctxt->input->col = ccol;
3722 ctxt->input->line++; ctxt->input->col = 1;
3729 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
3730 ctxt->input->cur = in;
3734 ctxt->input->col++;
3737 nbchar = in - ctxt->input->cur;
3739 if ((ctxt->sax != NULL) &&
3740 (ctxt->sax->ignorableWhitespace !=
3741 ctxt->sax->characters) &&
3742 (IS_BLANK_CH(*ctxt->input->cur))) {
3743 const xmlChar *tmp = ctxt->input->cur;
3744 ctxt->input->cur = in;
3746 if (areBlanks(ctxt, tmp, nbchar, 0)) {
3747 if (ctxt->sax->ignorableWhitespace != NULL)
3748 ctxt->sax->ignorableWhitespace(ctxt->userData,
3751 if (ctxt->sax->characters != NULL)
3752 ctxt->sax->characters(ctxt->userData,
3754 if (*ctxt->space == -1)
3755 *ctxt->space = -2;
3757 line = ctxt->input->line;
3758 col = ctxt->input->col;
3759 } else if (ctxt->sax != NULL) {
3760 if (ctxt->sax->characters != NULL)
3761 ctxt->sax->characters(ctxt->userData,
3762 ctxt->input->cur, nbchar);
3763 line = ctxt->input->line;
3764 col = ctxt->input->col;
3767 ctxt->input->cur = in;
3771 ctxt->input->cur = in;
3773 ctxt->input->line++; ctxt->input->col = 1;
3786 in = ctxt->input->cur;
3790 ctxt->input->line = line;
3791 ctxt->input->col = col;
3792 xmlParseCharDataComplex(ctxt, cdata);
3797 * @ctxt: an XML parser context
3805 xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
3821 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
3831 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
3832 if (areBlanks(ctxt, buf, nbchar, 0)) {
3833 if (ctxt->sax->ignorableWhitespace != NULL)
3834 ctxt->sax->ignorableWhitespace(ctxt->userData,
3837 if (ctxt->sax->characters != NULL)
3838 ctxt->sax->characters(ctxt->userData, buf, nbchar);
3839 if ((ctxt->sax->characters !=
3840 ctxt->sax->ignorableWhitespace) &&
3841 (*ctxt->space == -1))
3842 *ctxt->space = -2;
3860 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
3861 if (areBlanks(ctxt, buf, nbchar, 0)) {
3862 if (ctxt->sax->ignorableWhitespace != NULL)
3863 ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
3865 if (ctxt->sax->characters != NULL)
3866 ctxt->sax->characters(ctxt->userData, buf, nbchar);
3867 if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) &&
3868 (*ctxt->space == -1))
3869 *ctxt->space = -2;
3875 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
3884 * @ctxt: an XML parser context
3905 xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
3914 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
3918 URI = xmlParseSystemLiteral(ctxt);
3920 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
3925 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
3929 *publicID = xmlParsePubidLiteral(ctxt);
3931 xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
3938 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
3957 URI = xmlParseSystemLiteral(ctxt);
3959 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
3967 * @ctxt: an XML parser context
3980 xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf, int len, int size) {
3984 xmlParserInputPtr input = ctxt->input;
3992 xmlErrMemory(ctxt, NULL);
4001 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4012 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4026 xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
4034 xmlErrMemory(ctxt, NULL);
4060 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4063 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4067 if (input != ctxt->input) {
4068 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4072 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4073 (!ctxt->disableSAX))
4074 ctxt->sax->comment(ctxt->userData, buf);
4079 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4087 * @ctxt: an XML parser context
4096 xmlParseComment(xmlParserCtxtPtr ctxt) {
4110 state = ctxt->instate;
4111 ctxt->instate = XML_PARSER_COMMENT;
4120 in = ctxt->input->cur;
4124 ctxt->input->line++; ctxt->input->col = 1;
4129 ccol = ctxt->input->col;
4136 ctxt->input->col = ccol;
4139 ctxt->input->line++; ctxt->input->col = 1;
4144 nbchar = in - ctxt->input->cur;
4149 if ((ctxt->sax != NULL) &&
4150 (ctxt->sax->comment != NULL)) {
4158 xmlErrMemory(ctxt, NULL);
4159 ctxt->instate = state;
4170 xmlErrMemory(ctxt, NULL);
4171 ctxt->instate = state;
4176 memcpy(&buf[len], ctxt->input->cur, nbchar);
4181 ctxt->input->cur = in;
4184 ctxt->input->line++; ctxt->input->col = 1;
4189 ctxt->input->cur = in;
4191 ctxt->input->line++; ctxt->input->col = 1;
4198 in = ctxt->input->cur;
4203 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4204 (!ctxt->disableSAX)) {
4206 ctxt->sax->comment(ctxt->userData, buf);
4208 ctxt->sax->comment(ctxt->userData, BAD_CAST "");
4212 ctxt->instate = state;
4216 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4220 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4223 ctxt->input->col++;
4226 ctxt->input->col++;
4230 xmlParseCommentComplex(ctxt, buf, len, size);
4231 ctxt->instate = state;
4238 * @ctxt: an XML parser context
4248 xmlParsePITarget(xmlParserCtxtPtr ctxt) {
4251 name = xmlParseName(ctxt);
4259 xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
4263 xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
4271 xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
4281 * @ctxt: an XML parser context
4295 xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
4326 ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
4332 xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
4342 * @ctxt: an XML parser context
4352 xmlParsePI(xmlParserCtxtPtr ctxt) {
4362 xmlParserInputPtr input = ctxt->input;
4363 state = ctxt->instate;
4364 ctxt->instate = XML_PARSER_PI;
4375 target = xmlParsePITarget(ctxt);
4378 if (input != ctxt->input) {
4379 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4387 if ((ctxt->sax) && (!ctxt->disableSAX) &&
4388 (ctxt->sax->processingInstruction != NULL))
4389 ctxt->sax->processingInstruction(ctxt->userData,
4391 if (ctxt->instate != XML_PARSER_EOF)
4392 ctxt->instate = state;
4397 xmlErrMemory(ctxt, NULL);
4398 ctxt->instate = state;
4403 xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
4416 xmlErrMemory(ctxt, NULL);
4418 ctxt->instate = state;
4439 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
4442 if (input != ctxt->input) {
4443 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4455 xmlParseCatalogPI(ctxt, buf);
4463 if ((ctxt->sax) && (!ctxt->disableSAX) &&
4464 (ctxt->sax->processingInstruction != NULL))
4465 ctxt->sax->processingInstruction(ctxt->userData,
4470 xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
4472 if (ctxt->instate != XML_PARSER_EOF)
4473 ctxt->instate = state;
4479 * @ctxt: an XML parser context
4494 xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
4500 xmlParserInputPtr input = ctxt->input;
4504 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4510 name = xmlParseName(ctxt);
4512 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
4516 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4525 Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
4529 if (input != ctxt->input) {
4530 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4534 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
4535 (ctxt->sax->notationDecl != NULL))
4536 ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
4538 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
4547 * @ctxt: an XML parser context
4568 xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
4576 unsigned long oldnbent = ctxt->nbentities;
4580 xmlParserInputPtr input = ctxt->input;
4585 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4593 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4599 name = xmlParseName(ctxt);
4601 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
4607 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4611 ctxt->instate = XML_PARSER_ENTITY_DECL;
4617 value = xmlParseEntityValue(ctxt, &orig);
4619 if ((ctxt->sax != NULL) &&
4620 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
4621 ctxt->sax->entityDecl(ctxt->userData, name,
4626 URI = xmlParseExternalID(ctxt, &literal, 1);
4628 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
4635 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
4648 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
4650 if ((ctxt->sax != NULL) &&
4651 (!ctxt->disableSAX) &&
4652 (ctxt->sax->entityDecl != NULL))
4653 ctxt->sax->entityDecl(ctxt->userData, name,
4663 value = xmlParseEntityValue(ctxt, &orig);
4664 if ((ctxt->sax != NULL) &&
4665 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
4666 ctxt->sax->entityDecl(ctxt->userData, name,
4672 if ((ctxt->myDoc == NULL) ||
4673 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
4674 if (ctxt->myDoc == NULL) {
4675 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
4677 if (ctxt->myDoc->intSubset == NULL)
4678 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
4681 xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
4685 URI = xmlParseExternalID(ctxt, &literal, 1);
4687 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
4694 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
4707 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
4713 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4720 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4724 ndata = xmlParseName(ctxt);
4725 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
4726 (ctxt->sax->unparsedEntityDecl != NULL))
4727 ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
4730 if ((ctxt->sax != NULL) &&
4731 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
4732 ctxt->sax->entityDecl(ctxt->userData, name,
4739 if ((ctxt->replaceEntities != 0) &&
4740 ((ctxt->myDoc == NULL) ||
4741 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
4742 if (ctxt->myDoc == NULL) {
4743 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
4746 if (ctxt->myDoc->intSubset == NULL)
4747 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
4749 xmlSAX2EntityDecl(ctxt, name,
4758 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
4761 if (input != ctxt->input) {
4762 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4774 if ((ctxt->sax != NULL) &&
4775 (ctxt->sax->getParameterEntity != NULL))
4776 cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
4778 if ((ctxt->sax != NULL) &&
4779 (ctxt->sax->getEntity != NULL))
4780 cur = ctxt->sax->getEntity(ctxt->userData, name);
4781 if ((cur == NULL) && (ctxt->userData==ctxt)) {
4782 cur = xmlSAX2GetEntity(ctxt, name);
4787 cur->owner = ctxt->nbentities - oldnbent;
4806 * @ctxt: an XML parser context
4834 xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
4852 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4857 ret = xmlParseAttValue(ctxt);
4858 ctxt->instate = XML_PARSER_DTD;
4860 xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
4869 * @ctxt: an XML parser context
4885 xmlParseNotationType(xmlParserCtxtPtr ctxt) {
4890 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
4897 name = xmlParseName(ctxt);
4899 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
4917 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
4927 * @ctxt: an XML parser context
4941 xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
4946 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
4953 name = xmlParseNmtoken(ctxt);
4955 xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
4972 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
4981 * @ctxt: an XML parser context
4995 xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
4999 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5004 *tree = xmlParseNotationType(ctxt);
5008 *tree = xmlParseEnumerationType(ctxt);
5015 * @ctxt: an XML parser context
5059 xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5086 return(xmlParseEnumeratedType(ctxt, tree));
5091 * @ctxt: an XML parser context
5101 xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
5107 xmlParserInputPtr input = ctxt->input;
5111 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5115 elemName = xmlParseName(ctxt);
5117 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5131 attrName = xmlParseName(ctxt);
5133 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5139 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5145 type = xmlParseAttributeType(ctxt, &tree);
5152 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5160 def = xmlParseDefaultDecl(ctxt, &defaultValue);
5172 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5183 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
5191 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5192 (ctxt->sax->attributeDecl != NULL))
5193 ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
5198 if ((ctxt->sax2) && (defaultValue != NULL) &&
5201 xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
5203 if (ctxt->sax2) {
5204 xmlAddSpecialAttr(ctxt, elemName, attrName, type);
5211 if (input != ctxt->input) {
5212 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5222 * @ctxt: an XML parser context
5240 xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
5250 if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5251 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5256 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5264 ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5270 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5277 n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5279 n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5288 elem = xmlParseName(ctxt);
5290 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5292 xmlFreeDocElementContent(ctxt->myDoc, cur);
5300 cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
5306 if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5307 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5313 xmlFreeDocElementContent(ctxt->myDoc, ret);
5314 xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
5319 xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
5326 * @ctxt: an XML parser context
5356 xmlParseElementChildrenContentDecl (xmlParserCtxtPtr ctxt, int inputchk) {
5361 if (ctxt->depth > 128) {
5362 xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED,
5364 ctxt->depth);
5370 int inputid = ctxt->input->id;
5375 ctxt->depth++;
5376 cur = ret = xmlParseElementChildrenContentDecl(ctxt, inputid);
5377 ctxt->depth--;
5381 elem = xmlParseName(ctxt);
5383 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
5386 cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5388 xmlErrMemory(ctxt, NULL);
5419 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
5423 xmlFreeDocElementContent(ctxt->myDoc, last);
5425 xmlFreeDocElementContent(ctxt->myDoc, ret);
5430 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
5433 xmlFreeDocElementContent(ctxt->myDoc, last);
5434 xmlFreeDocElementContent(ctxt->myDoc, ret);
5459 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
5463 xmlFreeDocElementContent(ctxt->myDoc, last);
5465 xmlFreeDocElementContent(ctxt->myDoc, ret);
5470 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5473 xmlFreeDocElementContent(ctxt->myDoc, last);
5475 xmlFreeDocElementContent(ctxt->myDoc, ret);
5494 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
5496 xmlFreeDocElementContent(ctxt->myDoc, ret);
5503 int inputid = ctxt->input->id;
5507 ctxt->depth++;
5508 last = xmlParseElementChildrenContentDecl(ctxt, inputid);
5509 ctxt->depth--;
5512 elem = xmlParseName(ctxt);
5514 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
5516 xmlFreeDocElementContent(ctxt->myDoc, ret);
5519 last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5541 if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5542 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5616 * @ctxt: an XML parser context
5629 xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
5633 int inputid = ctxt->input->id;
5639 xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
5647 tree = xmlParseElementMixedContentDecl(ctxt, inputid);
5650 tree = xmlParseElementChildrenContentDecl(ctxt, inputid);
5660 * @ctxt: an XML parser context
5672 xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
5679 xmlParserInputPtr input = ctxt->input;
5683 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5687 name = xmlParseName(ctxt);
5689 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5693 while ((RAW == 0) && (ctxt->inputNr > 1))
5694 xmlPopInput(ctxt);
5696 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5714 ret = xmlParseElementContentDecl(ctxt, name, &content);
5719 if ((RAW == '%') && (ctxt->external == 0) &&
5720 (ctxt->inputNr == 1)) {
5721 xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
5724 xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
5734 while ((RAW == 0) && (ctxt->inputNr > 1))
5735 xmlPopInput(ctxt);
5739 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
5741 xmlFreeDocElementContent(ctxt->myDoc, content);
5744 if (input != ctxt->input) {
5745 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5750 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5751 (ctxt->sax->elementDecl != NULL)) {
5754 ctxt->sax->elementDecl(ctxt->userData, name, ret,
5763 xmlFreeDocElementContent(ctxt->myDoc, content);
5766 xmlFreeDocElementContent(ctxt->myDoc, content);
5775 * @ctxt: an XML parser context
5785 xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
5792 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
5797 if ((ctxt->input != NULL) && (ctxt->input->filename))
5799 "%s(%d): ", ctxt->input->filename,
5800 ctxt->input->line);
5808 unsigned int cons = ctxt->input->consumed;
5811 xmlParseConditionalSections(ctxt);
5815 xmlParsePEReference(ctxt);
5817 xmlParseMarkupDecl(ctxt);
5822 while ((RAW == 0) && (ctxt->inputNr > 1))
5823 xmlPopInput(ctxt);
5825 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
5826 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
5831 if ((ctxt->input != NULL) && (ctxt->input->filename))
5833 "%s(%d): ", ctxt->input->filename,
5834 ctxt->input->line);
5847 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
5852 if ((ctxt->input != NULL) && (ctxt->input->filename))
5854 "%s(%d): ", ctxt->input->filename,
5855 ctxt->input->line);
5864 state = ctxt->disableSAX;
5865 instate = ctxt->instate;
5866 if (ctxt->recovery == 0) ctxt->disableSAX = 1;
5867 ctxt->instate = XML_PARSER_IGNORE;
5883 ctxt->disableSAX = state;
5884 ctxt->instate = instate;
5887 if ((ctxt->input != NULL) && (ctxt->input->filename))
5889 "%s(%d): ", ctxt->input->filename,
5890 ctxt->input->line);
5896 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
5903 xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
5911 * @ctxt: an XML parser context
5932 xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
5939 xmlParseElementDecl(ctxt);
5941 xmlParseEntityDecl(ctxt);
5944 xmlParseAttributeListDecl(ctxt);
5947 xmlParseNotationDecl(ctxt);
5950 xmlParseComment(ctxt);
5957 xmlParsePI(ctxt);
5964 if ((ctxt->external == 0) && (ctxt->inputNr == 1))
5965 xmlParsePEReference(ctxt);
5971 if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
5973 xmlParseConditionalSections(ctxt);
5977 ctxt->instate = XML_PARSER_DTD;
5982 * @ctxt: an XML parser context
5992 xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
6002 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
6007 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6015 version = xmlParseVersionInfo(ctxt);
6020 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6024 ctxt->input->version = version;
6029 encoding = xmlParseEncodingDecl(ctxt);
6030 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
6036 if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
6037 xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
6046 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
6049 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
6057 * @ctxt: an XML parser context
6068 xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
6070 xmlDetectSAX2(ctxt);
6073 xmlParseTextDecl(ctxt);
6074 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
6078 ctxt->instate = XML_PARSER_EOF;
6082 if (ctxt->myDoc == NULL) {
6083 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
6085 if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
6086 xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
6088 ctxt->instate = XML_PARSER_DTD;
6089 ctxt->external = 1;
6094 unsigned int cons = ctxt->input->consumed;
6098 xmlParseConditionalSections(ctxt);
6102 xmlParsePEReference(ctxt);
6104 xmlParseMarkupDecl(ctxt);
6109 while ((RAW == 0) && (ctxt->inputNr > 1))
6110 xmlPopInput(ctxt);
6112 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
6113 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6119 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6126 * @ctxt: an XML parser context
6136 xmlParseReference(xmlParserCtxtPtr ctxt) {
6145 int value = xmlParseCharRef(ctxt);
6147 if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
6156 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6157 (!ctxt->disableSAX))
6158 ctxt->sax->characters(ctxt->userData, out, 1);
6164 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
6165 (!ctxt->disableSAX))
6166 ctxt->sax->reference(ctxt->userData, out);
6174 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6175 (!ctxt->disableSAX))
6176 ctxt->sax->characters(ctxt->userData, out, i);
6181 ent = xmlParseEntityRef(ctxt);
6183 if (!ctxt->wellFormed)
6230 list = xmlNewDocText(ctxt->myDoc, value);
6246 unsigned long oldnbent = ctxt->nbentities;
6259 if (ctxt->userData == ctxt)
6262 user_data = ctxt->userData;
6265 ctxt->depth++;
6266 ret = xmlParseBalancedChunkMemoryInternal(ctxt,
6268 ctxt->depth--;
6272 ctxt->depth++;
6273 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
6274 ctxt->sax, user_data, ctxt->depth,
6276 ctxt->depth--;
6279 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
6287 ent->owner = ctxt->nbentities - oldnbent;
6292 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6296 if (xmlParserEntityCheck(ctxt, 0, ent, 0)) {
6301 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6308 if (ctxt->replaceEntities) {
6315 (ctxt->parseMode == XML_PARSE_READER)) {
6323 list->parent = (xmlNodePtr) ctxt->node;
6324 list->doc = ctxt->myDoc;
6351 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6357 ctxt->nbentities += ent->owner;
6377 if (ctxt->userData == ctxt)
6380 user_data = ctxt->userData;
6383 ctxt->depth++;
6384 ret = xmlParseBalancedChunkMemoryInternal(ctxt,
6386 ctxt->depth--;
6389 ctxt->depth++;
6390 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
6391 ctxt->sax, user_data, ctxt->depth,
6393 ctxt->depth--;
6396 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
6400 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6404 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
6405 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
6410 ctxt->sax->reference(ctxt->userData, ent->name);
6414 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
6415 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
6419 ctxt->sax->reference(ctxt->userData, ent->name);
6422 if ((ctxt->replaceEntities) || (ent->children == NULL)) {
6436 if ((ctxt->node != NULL) && (ent->children != NULL)) {
6445 (ctxt->parseMode == XML_PARSE_READER)) {
6451 ctxt->sizeentcopy += ent->length;
6452 if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
6458 if (ctxt->parseMode == XML_PARSE_READER)
6464 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
6471 nw = xmlAddChild(ctxt->node, nw);
6478 if ((ctxt->parseMode == XML_PARSE_READER) &&
6499 ctxt->sizeentcopy += ent->length;
6500 if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
6517 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
6525 xmlAddChild(ctxt->node, cur);
6545 nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
6552 xmlAddChildList(ctxt->node, ent->children);
6559 ctxt->nodemem = 0;
6560 ctxt->nodelen = 0;
6570 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6571 (!ctxt->disableSAX))
6572 ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
6579 * @ctxt: an XML parser context
6606 xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
6614 name = xmlParseName(ctxt);
6616 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6624 ctxt->nbentities++;
6630 if (ctxt->sax != NULL) {
6631 if (ctxt->sax->getEntity != NULL)
6632 ent = ctxt->sax->getEntity(ctxt->userData, name);
6633 if ((ctxt->wellFormed == 1 ) && (ent == NULL))
6635 if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
6636 (ctxt->userData==ctxt)) {
6637 ent = xmlSAX2GetEntity(ctxt, name);
6662 if ((ctxt->standalone == 1) ||
6663 ((ctxt->hasExternalSubset == 0) &&
6664 (ctxt->hasPErefs == 0))) {
6665 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6668 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
6670 if ((ctxt->inSubset == 0) &&
6671 (ctxt->sax != NULL) &&
6672 (ctxt->sax->reference != NULL)) {
6673 ctxt->sax->reference(ctxt->userData, name);
6676 ctxt->valid = 0;
6685 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
6694 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6696 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
6705 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6710 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
6721 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
6738 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6747 * @ctxt: an XML parser context
6777 xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
6790 name = xmlParseStringName(ctxt, &ptr);
6792 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6800 ctxt->nbentities++;
6805 if (ctxt->sax != NULL) {
6806 if (ctxt->sax->getEntity != NULL)
6807 ent = ctxt->sax->getEntity(ctxt->userData, name);
6810 if ((ent == NULL) && (ctxt->userData==ctxt)) {
6811 ent = xmlSAX2GetEntity(ctxt, name);
6836 if ((ctxt->standalone == 1) ||
6837 ((ctxt->hasExternalSubset == 0) &&
6838 (ctxt->hasPErefs == 0))) {
6839 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6842 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
6846 /* TODO ? check regressions ctxt->valid = 0; */
6855 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
6864 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6866 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
6875 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6880 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
6892 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
6909 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6920 * @ctxt: an XML parser context
6948 xmlParsePEReference(xmlParserCtxtPtr ctxt)
6956 name = xmlParseName(ctxt);
6958 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6966 ctxt->nbentities++;
6968 if ((ctxt->sax != NULL) &&
6969 (ctxt->sax->getParameterEntity != NULL))
6970 entity = ctxt->sax->getParameterEntity(ctxt->userData,
6981 if ((ctxt->standalone == 1) ||
6982 ((ctxt->hasExternalSubset == 0) &&
6983 (ctxt->hasPErefs == 0))) {
6984 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6995 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
6998 ctxt->valid = 0;
7006 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7009 } else if (ctxt->input->free != deallocblankswrapper) {
7011 xmlNewBlanksWrapperInputStream(ctxt, entity);
7012 xmlPushInput(ctxt, input);
7019 input = xmlNewEntityInputStream(ctxt, entity);
7020 xmlPushInput(ctxt, input);
7024 xmlParseTextDecl(ctxt);
7025 if (ctxt->errNo ==
7031 ctxt->instate = XML_PARSER_EOF;
7037 ctxt->hasPErefs = 1;
7039 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7047 * @ctxt: an XML parser context
7077 xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
7089 name = xmlParseStringName(ctxt, &ptr);
7091 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7101 ctxt->nbentities++;
7103 if ((ctxt->sax != NULL) &&
7104 (ctxt->sax->getParameterEntity != NULL))
7105 entity = ctxt->sax->getParameterEntity(ctxt->userData,
7116 if ((ctxt->standalone == 1) ||
7117 ((ctxt->hasExternalSubset == 0) &&
7118 (ctxt->hasPErefs == 0))) {
7119 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7129 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7132 ctxt->valid = 0;
7140 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7145 ctxt->hasPErefs = 1;
7147 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7158 * @ctxt: an XML parser context
7171 xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
7186 name = xmlParseName(ctxt);
7188 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7191 ctxt->intSubName = name;
7198 URI = xmlParseExternalID(ctxt, &ExternalID, 1);
7201 ctxt->hasExternalSubset = 1;
7203 ctxt->extSubURI = URI;
7204 ctxt->extSubSystem = ExternalID;
7211 if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
7212 (!ctxt->disableSAX))
7213 ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
7226 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
7233 * @ctxt: an XML parser context
7241 xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
7246 ctxt->instate = XML_PARSER_DTD;
7255 unsigned int cons = ctxt->input->consumed;
7258 xmlParseMarkupDecl(ctxt);
7259 xmlParsePEReference(ctxt);
7264 while ((RAW == 0) && (ctxt->inputNr > 1))
7265 xmlPopInput(ctxt);
7267 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
7268 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7283 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
7291 * @ctxt: an XML parser context
7323 xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
7329 name = xmlParseName(ctxt);
7331 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7343 val = xmlParseAttValue(ctxt);
7344 ctxt->instate = XML_PARSER_CONTENT;
7346 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
7356 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
7358 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
7369 *(ctxt->space) = 0;
7371 *(ctxt->space) = 1;
7373 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
7385 * @ctxt: an XML parser context
7412 xmlParseStartTag(xmlParserCtxtPtr ctxt) {
7416 const xmlChar **atts = ctxt->atts;
7418 int maxatts = ctxt->maxatts;
7424 name = xmlParseName(ctxt);
7426 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7443 unsigned int cons = ctxt->input->consumed;
7445 attname = xmlParseAttribute(ctxt, &attvalue);
7454 xmlErrAttributeDup(ctxt, NULL, attname);
7467 xmlErrMemory(ctxt, NULL);
7472 ctxt->atts = atts;
7473 ctxt->maxatts = maxatts;
7481 xmlErrMemory(ctxt, NULL);
7487 ctxt->atts = atts;
7488 ctxt->maxatts = maxatts;
7505 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
7509 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
7511 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
7522 if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
7523 (!ctxt->disableSAX)) {
7525 ctxt->sax->startElement(ctxt->userData, name, atts);
7527 ctxt->sax->startElement(ctxt->userData, name, NULL);
7541 * @ctxt: an XML parser context
7555 xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
7560 xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
7566 name = xmlParseNameAndCompare(ctxt,ctxt->name);
7574 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
7586 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
7588 ctxt->name, line, name);
7594 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
7595 (!ctxt->disableSAX))
7596 ctxt->sax->endElement(ctxt->userData, ctxt->name);
7598 namePop(ctxt);
7599 spacePop(ctxt);
7605 * @ctxt: an XML parser context
7617 xmlParseEndTag(xmlParserCtxtPtr ctxt) {
7618 xmlParseEndTag1(ctxt, 0);
7629 xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
7657 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
7662 * @ctxt: an XML parser context
7666 * The prefix must come from the @ctxt->dict dictionnary
7671 xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
7674 if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
7675 for (i = ctxt->nsNr - 2;i >= 0;i-=2)
7676 if (ctxt->nsTab[i] == prefix) {
7677 if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
7679 return(ctxt->nsTab[i + 1]);
7686 * @ctxt: an XML parser context
7700 xmlParseNCName(xmlParserCtxtPtr ctxt) {
7708 in = ctxt->input->cur;
7720 count = in - ctxt->input->cur;
7721 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
7722 ctxt->input->cur = in;
7723 ctxt->nbChars += count;
7724 ctxt->input->col += count;
7726 xmlErrMemory(ctxt, NULL);
7731 return(xmlParseNCNameComplex(ctxt));
7736 * @ctxt: an XML parser context
7749 xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
7754 l = xmlParseNCName(ctxt);
7757 l = xmlParseName(ctxt);
7759 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
7770 l = xmlParseNCName(ctxt);
7774 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
7777 p = xmlDictLookup(ctxt->dict, tmp, -1);
7785 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
7788 tmp = (xmlChar *) xmlParseName(ctxt);
7791 l = xmlDictLookup(ctxt->dict, tmp, -1);
7797 l = xmlDictLookup(ctxt->dict, tmp, -1);
7810 * @ctxt: an XML parser context
7822 xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
7829 if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
7832 in = ctxt->input->cur;
7848 ctxt->input->cur = in;
7855 ret = xmlParseQName (ctxt, &prefix2);
7863 * @ctxt: an XML parser context
7896 xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len, int *alloc,
7906 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
7909 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
7917 end = ctxt->input->end;
7920 const xmlChar *oldbase = ctxt->input->base;
7922 if (oldbase != ctxt->input->base) {
7923 long delta = ctxt->input->base - oldbase;
7927 end = ctxt->input->end;
7939 const xmlChar *oldbase = ctxt->input->base;
7941 if (oldbase != ctxt->input->base) {
7942 long delta = ctxt->input->base - oldbase;
7946 end = ctxt->input->end;
7953 const xmlChar *oldbase = ctxt->input->base;
7955 if (oldbase != ctxt->input->base) {
7956 long delta = ctxt->input->base - oldbase;
7960 end = ctxt->input->end;
7973 const xmlChar *oldbase = ctxt->input->base;
7975 if (oldbase != ctxt->input->base) {
7976 long delta = ctxt->input->base - oldbase;
7981 end = ctxt->input->end;
7990 const xmlChar *oldbase = ctxt->input->base;
7992 if (oldbase != ctxt->input->base) {
7993 long delta = ctxt->input->base - oldbase;
7997 end = ctxt->input->end;
8016 return xmlParseAttValueComplex(ctxt, len, normalize);
8021 * @ctxt: an XML parser context
8035 xmlParseAttribute2(xmlParserCtxtPtr ctxt,
8045 name = xmlParseQName(ctxt, prefix);
8047 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8055 if (ctxt->attsSpecial != NULL) {
8058 type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial,
8070 val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
8071 ctxt->instate = XML_PARSER_CONTENT;
8073 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8078 if (*prefix == ctxt->str_xml) {
8084 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
8087 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8099 *(ctxt->space) = 0;
8101 *(ctxt->space) = 1;
8103 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8119 * @ctxt: an XML parser context
8147 xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
8155 const xmlChar **atts = ctxt->atts;
8156 int maxatts = ctxt->maxatts;
8161 int nsNr = ctxt->nsNr;
8175 base = ctxt->input->base;
8176 cur = ctxt->input->cur - ctxt->input->base;
8177 oldline = ctxt->input->line;
8178 oldcol = ctxt->input->col;
8185 ctxt->nsNr = nsNr;
8187 localname = xmlParseQName(ctxt, &prefix);
8189 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8193 *tlen = ctxt->input->cur - ctxt->input->base - cur;
8202 if (ctxt->input->base != base) goto base_changed;
8208 unsigned int cons = ctxt->input->consumed;
8211 attname = xmlParseAttribute2(ctxt, prefix, localname,
8213 if (ctxt->input->base != base) {
8221 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
8222 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
8228 xmlWarningMsg(ctxt, XML_WAR_NS_URI,
8233 xmlWarningMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
8244 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
8247 xmlErrAttributeDup(ctxt, NULL, attname);
8249 if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
8254 if (aprefix == ctxt->str_xmlns) {
8255 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
8258 if (attname == ctxt->str_xml) {
8259 if (URL != ctxt->str_xml_ns) {
8260 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8273 xmlWarningMsg(ctxt, XML_WAR_NS_URI,
8277 if ((ctxt->pedantic) && (uri->scheme == NULL)) {
8278 xmlWarningMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
8289 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
8292 xmlErrAttributeDup(ctxt, aprefix, attname);
8294 if (nsPush(ctxt, attname, URL) > 0) nbNs++;
8297 if (ctxt->input->base != base) goto base_changed;
8305 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
8310 maxatts = ctxt->maxatts;
8311 atts = ctxt->atts;
8313 ctxt->attallocs[nratts++] = alloc;
8332 if (ctxt->input->base != base) goto base_changed;
8336 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8341 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
8343 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8348 if (ctxt->input->base != base) goto base_changed;
8354 if (ctxt->attsDefault != NULL) {
8357 defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
8366 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
8371 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
8375 nsname = xmlGetNamespace(ctxt, NULL);
8377 if (nsPush(ctxt, NULL,
8381 } else if (aprefix == ctxt->str_xmlns) {
8386 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
8390 nsname = xmlGetNamespace(ctxt, attname);
8392 if (nsPush(ctxt, attname,
8407 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
8410 maxatts = ctxt->maxatts;
8411 atts = ctxt->atts;
8418 atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
8435 nsname = xmlGetNamespace(ctxt, atts[i + 1]);
8437 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
8453 xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
8457 xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
8466 nsname = xmlGetNamespace(ctxt, prefix);
8468 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
8478 if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
8479 (!ctxt->disableSAX)) {
8481 ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
8482 nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
8485 ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
8494 if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
8506 if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
8509 ctxt->input->cur = ctxt->input->base + cur;
8510 ctxt->input->line = oldline;
8511 ctxt->input->col = oldcol;
8512 if (ctxt->wellFormed == 1) {
8520 * @ctxt: an XML parser context
8534 xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
8540 xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
8545 if ((tlen > 0) && (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
8546 if (ctxt->input->cur[tlen] == '>') {
8547 ctxt->input->cur += tlen + 1;
8550 ctxt->input->cur += tlen;
8554 name = xmlParseNameAndCompare(ctxt, ctxt->name);
8556 name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
8565 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
8577 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
8579 ctxt->name, line, name);
8586 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
8587 (!ctxt->disableSAX))
8588 ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
8590 spacePop(ctxt);
8592 nsPop(ctxt, nsNr);
8598 * @ctxt: an XML parser context
8611 xmlParseCDSect(xmlParserCtxtPtr ctxt) {
8626 ctxt->instate = XML_PARSER_CDATA_SECTION;
8629 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
8630 ctxt->instate = XML_PARSER_CONTENT;
8636 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
8637 ctxt->instate = XML_PARSER_CONTENT;
8644 xmlErrMemory(ctxt, NULL);
8656 xmlErrMemory(ctxt, NULL);
8675 ctxt->instate = XML_PARSER_CONTENT;
8677 xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
8687 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
8688 if (ctxt->sax->cdataBlock != NULL)
8689 ctxt->sax->cdataBlock(ctxt->userData, buf, len);
8690 else if (ctxt->sax->characters != NULL)
8691 ctxt->sax->characters(ctxt->userData, buf, len);
8698 * @ctxt: an XML parser context
8706 xmlParseContent(xmlParserCtxtPtr ctxt) {
8710 (ctxt->instate != XML_PARSER_EOF)) {
8712 unsigned int cons = ctxt->input->consumed;
8713 const xmlChar *cur = ctxt->input->cur;
8719 xmlParsePI(ctxt);
8727 xmlParseCDSect(ctxt);
8735 xmlParseComment(ctxt);
8736 ctxt->instate = XML_PARSER_CONTENT;
8743 xmlParseElement(ctxt);
8752 xmlParseReference(ctxt);
8759 xmlParseCharData(ctxt, 0);
8766 while ((RAW == 0) && (ctxt->inputNr > 1))
8767 xmlPopInput(ctxt);
8770 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
8771 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8773 ctxt->instate = XML_PARSER_EOF;
8781 * @ctxt: an XML parser context
8794 xmlParseElement(xmlParserCtxtPtr ctxt) {
8801 int nsNr = ctxt->nsNr;
8803 if ((unsigned int) ctxt->nameNr > xmlParserMaxDepth) {
8804 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
8807 ctxt->instate = XML_PARSER_EOF;
8812 if (ctxt->record_info) {
8813 node_info.begin_pos = ctxt->input->consumed +
8814 (CUR_PTR - ctxt->input->base);
8815 node_info.begin_line = ctxt->input->line;
8818 if (ctxt->spaceNr == 0)
8819 spacePush(ctxt, -1);
8820 else if (*ctxt->space == -2)
8821 spacePush(ctxt, -1);
8823 spacePush(ctxt, *ctxt->space);
8825 line = ctxt->input->line;
8827 if (ctxt->sax2)
8829 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
8832 name = xmlParseStartTag(ctxt);
8834 if (ctxt->instate == XML_PARSER_EOF)
8837 spacePop(ctxt);
8840 namePush(ctxt, name);
8841 ret = ctxt->node;
8849 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
8850 ctxt->node && (ctxt->node == ctxt->myDoc->children))
8851 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
8859 if (ctxt->sax2) {
8860 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
8861 (!ctxt->disableSAX))
8862 ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
8865 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
8866 (!ctxt->disableSAX))
8867 ctxt->sax->endElement(ctxt->userData, name);
8870 namePop(ctxt);
8871 spacePop(ctxt);
8872 if (nsNr != ctxt->nsNr)
8873 nsPop(ctxt, ctxt->nsNr - nsNr);
8874 if ( ret != NULL && ctxt->record_info ) {
8875 node_info.end_pos = ctxt->input->consumed +
8876 (CUR_PTR - ctxt->input->base);
8877 node_info.end_line = ctxt->input->line;
8879 xmlParserAddNodeInfo(ctxt, &node_info);
8886 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
8893 nodePop(ctxt);
8894 namePop(ctxt);
8895 spacePop(ctxt);
8896 if (nsNr != ctxt->nsNr)
8897 nsPop(ctxt, ctxt->nsNr - nsNr);
8902 if ( ret != NULL && ctxt->record_info ) {
8903 node_info.end_pos = ctxt->input->consumed +
8904 (CUR_PTR - ctxt->input->base);
8905 node_info.end_line = ctxt->input->line;
8907 xmlParserAddNodeInfo(ctxt, &node_info);
8915 xmlParseContent(ctxt);
8917 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
8924 nodePop(ctxt);
8925 namePop(ctxt);
8926 spacePop(ctxt);
8927 if (nsNr != ctxt->nsNr)
8928 nsPop(ctxt, ctxt->nsNr - nsNr);
8935 if (ctxt->sax2) {
8936 xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
8937 namePop(ctxt);
8941 xmlParseEndTag1(ctxt, line);
8947 if ( ret != NULL && ctxt->record_info ) {
8948 node_info.end_pos = ctxt->input->consumed +
8949 (CUR_PTR - ctxt->input->base);
8950 node_info.end_line = ctxt->input->line;
8952 xmlParserAddNodeInfo(ctxt, &node_info);
8958 * @ctxt: an XML parser context
8967 xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
8975 xmlErrMemory(ctxt, NULL);
8990 xmlErrMemory(ctxt, NULL);
9005 * @ctxt: an XML parser context
9017 xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
9024 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
9031 version = xmlParseVersionNum(ctxt);
9033 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9038 version = xmlParseVersionNum(ctxt);
9040 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9044 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
9052 * @ctxt: an XML parser context
9061 xmlParseEncName(xmlParserCtxtPtr ctxt) {
9072 xmlErrMemory(ctxt, NULL);
9090 xmlErrMemory(ctxt, NULL);
9107 xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
9114 * @ctxt: an XML parser context
9126 xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
9134 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
9141 encoding = xmlParseEncName(ctxt);
9143 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9148 encoding = xmlParseEncName(ctxt);
9150 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9154 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
9163 if (ctxt->encoding != NULL)
9164 xmlFree((xmlChar *) ctxt->encoding);
9165 ctxt->encoding = encoding;
9173 if (ctxt->encoding != NULL)
9174 xmlFree((xmlChar *) ctxt->encoding);
9175 ctxt->encoding = encoding;
9180 if (ctxt->input->encoding != NULL)
9181 xmlFree((xmlChar *) ctxt->input->encoding);
9182 ctxt->input->encoding = encoding;
9186 xmlSwitchToEncoding(ctxt, handler);
9188 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
9199 * @ctxt: an XML parser context
9229 xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
9237 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
9252 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
9255 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9268 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
9271 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9275 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
9283 * @ctxt: an XML parser context
9291 xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
9299 ctxt->input->standalone = -2;
9307 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9315 version = xmlParseVersionInfo(ctxt);
9317 xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
9323 xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
9327 if (ctxt->version != NULL)
9328 xmlFree((void *) ctxt->version);
9329 ctxt->version = version;
9340 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
9342 xmlParseEncodingDecl(ctxt);
9343 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9353 if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
9358 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
9361 ctxt->input->standalone = xmlParseSDDecl(ctxt);
9368 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
9371 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
9379 * @ctxt: an XML parser context
9387 xmlParseMisc(xmlParserCtxtPtr ctxt) {
9392 xmlParsePI(ctxt);
9396 xmlParseComment(ctxt);
9402 * @ctxt: an XML parser context
9416 xmlParseDocument(xmlParserCtxtPtr ctxt) {
9422 if ((ctxt == NULL) || (ctxt->input == NULL))
9430 xmlDetectSAX2(ctxt);
9435 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9436 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
9438 if ((ctxt->encoding == (const xmlChar *)XML_CHAR_ENCODING_NONE) &&
9439 ((ctxt->input->end - ctxt->input->cur) >= 4)) {
9451 xmlSwitchEncoding(ctxt, enc);
9457 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9469 xmlParseXMLDecl(ctxt);
9470 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9476 ctxt->standalone = ctxt->input->standalone;
9479 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9481 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
9482 ctxt->sax->startDocument(ctxt->userData);
9488 xmlParseMisc(ctxt);
9497 ctxt->inSubset = 1;
9498 xmlParseDocTypeDecl(ctxt);
9500 ctxt->instate = XML_PARSER_DTD;
9501 xmlParseInternalSubset(ctxt);
9507 ctxt->inSubset = 2;
9508 if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
9509 (!ctxt->disableSAX))
9510 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
9511 ctxt->extSubSystem, ctxt->extSubURI);
9512 ctxt->inSubset = 0;
9514 xmlCleanSpecialAttr(ctxt);
9516 ctxt->instate = XML_PARSER_PROLOG;
9517 xmlParseMisc(ctxt);
9525 xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
9528 ctxt->instate = XML_PARSER_CONTENT;
9529 xmlParseElement(ctxt);
9530 ctxt->instate = XML_PARSER_EPILOG;
9536 xmlParseMisc(ctxt);
9539 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
9541 ctxt->instate = XML_PARSER_EOF;
9547 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9548 ctxt->sax->endDocument(ctxt->userData);
9553 if ((ctxt->myDoc != NULL) &&
9554 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
9555 xmlFreeDoc(ctxt->myDoc);
9556 ctxt->myDoc = NULL;
9559 if (! ctxt->wellFormed) {
9560 ctxt->valid = 0;
9568 * @ctxt: an XML parser context
9581 xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
9585 if ((ctxt == NULL) || (ctxt->input == NULL))
9590 xmlDetectSAX2(ctxt);
9597 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9598 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
9605 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
9612 xmlSwitchEncoding(ctxt, enc);
9618 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9630 xmlParseXMLDecl(ctxt);
9631 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9639 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9641 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
9642 ctxt->sax->startDocument(ctxt->userData);
9647 ctxt->instate = XML_PARSER_CONTENT;
9648 ctxt->validate = 0;
9649 ctxt->loadsubset = 0;
9650 ctxt->depth = 0;
9652 xmlParseContent(ctxt);
9655 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
9657 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
9663 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9664 ctxt->sax->endDocument(ctxt->userData);
9666 if (! ctxt->wellFormed) return(-1);
9679 * @ctxt: an XML parser context
9686 * This function has a side effect of (possibly) incrementing ctxt->checkIndex
9694 xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
9700 in = ctxt->input;
9704 if (ctxt->checkIndex > base)
9705 base = ctxt->checkIndex;
9724 ctxt->checkIndex = 0;
9742 ctxt->checkIndex = base;
9759 * @ctxt: an XML parser context
9766 xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
9770 if ((ctxt == NULL) || (lastlt == NULL) || (lastgt == NULL)) {
9775 if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) {
9776 tmp = ctxt->input->end;
9778 while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
9779 if (tmp < ctxt->input->base) {
9785 while ((tmp < ctxt->input->end) && (*tmp != '>')) {
9788 while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++;
9789 if (tmp < ctxt->input->end) tmp++;
9792 while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++;
9793 if (tmp < ctxt->input->end) tmp++;
9797 if (tmp < ctxt->input->end)
9802 while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
9803 if (tmp >= ctxt->input->base)
9883 * @ctxt: an XML parser context
9891 xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
9897 if (ctxt->input == NULL)
9901 switch (ctxt->instate) {
9953 if ((ctxt->input != NULL) &&
9954 (ctxt->input->cur - ctxt->input->base > 4096)) {
9955 xmlSHRINK(ctxt);
9956 ctxt->checkIndex = 0;
9958 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
9961 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
9968 while ((RAW == 0) && (ctxt->inputNr > 1))
9969 xmlPopInput(ctxt);
9971 if (ctxt->input == NULL) break;
9972 if (ctxt->input->buf == NULL)
9973 avail = ctxt->input->length -
9974 (ctxt->input->cur - ctxt->input->base);
9981 if ((ctxt->input->buf->raw != NULL) &&
9982 (ctxt->input->buf->raw->use > 0)) {
9983 int base = ctxt->input->base -
9984 ctxt->input->buf->buffer->content;
9985 int current = ctxt->input->cur - ctxt->input->base;
9987 xmlParserInputBufferPush(ctxt->input->buf, 0, "");
9988 ctxt->input->base = ctxt->input->buf->buffer->content + base;
9989 ctxt->input->cur = ctxt->input->base + current;
9990 ctxt->input->end =
9991 &ctxt->input->buf->buffer->content[
9992 ctxt->input->buf->buffer->use];
9994 avail = ctxt->input->buf->buffer->use -
9995 (ctxt->input->cur - ctxt->input->base);
9999 switch (ctxt->instate) {
10006 if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
10028 xmlSwitchEncoding(ctxt, enc);
10034 cur = ctxt->input->cur[0];
10035 next = ctxt->input->cur[1];
10037 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10038 ctxt->sax->setDocumentLocator(ctxt->userData,
10040 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10041 ctxt->instate = XML_PARSER_EOF;
10046 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10047 ctxt->sax->endDocument(ctxt->userData);
10054 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10056 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10057 ctxt->sax->setDocumentLocator(ctxt->userData,
10059 if ((ctxt->input->cur[2] == 'x') &&
10060 (ctxt->input->cur[3] == 'm') &&
10061 (ctxt->input->cur[4] == 'l') &&
10062 (IS_BLANK_CH(ctxt->input->cur[5]))) {
10068 xmlParseXMLDecl(ctxt);
10069 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10074 ctxt->instate = XML_PARSER_EOF;
10077 ctxt->standalone = ctxt->input->standalone;
10078 if ((ctxt->encoding == NULL) &&
10079 (ctxt->input->encoding != NULL))
10080 ctxt->encoding = xmlStrdup(ctxt->input->encoding);
10081 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
10082 (!ctxt->disableSAX))
10083 ctxt->sax->startDocument(ctxt->userData);
10084 ctxt->instate = XML_PARSER_MISC;
10090 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10091 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
10092 (!ctxt->disableSAX))
10093 ctxt->sax->startDocument(ctxt->userData);
10094 ctxt->instate = XML_PARSER_MISC;
10101 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10102 ctxt->sax->setDocumentLocator(ctxt->userData,
10104 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10105 if (ctxt->version == NULL) {
10106 xmlErrMemory(ctxt, NULL);
10109 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
10110 (!ctxt->disableSAX))
10111 ctxt->sax->startDocument(ctxt->userData);
10112 ctxt->instate = XML_PARSER_MISC;
10123 int nsNr = ctxt->nsNr;
10125 if ((avail < 2) && (ctxt->inputNr == 1))
10127 cur = ctxt->input->cur[0];
10129 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10130 ctxt->instate = XML_PARSER_EOF;
10131 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10132 ctxt->sax->endDocument(ctxt->userData);
10136 if (ctxt->progressive) {
10138 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
10140 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
10144 if (ctxt->spaceNr == 0)
10145 spacePush(ctxt, -1);
10146 else if (*ctxt->space == -2)
10147 spacePush(ctxt, -1);
10149 spacePush(ctxt, *ctxt->space);
10151 if (ctxt->sax2)
10153 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
10156 name = xmlParseStartTag(ctxt);
10158 if (ctxt->instate == XML_PARSER_EOF)
10161 spacePop(ctxt);
10162 ctxt->instate = XML_PARSER_EOF;
10163 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10164 ctxt->sax->endDocument(ctxt->userData);
10173 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
10174 ctxt->node && (ctxt->node == ctxt->myDoc->children))
10175 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
10184 if (ctxt->sax2) {
10185 if ((ctxt->sax != NULL) &&
10186 (ctxt->sax->endElementNs != NULL) &&
10187 (!ctxt->disableSAX))
10188 ctxt->sax->endElementNs(ctxt->userData, name,
10190 if (ctxt->nsNr - nsNr > 0)
10191 nsPop(ctxt, ctxt->nsNr - nsNr);
10194 if ((ctxt->sax != NULL) &&
10195 (ctxt->sax->endElement != NULL) &&
10196 (!ctxt->disableSAX))
10197 ctxt->sax->endElement(ctxt->userData, name);
10200 spacePop(ctxt);
10201 if (ctxt->nameNr == 0) {
10202 ctxt->instate = XML_PARSER_EPILOG;
10204 ctxt->instate = XML_PARSER_CONTENT;
10211 xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
10214 nodePop(ctxt);
10215 spacePop(ctxt);
10217 if (ctxt->sax2)
10218 nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
10221 namePush(ctxt, name);
10224 ctxt->instate = XML_PARSER_CONTENT;
10230 if ((avail < 2) && (ctxt->inputNr == 1))
10232 cur = ctxt->input->cur[0];
10233 next = ctxt->input->cur[1];
10236 cons = ctxt->input->consumed;
10238 ctxt->instate = XML_PARSER_END_TAG;
10242 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10244 xmlParsePI(ctxt);
10246 ctxt->instate = XML_PARSER_START_TAG;
10249 (ctxt->input->cur[2] == '-') &&
10250 (ctxt->input->cur[3] == '-')) {
10255 ctxt->input->cur += 4;
10256 term = xmlParseLookupSequence(ctxt, '-', '-', '>');
10257 ctxt->input->cur -= 4;
10260 xmlParseComment(ctxt);
10261 ctxt->instate = XML_PARSER_CONTENT;
10262 } else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
10263 (ctxt->input->cur[2] == '[') &&
10264 (ctxt->input->cur[3] == 'C') &&
10265 (ctxt->input->cur[4] == 'D') &&
10266 (ctxt->input->cur[5] == 'A') &&
10267 (ctxt->input->cur[6] == 'T') &&
10268 (ctxt->input->cur[7] == 'A') &&
10269 (ctxt->input->cur[8] == '[')) {
10271 ctxt->instate = XML_PARSER_CDATA_SECTION;
10278 (xmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
10280 xmlParseReference(ctxt);
10294 if ((ctxt->inputNr == 1) &&
10297 if (ctxt->progressive) {
10299 (ctxt->input->cur > lastlt))
10301 } else if (xmlParseLookupSequence(ctxt,
10307 ctxt->checkIndex = 0;
10308 xmlParseCharData(ctxt, 0);
10313 while ((RAW == 0) && (ctxt->inputNr > 1))
10314 xmlPopInput(ctxt);
10315 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
10316 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
10318 ctxt->instate = XML_PARSER_EOF;
10327 if (ctxt->progressive) {
10329 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
10331 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
10335 if (ctxt->sax2) {
10336 xmlParseEndTag2(ctxt,
10337 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 3],
10338 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 2], 0,
10339 (int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
10340 nameNsPop(ctxt);
10344 xmlParseEndTag1(ctxt, 0);
10346 if (ctxt->instate == XML_PARSER_EOF) {
10348 } else if (ctxt->nameNr == 0) {
10349 ctxt->instate = XML_PARSER_EPILOG;
10351 ctxt->instate = XML_PARSER_CONTENT;
10361 base = xmlParseLookupSequence(ctxt, ']', ']', '>');
10366 tmp = xmlCheckCdataPush(ctxt->input->cur,
10370 ctxt->input->cur += tmp;
10373 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
10374 if (ctxt->sax->cdataBlock != NULL)
10375 ctxt->sax->cdataBlock(ctxt->userData,
10376 ctxt->input->cur, tmp);
10377 else if (ctxt->sax->characters != NULL)
10378 ctxt->sax->characters(ctxt->userData,
10379 ctxt->input->cur, tmp);
10382 ctxt->checkIndex = 0;
10388 tmp = xmlCheckCdataPush(ctxt->input->cur, base);
10391 ctxt->input->cur += tmp;
10394 if ((ctxt->sax != NULL) && (base > 0) &&
10395 (!ctxt->disableSAX)) {
10396 if (ctxt->sax->cdataBlock != NULL)
10397 ctxt->sax->cdataBlock(ctxt->userData,
10398 ctxt->input->cur, base);
10399 else if (ctxt->sax->characters != NULL)
10400 ctxt->sax->characters(ctxt->userData,
10401 ctxt->input->cur, base);
10404 ctxt->checkIndex = 0;
10405 ctxt->instate = XML_PARSER_CONTENT;
10415 if (ctxt->input->buf == NULL)
10416 avail = ctxt->input->length -
10417 (ctxt->input->cur - ctxt->input->base);
10419 avail = ctxt->input->buf->buffer->use -
10420 (ctxt->input->cur - ctxt->input->base);
10423 cur = ctxt->input->cur[0];
10424 next = ctxt->input->cur[1];
10427 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10433 xmlParsePI(ctxt);
10434 ctxt->checkIndex = 0;
10436 (ctxt->input->cur[2] == '-') &&
10437 (ctxt->input->cur[3] == '-')) {
10439 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
10445 xmlParseComment(ctxt);
10446 ctxt->instate = XML_PARSER_MISC;
10447 ctxt->checkIndex = 0;
10449 (ctxt->input->cur[2] == 'D') &&
10450 (ctxt->input->cur[3] == 'O') &&
10451 (ctxt->input->cur[4] == 'C') &&
10452 (ctxt->input->cur[5] == 'T') &&
10453 (ctxt->input->cur[6] == 'Y') &&
10454 (ctxt->input->cur[7] == 'P') &&
10455 (ctxt->input->cur[8] == 'E')) {
10457 (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0))
10463 ctxt->inSubset = 1;
10464 xmlParseDocTypeDecl(ctxt);
10466 ctxt->instate = XML_PARSER_DTD;
10475 ctxt->inSubset = 2;
10476 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
10477 (ctxt->sax->externalSubset != NULL))
10478 ctxt->sax->externalSubset(ctxt->userData,
10479 ctxt->intSubName, ctxt->extSubSystem,
10480 ctxt->extSubURI);
10481 ctxt->inSubset = 0;
10482 xmlCleanSpecialAttr(ctxt);
10483 ctxt->instate = XML_PARSER_PROLOG;
10493 ctxt->instate = XML_PARSER_START_TAG;
10494 ctxt->progressive = 1;
10495 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
10504 if (ctxt->input->buf == NULL)
10505 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
10507 avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
10510 cur = ctxt->input->cur[0];
10511 next = ctxt->input->cur[1];
10514 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10520 xmlParsePI(ctxt);
10522 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
10524 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
10530 xmlParseComment(ctxt);
10531 ctxt->instate = XML_PARSER_PROLOG;
10536 ctxt->instate = XML_PARSER_START_TAG;
10537 if (ctxt->progressive == 0)
10538 ctxt->progressive = 1;
10539 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
10548 if (ctxt->input->buf == NULL)
10549 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
10551 avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
10554 cur = ctxt->input->cur[0];
10555 next = ctxt->input->cur[1];
10558 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10564 xmlParsePI(ctxt);
10565 ctxt->instate = XML_PARSER_EPILOG;
10567 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
10569 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
10575 xmlParseComment(ctxt);
10576 ctxt->instate = XML_PARSER_EPILOG;
10581 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10582 ctxt->instate = XML_PARSER_EOF;
10587 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10588 ctxt->sax->endDocument(ctxt->userData);
10607 base = ctxt->input->cur - ctxt->input->base;
10609 if (ctxt->checkIndex > base)
10610 base = ctxt->checkIndex;
10611 buf = ctxt->input->buf->buffer->content;
10612 for (;(unsigned int) base < ctxt->input->buf->buffer->use;
10623 ctxt->input->buf->buffer->use) &&
10628 ctxt->input->buf->buffer->use; base++) {
10660 ctxt->input->buf->buffer->use)
10668 (unsigned int) base + i < ctxt->input->buf->buffer->use;
10703 xmlParseInternalSubset(ctxt);
10704 ctxt->inSubset = 2;
10705 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
10706 (ctxt->sax->externalSubset != NULL))
10707 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
10708 ctxt->extSubSystem, ctxt->extSubURI);
10709 ctxt->inSubset = 0;
10710 xmlCleanSpecialAttr(ctxt);
10711 ctxt->instate = XML_PARSER_PROLOG;
10712 ctxt->checkIndex = 0;
10722 ctxt->instate = XML_PARSER_CONTENT;
10731 ctxt->instate = XML_PARSER_DTD;
10740 ctxt->instate = XML_PARSER_CONTENT;
10749 ctxt->instate = XML_PARSER_DTD;
10758 ctxt->instate = XML_PARSER_CONTENT;
10767 ctxt->instate = XML_PARSER_START_TAG;
10776 ctxt->instate = XML_PARSER_START_TAG;
10785 ctxt->instate = XML_PARSER_START_TAG;
10803 ctxt->input->cur[0], ctxt->input->cur[1],
10804 ctxt->input->cur[2], ctxt->input->cur[3]);
10805 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
10814 * @ctxt: an XML parser context
10824 xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
10828 if (ctxt == NULL)
10830 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
10831 return(ctxt->errNo);
10832 if (ctxt->instate == XML_PARSER_START)
10833 xmlDetectSAX2(ctxt);
10839 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
10840 (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF)) {
10841 int base = ctxt->input->base - ctxt->input->buf->buffer->content;
10842 int cur = ctxt->input->cur - ctxt->input->base;
10845 res =xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
10847 ctxt->errNo = XML_PARSER_EOF;
10848 ctxt->disableSAX = 1;
10851 ctxt->input->base = ctxt->input->buf->buffer->content + base;
10852 ctxt->input->cur = ctxt->input->base + cur;
10853 ctxt->input->end =
10854 &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
10859 } else if (ctxt->instate != XML_PARSER_EOF) {
10860 if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
10861 xmlParserInputBufferPtr in = ctxt->input->buf;
10876 xmlParseTryOrFinish(ctxt, terminate);
10877 if ((end_in_lf == 1) && (ctxt->input != NULL) &&
10878 (ctxt->input->buf != NULL)) {
10879 xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
10881 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
10882 return(ctxt->errNo);
10889 if (ctxt->input != NULL) {
10890 if (ctxt->input->buf == NULL)
10891 avail = ctxt->input->length -
10892 (ctxt->input->cur - ctxt->input->base);
10894 avail = ctxt->input->buf->buffer->use -
10895 (ctxt->input->cur - ctxt->input->base);
10898 if ((ctxt->instate != XML_PARSER_EOF) &&
10899 (ctxt->instate != XML_PARSER_EPILOG)) {
10900 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10902 if ((ctxt->instate == XML_PARSER_EPILOG) && (avail > 0)) {
10903 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10905 if (ctxt->instate != XML_PARSER_EOF) {
10906 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10907 ctxt->sax->endDocument(ctxt->userData);
10909 ctxt->instate = XML_PARSER_EOF;
10911 return((xmlParserErrors) ctxt->errNo);
10942 xmlParserCtxtPtr ctxt;
10956 ctxt = xmlNewParserCtxt();
10957 if (ctxt == NULL) {
10962 ctxt->dictNames = 1;
10963 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * sizeof(xmlChar *));
10964 if (ctxt->pushTab == NULL) {
10965 xmlErrMemory(ctxt, NULL);
10967 xmlFreeParserCtxt(ctxt);
10972 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
10974 xmlFree(ctxt->sax);
10975 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
10976 if (ctxt->sax == NULL) {
10977 xmlErrMemory(ctxt, NULL);
10979 xmlFreeParserCtxt(ctxt);
10982 memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
10984 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
10986 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
10988 ctxt->userData = user_data;
10991 ctxt->directory = NULL;
10993 ctxt->directory = xmlParserGetDirectory(filename);
10996 inputStream = xmlNewInputStream(ctxt);
10998 xmlFreeParserCtxt(ctxt);
11009 xmlFreeParserCtxt(ctxt);
11020 inputPush(ctxt, inputStream);
11028 ctxt->charset = XML_CHAR_ENCODING_NONE;
11029 } else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) {
11030 int base = ctxt->input->base - ctxt->input->buf->buffer->content;
11031 int cur = ctxt->input->cur - ctxt->input->base;
11033 xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
11035 ctxt->input->base = ctxt->input->buf->buffer->content + base;
11036 ctxt->input->cur = ctxt->input->base + cur;
11037 ctxt->input->end =
11038 &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
11045 xmlSwitchEncoding(ctxt, enc);
11048 return(ctxt);
11054 * @ctxt: an XML parser context
11059 xmlStopParser(xmlParserCtxtPtr ctxt) {
11060 if (ctxt == NULL)
11062 ctxt->instate = XML_PARSER_EOF;
11063 ctxt->disableSAX = 1;
11064 if (ctxt->input != NULL) {
11065 ctxt->input->cur = BAD_CAST"";
11066 ctxt->input->base = ctxt->input->cur;
11088 xmlParserCtxtPtr ctxt;
11097 ctxt = xmlNewParserCtxt();
11098 if (ctxt == NULL) {
11104 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
11106 xmlFree(ctxt->sax);
11107 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
11108 if (ctxt->sax == NULL) {
11109 xmlErrMemory(ctxt, NULL);
11110 xmlFreeParserCtxt(ctxt);
11113 memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
11115 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
11117 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
11119 ctxt->userData = user_data;
11122 inputStream = xmlNewIOInputStream(ctxt, buf, enc);
11124 xmlFreeParserCtxt(ctxt);
11127 inputPush(ctxt, inputStream);
11129 return(ctxt);
11155 xmlParserCtxtPtr ctxt;
11162 ctxt = xmlNewParserCtxt();
11163 if (ctxt == NULL) {
11172 if (ctxt->sax != NULL)
11173 xmlFree(ctxt->sax);
11174 ctxt->sax = sax;
11175 ctxt->userData = ctxt;
11177 xmlDetectSAX2(ctxt);
11183 pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
11185 if (sax != NULL) ctxt->sax = NULL;
11187 xmlFreeParserCtxt(ctxt);
11194 xmlPushInput(ctxt, pinput);
11196 xmlSwitchEncoding(ctxt, enc);
11202 pinput->base = ctxt->input->cur;
11203 pinput->cur = ctxt->input->cur;
11209 ctxt->inSubset = 2;
11210 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
11211 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
11215 ((ctxt->input->end - ctxt->input->cur) >= 4)) {
11227 xmlSwitchEncoding(ctxt, enc);
11231 xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
11233 if (ctxt->myDoc != NULL) {
11234 if (ctxt->wellFormed) {
11235 ret = ctxt->myDoc->extSubset;
11236 ctxt->myDoc->extSubset = NULL;
11250 xmlFreeDoc(ctxt->myDoc);
11251 ctxt->myDoc = NULL;
11253 if (sax != NULL) ctxt->sax = NULL;
11254 xmlFreeParserCtxt(ctxt);
11274 xmlParserCtxtPtr ctxt;
11281 ctxt = xmlNewParserCtxt();
11282 if (ctxt == NULL) {
11290 if (ctxt->sax != NULL)
11291 xmlFree(ctxt->sax);
11292 ctxt->sax = sax;
11293 ctxt->userData = ctxt;
11301 xmlFreeParserCtxt(ctxt);
11309 if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
11310 input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
11313 if (sax != NULL) ctxt->sax = NULL;
11314 xmlFreeParserCtxt(ctxt);
11323 xmlPushInput(ctxt, input);
11324 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11325 enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
11326 xmlSwitchEncoding(ctxt, enc);
11335 input->base = ctxt->input->cur;
11336 input->cur = ctxt->input->cur;
11342 ctxt->inSubset = 2;
11343 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
11344 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
11346 xmlParseExternalSubset(ctxt, ExternalID, SystemID);
11348 if (ctxt->myDoc != NULL) {
11349 if (ctxt->wellFormed) {
11350 ret = ctxt->myDoc->extSubset;
11351 ctxt->myDoc->extSubset = NULL;
11365 xmlFreeDoc(ctxt->myDoc);
11366 ctxt->myDoc = NULL;
11368 if (sax != NULL) ctxt->sax = NULL;
11369 xmlFreeParserCtxt(ctxt);
11417 xmlParserCtxtPtr ctxt;
11440 ctxt = xmlNewParserCtxt();
11441 if (ctxt == NULL) {
11445 ctxt->userData = ctxt;
11446 ctxt->_private = ctx->_private;
11448 inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
11450 xmlFreeParserCtxt(ctxt);
11454 inputPush(ctxt, inputStream);
11456 if ((ctxt->directory == NULL) && (directory == NULL))
11458 if ((ctxt->directory == NULL) && (directory != NULL))
11459 ctxt->directory = directory;
11461 oldsax = ctxt->sax;
11462 ctxt->sax = ctx->sax;
11463 xmlDetectSAX2(ctxt);
11466 xmlFreeParserCtxt(ctxt);
11482 ctxt->sax = oldsax;
11483 xmlFreeParserCtxt(ctxt);
11490 nodePush(ctxt, newDoc->children);
11492 ctxt->myDoc = newDoc;
11494 ctxt->myDoc = ctx->myDoc;
11504 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11511 xmlSwitchEncoding(ctxt, enc);
11519 xmlParseTextDecl(ctxt);
11525 ctxt->instate = XML_PARSER_CONTENT;
11526 ctxt->validate = ctx->validate;
11527 ctxt->valid = ctx->valid;
11528 ctxt->loadsubset = ctx->loadsubset;
11529 ctxt->depth = ctx->depth + 1;
11530 ctxt->replaceEntities = ctx->replaceEntities;
11531 if (ctxt->validate) {
11532 ctxt->vctxt.error = ctx->vctxt.error;
11533 ctxt->vctxt.warning = ctx->vctxt.warning;
11535 ctxt->vctxt.error = NULL;
11536 ctxt->vctxt.warning = NULL;
11538 ctxt->vctxt.nodeTab = NULL;
11539 ctxt->vctxt.nodeNr = 0;
11540 ctxt->vctxt.nodeMax = 0;
11541 ctxt->vctxt.node = NULL;
11542 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
11543 ctxt->dict = ctx->dict;
11544 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
11545 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
11546 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
11547 ctxt->dictNames = ctx->dictNames;
11548 ctxt->attsDefault = ctx->attsDefault;
11549 ctxt->attsSpecial = ctx->attsSpecial;
11550 ctxt->linenumbers = ctx->linenumbers;
11552 xmlParseContent(ctxt);
11554 ctx->validate = ctxt->validate;
11555 ctx->valid = ctxt->valid;
11557 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11559 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11561 if (ctxt->node != newDoc->children) {
11562 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11565 if (!ctxt->wellFormed) {
11566 if (ctxt->errNo == 0)
11569 ret = ctxt->errNo;
11588 ctxt->sax = oldsax;
11589 ctxt->dict = NULL;
11590 ctxt->attsDefault = NULL;
11591 ctxt->attsSpecial = NULL;
11592 xmlFreeParserCtxt(ctxt);
11622 xmlParserCtxtPtr ctxt;
11644 ctxt = xmlCreateEntityParserCtxt(URL, ID, NULL);
11645 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
11646 ctxt->userData = ctxt;
11648 ctxt->_private = oldctxt->_private;
11649 ctxt->loadsubset = oldctxt->loadsubset;
11650 ctxt->validate = oldctxt->validate;
11651 ctxt->external = oldctxt->external;
11652 ctxt->record_info = oldctxt->record_info;
11653 ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
11654 ctxt->node_seq.length = oldctxt->node_seq.length;
11655 ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
11661 ctxt->_private = NULL;
11662 ctxt->validate = 0;
11663 ctxt->external = 2;
11664 ctxt->loadsubset = 0;
11667 oldsax = ctxt->sax;
11668 ctxt->sax = sax;
11670 ctxt->userData = user_data;
11672 xmlDetectSAX2(ctxt);
11675 ctxt->node_seq.maximum = 0;
11676 ctxt->node_seq.length = 0;
11677 ctxt->node_seq.buffer = NULL;
11678 xmlFreeParserCtxt(ctxt);
11692 ctxt->sax = oldsax;
11693 ctxt->node_seq.maximum = 0;
11694 ctxt->node_seq.length = 0;
11695 ctxt->node_seq.buffer = NULL;
11696 xmlFreeParserCtxt(ctxt);
11703 nodePush(ctxt, newDoc->children);
11704 ctxt->myDoc = doc;
11713 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11720 xmlSwitchEncoding(ctxt, enc);
11728 xmlParseTextDecl(ctxt);
11731 ctxt->instate = XML_PARSER_CONTENT;
11732 ctxt->depth = depth;
11734 xmlParseContent(ctxt);
11737 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11739 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11741 if (ctxt->node != newDoc->children) {
11742 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11745 if (!ctxt->wellFormed) {
11746 if (ctxt->errNo == 0)
11749 ret = (xmlParserErrors)ctxt->errNo;
11773 oldctxt->nbentities += ctxt->nbentities;
11777 if (ctxt->input != NULL) {
11778 oldctxt->sizeentities += ctxt->input->consumed;
11779 oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base);
11784 if (ctxt->lastError.code != XML_ERR_OK)
11785 xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
11788 ctxt->sax = oldsax;
11789 oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
11790 oldctxt->node_seq.length = ctxt->node_seq.length;
11791 oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
11792 oldctxt->nbentities += ctxt->nbentities;
11793 ctxt->node_seq.maximum = 0;
11794 ctxt->node_seq.length = 0;
11795 ctxt->node_seq.buffer = NULL;
11796 xmlFreeParserCtxt(ctxt);
11884 xmlParserCtxtPtr ctxt;
11905 ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
11906 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
11908 ctxt->userData = user_data;
11910 ctxt->userData = ctxt;
11911 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
11912 ctxt->dict = oldctxt->dict;
11913 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
11914 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
11915 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
11917 oldsax = ctxt->sax;
11918 ctxt->sax = oldctxt->sax;
11919 xmlDetectSAX2(ctxt);
11920 ctxt->replaceEntities = oldctxt->replaceEntities;
11921 ctxt->options = oldctxt->options;
11923 ctxt->_private = oldctxt->_private;
11927 ctxt->sax = oldsax;
11928 ctxt->dict = NULL;
11929 xmlFreeParserCtxt(ctxt);
11932 newDoc->dict = ctxt->dict;
11934 ctxt->myDoc = newDoc;
11936 ctxt->myDoc = oldctxt->myDoc;
11937 content = ctxt->myDoc->children;
11938 last = ctxt->myDoc->last;
11940 newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
11942 ctxt->sax = oldsax;
11943 ctxt->dict = NULL;
11944 xmlFreeParserCtxt(ctxt);
11950 ctxt->myDoc->children = NULL;
11951 ctxt->myDoc->last = NULL;
11952 xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
11953 nodePush(ctxt, ctxt->myDoc->children);
11954 ctxt->instate = XML_PARSER_CONTENT;
11955 ctxt->depth = oldctxt->depth + 1;
11957 ctxt->validate = 0;
11958 ctxt->loadsubset = oldctxt->loadsubset;
11963 ctxt->loadsubset |= XML_SKIP_IDS;
11965 ctxt->dictNames = oldctxt->dictNames;
11966 ctxt->attsDefault = oldctxt->attsDefault;
11967 ctxt->attsSpecial = oldctxt->attsSpecial;
11969 xmlParseContent(ctxt);
11971 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11973 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11975 if (ctxt->node != ctxt->myDoc->children) {
11976 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11979 if (!ctxt->wellFormed) {
11980 if (ctxt->errNo == 0)
11983 ret = (xmlParserErrors)ctxt->errNo;
11995 cur = ctxt->myDoc->children->children;
12009 ctxt->myDoc->children->children = NULL;
12011 if (ctxt->myDoc != NULL) {
12012 xmlFreeNode(ctxt->myDoc->children);
12013 ctxt->myDoc->children = content;
12014 ctxt->myDoc->last = last;
12021 oldctxt->nbentities += ctxt->nbentities;
12025 if (ctxt->lastError.code != XML_ERR_OK)
12026 xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
12028 ctxt->sax = oldsax;
12029 ctxt->dict = NULL;
12030 ctxt->attsDefault = NULL;
12031 ctxt->attsSpecial = NULL;
12032 xmlFreeParserCtxt(ctxt);
12063 xmlParserCtxtPtr ctxt;
12108 ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
12111 ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
12116 if (ctxt == NULL)
12120 xmlFreeParserCtxt(ctxt);
12131 if (ctxt->dict != NULL)
12132 xmlDictFree(ctxt->dict);
12133 ctxt->dict = doc->dict;
12137 xmlCtxtUseOptions(ctxt, options);
12138 xmlDetectSAX2(ctxt);
12139 ctxt->myDoc = doc;
12142 nodePush(ctxt, node);
12152 if (ctxt->dict) {
12153 iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
12154 ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
12160 if (xmlGetNamespace(ctxt, iprefix) == NULL) {
12161 nsPush(ctxt, iprefix, ihref);
12168 ctxt->instate = XML_PARSER_CONTENT;
12171 if ((ctxt->validate) || (ctxt->replaceEntities != 0)) {
12175 ctxt->loadsubset |= XML_SKIP_IDS;
12180 __htmlParseContent(ctxt);
12183 xmlParseContent(ctxt);
12185 nsPop(ctxt, nsnr);
12187 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12189 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12191 if ((ctxt->node != NULL) && (ctxt->node != node)) {
12192 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12193 ctxt->wellFormed = 0;
12196 if (!ctxt->wellFormed) {
12197 if (ctxt->errNo == 0)
12200 ret = (xmlParserErrors)ctxt->errNo;
12235 ctxt->dict = NULL;
12236 xmlFreeParserCtxt(ctxt);
12273 xmlParserCtxtPtr ctxt;
12292 ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
12293 if (ctxt == NULL) return(-1);
12294 ctxt->userData = ctxt;
12296 oldsax = ctxt->sax;
12297 ctxt->sax = sax;
12299 ctxt->userData = user_data;
12303 xmlFreeParserCtxt(ctxt);
12307 xmlDictFree(ctxt->dict);
12308 ctxt->dict = doc->dict;
12309 xmlDictReference(ctxt->dict);
12310 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
12311 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
12312 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
12313 ctxt->dictNames = 1;
12315 xmlCtxtUseOptions(ctxt, XML_PARSE_NODICT);
12324 ctxt->sax = oldsax;
12325 xmlFreeParserCtxt(ctxt);
12332 nodePush(ctxt, newRoot);
12334 ctxt->myDoc = newDoc;
12336 ctxt->myDoc = newDoc;
12342 ctxt->instate = XML_PARSER_CONTENT;
12343 ctxt->depth = depth;
12348 ctxt->validate = 0;
12349 ctxt->loadsubset = 0;
12350 xmlDetectSAX2(ctxt);
12355 xmlParseContent(ctxt);
12359 xmlParseContent(ctxt);
12362 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12364 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12366 if (ctxt->node != newDoc->children) {
12367 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12370 if (!ctxt->wellFormed) {
12371 if (ctxt->errNo == 0)
12374 ret = ctxt->errNo;
12397 ctxt->sax = oldsax;
12398 xmlFreeParserCtxt(ctxt);
12426 xmlParserCtxtPtr ctxt;
12428 ctxt = xmlCreateFileParserCtxt(filename);
12429 if (ctxt == NULL) {
12433 if (ctxt->sax != NULL)
12434 xmlFree(ctxt->sax);
12435 ctxt->sax = sax;
12436 ctxt->userData = NULL;
12439 xmlParseExtParsedEnt(ctxt);
12441 if (ctxt->wellFormed)
12442 ret = ctxt->myDoc;
12445 xmlFreeDoc(ctxt->myDoc);
12446 ctxt->myDoc = NULL;
12449 ctxt->sax = NULL;
12450 xmlFreeParserCtxt(ctxt);
12489 xmlParserCtxtPtr ctxt;
12494 ctxt = xmlNewParserCtxt();
12495 if (ctxt == NULL) {
12502 inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
12504 xmlFreeParserCtxt(ctxt);
12508 inputPush(ctxt, inputStream);
12510 if ((ctxt->directory == NULL) && (directory == NULL))
12512 if ((ctxt->directory == NULL) && (directory != NULL))
12513 ctxt->directory = directory;
12515 inputStream = xmlLoadExternalEntity((char *)uri, (char *)ID, ctxt);
12518 xmlFreeParserCtxt(ctxt);
12522 inputPush(ctxt, inputStream);
12524 if ((ctxt->directory == NULL) && (directory == NULL))
12526 if ((ctxt->directory == NULL) && (directory != NULL))
12527 ctxt->directory = directory;
12530 return(ctxt);
12553 xmlParserCtxtPtr ctxt;
12557 ctxt = xmlNewParserCtxt();
12558 if (ctxt == NULL) {
12564 xmlCtxtUseOptions(ctxt, options);
12565 ctxt->linenumbers = 1;
12567 inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
12569 xmlFreeParserCtxt(ctxt);
12573 inputPush(ctxt, inputStream);
12574 if ((ctxt->directory == NULL) && (directory == NULL))
12576 if ((ctxt->directory == NULL) && (directory != NULL))
12577 ctxt->directory = directory;
12579 return(ctxt);
12622 xmlParserCtxtPtr ctxt;
12627 ctxt = xmlCreateFileParserCtxt(filename);
12628 if (ctxt == NULL) {
12632 if (ctxt->sax != NULL)
12633 xmlFree(ctxt->sax);
12634 ctxt->sax = sax;
12636 xmlDetectSAX2(ctxt);
12638 ctxt->_private = data;
12641 if ((ctxt->directory == NULL) && (directory == NULL))
12643 if ((ctxt->directory == NULL) && (directory != NULL))
12644 ctxt->directory = (char *) xmlStrdup((xmlChar *) directory);
12646 ctxt->recovery = recovery;
12648 xmlParseDocument(ctxt);
12650 if ((ctxt->wellFormed) || recovery) {
12651 ret = ctxt->myDoc;
12653 if (ctxt->input->buf->compressed > 0)
12656 ret->compression = ctxt->input->buf->compressed;
12661 xmlFreeDoc(ctxt->myDoc);
12662 ctxt->myDoc = NULL;
12665 ctxt->sax = NULL;
12666 xmlFreeParserCtxt(ctxt);
12742 * @ctxt: an XML parser context
12751 xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
12756 if ((ctxt == NULL) || (buffer == NULL))
12759 input = xmlNewInputStream(ctxt);
12762 xmlClearParserCtxt(ctxt);
12766 xmlClearParserCtxt(ctxt);
12772 inputPush(ctxt, input);
12790 xmlParserCtxtPtr ctxt;
12792 ctxt = xmlCreateFileParserCtxt(filename);
12793 if (ctxt == NULL) return -1;
12794 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12795 xmlFree(ctxt->sax);
12796 ctxt->sax = sax;
12797 xmlDetectSAX2(ctxt);
12800 ctxt->userData = user_data;
12802 xmlParseDocument(ctxt);
12804 if (ctxt->wellFormed)
12807 if (ctxt->errNo != 0)
12808 ret = ctxt->errNo;
12813 ctxt->sax = NULL;
12814 if (ctxt->myDoc != NULL) {
12815 xmlFreeDoc(ctxt->myDoc);
12816 ctxt->myDoc = NULL;
12818 xmlFreeParserCtxt(ctxt);
12841 xmlParserCtxtPtr ctxt;
12850 ctxt = xmlNewParserCtxt();
12851 if (ctxt == NULL)
12857 xmlFreeParserCtxt(ctxt);
12861 input = xmlNewInputStream(ctxt);
12864 xmlFreeParserCtxt(ctxt);
12874 inputPush(ctxt, input);
12875 return(ctxt);
12902 xmlParserCtxtPtr ctxt;
12904 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
12905 if (ctxt == NULL) return(NULL);
12907 if (ctxt->sax != NULL)
12908 xmlFree(ctxt->sax);
12909 ctxt->sax = sax;
12911 xmlDetectSAX2(ctxt);
12913 ctxt->_private=data;
12916 ctxt->recovery = recovery;
12918 xmlParseDocument(ctxt);
12920 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
12923 xmlFreeDoc(ctxt->myDoc);
12924 ctxt->myDoc = NULL;
12927 ctxt->sax = NULL;
12928 xmlFreeParserCtxt(ctxt);
12997 xmlParserCtxtPtr ctxt;
12999 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
13000 if (ctxt == NULL) return -1;
13001 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
13002 xmlFree(ctxt->sax);
13003 ctxt->sax = sax;
13004 xmlDetectSAX2(ctxt);
13007 ctxt->userData = user_data;
13009 xmlParseDocument(ctxt);
13011 if (ctxt->wellFormed)
13014 if (ctxt->errNo != 0)
13015 ret = ctxt->errNo;
13020 ctxt->sax = NULL;
13021 if (ctxt->myDoc != NULL) {
13022 xmlFreeDoc(ctxt->myDoc);
13023 ctxt->myDoc = NULL;
13025 xmlFreeParserCtxt(ctxt);
13067 xmlParserCtxtPtr ctxt;
13073 ctxt = xmlCreateDocParserCtxt(cur);
13074 if (ctxt == NULL) return(NULL);
13076 oldsax = ctxt->sax;
13077 ctxt->sax = sax;
13078 ctxt->userData = NULL;
13080 xmlDetectSAX2(ctxt);
13082 xmlParseDocument(ctxt);
13083 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
13086 xmlFreeDoc(ctxt->myDoc);
13087 ctxt->myDoc = NULL;
13090 ctxt->sax = oldsax;
13091 xmlFreeParserCtxt(ctxt);
13264 * @ctxt: an XML parser context
13269 xmlCtxtReset(xmlParserCtxtPtr ctxt)
13274 if (ctxt == NULL)
13277 dict = ctxt->dict;
13279 while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
13282 ctxt->inputNr = 0;
13283 ctxt->input = NULL;
13285 ctxt->spaceNr = 0;
13286 if (ctxt->spaceTab != NULL) {
13287 ctxt->spaceTab[0] = -1;
13288 ctxt->space = &ctxt->spaceTab[0];
13290 ctxt->space = NULL;
13294 ctxt->nodeNr = 0;
13295 ctxt->node = NULL;
13297 ctxt->nameNr = 0;
13298 ctxt->name = NULL;
13300 DICT_FREE(ctxt->version);
13301 ctxt->version = NULL;
13302 DICT_FREE(ctxt->encoding);
13303 ctxt->encoding = NULL;
13304 DICT_FREE(ctxt->directory);
13305 ctxt->directory = NULL;
13306 DICT_FREE(ctxt->extSubURI);
13307 ctxt->extSubURI = NULL;
13308 DICT_FREE(ctxt->extSubSystem);
13309 ctxt->extSubSystem = NULL;
13310 if (ctxt->myDoc != NULL)
13311 xmlFreeDoc(ctxt->myDoc);
13312 ctxt->myDoc = NULL;
13314 ctxt->standalone = -1;
13315 ctxt->hasExternalSubset = 0;
13316 ctxt->hasPErefs = 0;
13317 ctxt->html = 0;
13318 ctxt->external = 0;
13319 ctxt->instate = XML_PARSER_START;
13320 ctxt->token = 0;
13322 ctxt->wellFormed = 1;
13323 ctxt->nsWellFormed = 1;
13324 ctxt->disableSAX = 0;
13325 ctxt->valid = 1;
13327 ctxt->vctxt.userData = ctxt;
13328 ctxt->vctxt.error = xmlParserValidityError;
13329 ctxt->vctxt.warning = xmlParserValidityWarning;
13331 ctxt->record_info = 0;
13332 ctxt->nbChars = 0;
13333 ctxt->checkIndex = 0;
13334 ctxt->inSubset = 0;
13335 ctxt->errNo = XML_ERR_OK;
13336 ctxt->depth = 0;
13337 ctxt->charset = XML_CHAR_ENCODING_UTF8;
13338 ctxt->catalogs = NULL;
13339 ctxt->nbentities = 0;
13340 ctxt->sizeentities = 0;
13341 ctxt->sizeentcopy = 0;
13342 xmlInitNodeInfoSeq(&ctxt->node_seq);
13344 if (ctxt->attsDefault != NULL) {
13345 xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
13346 ctxt->attsDefault = NULL;
13348 if (ctxt->attsSpecial != NULL) {
13349 xmlHashFree(ctxt->attsSpecial, NULL);
13350 ctxt->attsSpecial = NULL;
13354 if (ctxt->catalogs != NULL)
13355 xmlCatalogFreeLocal(ctxt->catalogs);
13357 if (ctxt->lastError.code != XML_ERR_OK)
13358 xmlResetError(&ctxt->lastError);
13363 * @ctxt: an XML parser context
13374 xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
13381 if (ctxt == NULL)
13391 if (ctxt == NULL) {
13396 xmlCtxtReset(ctxt);
13398 if (ctxt->pushTab == NULL) {
13399 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 *
13401 if (ctxt->pushTab == NULL) {
13402 xmlErrMemory(ctxt, NULL);
13409 ctxt->directory = NULL;
13411 ctxt->directory = xmlParserGetDirectory(filename);
13414 inputStream = xmlNewInputStream(ctxt);
13431 inputPush(ctxt, inputStream);
13433 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
13434 (ctxt->input->buf != NULL)) {
13435 int base = ctxt->input->base - ctxt->input->buf->buffer->content;
13436 int cur = ctxt->input->cur - ctxt->input->base;
13438 xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
13440 ctxt->input->base = ctxt->input->buf->buffer->content + base;
13441 ctxt->input->cur = ctxt->input->base + cur;
13442 ctxt->input->end =
13443 &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->
13455 xmlSwitchToEncoding(ctxt, hdlr);
13457 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
13461 xmlSwitchEncoding(ctxt, enc);
13469 * @ctxt: an XML parser context
13478 xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
13480 if (ctxt == NULL)
13483 ctxt->recovery = 1;
13486 ctxt->recovery = 0;
13488 ctxt->loadsubset = XML_DETECT_IDS;
13491 ctxt->loadsubset = 0;
13493 ctxt->loadsubset |= XML_COMPLETE_ATTRS;
13497 ctxt->replaceEntities = 1;
13498 /* ctxt->loadsubset |= XML_DETECT_IDS; */
13501 ctxt->replaceEntities = 0;
13503 ctxt->pedantic = 1;
13506 ctxt->pedantic = 0;
13508 ctxt->keepBlanks = 0;
13509 ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
13512 ctxt->keepBlanks = 1;
13514 ctxt->validate = 1;
13516 ctxt->vctxt.warning = NULL;
13518 ctxt->vctxt.error = NULL;
13521 ctxt->validate = 0;
13523 ctxt->sax->warning = NULL;
13527 ctxt->sax->error = NULL;
13528 ctxt->sax->fatalError = NULL;
13533 ctxt->sax->startElement = xmlSAX2StartElement;
13534 ctxt->sax->endElement = xmlSAX2EndElement;
13535 ctxt->sax->startElementNs = NULL;
13536 ctxt->sax->endElementNs = NULL;
13537 ctxt->sax->initialized = 1;
13542 ctxt->dictNames = 0;
13545 ctxt->dictNames = 1;
13548 ctxt->sax->cdataBlock = NULL;
13552 ctxt->options |= XML_PARSE_NSCLEAN;
13556 ctxt->options |= XML_PARSE_NONET;
13560 ctxt->options |= XML_PARSE_COMPACT;
13563 ctxt->linenumbers = 1;
13569 * @ctxt: an XML parser context
13580 xmlDoRead(xmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
13585 xmlCtxtUseOptions(ctxt, options);
13591 xmlSwitchToEncoding(ctxt, hdlr);
13593 if ((URL != NULL) && (ctxt->input != NULL) &&
13594 (ctxt->input->filename == NULL))
13595 ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
13596 xmlParseDocument(ctxt);
13597 if ((ctxt->wellFormed) || ctxt->recovery)
13598 ret = ctxt->myDoc;
13601 if (ctxt->myDoc != NULL) {
13602 xmlFreeDoc(ctxt->myDoc);
13605 ctxt->myDoc = NULL;
13607 xmlFreeParserCtxt(ctxt);
13627 xmlParserCtxtPtr ctxt;
13632 ctxt = xmlCreateDocParserCtxt(cur);
13633 if (ctxt == NULL)
13635 return (xmlDoRead(ctxt, URL, encoding, options, 0));
13651 xmlParserCtxtPtr ctxt;
13653 ctxt = xmlCreateURLParserCtxt(filename, options);
13654 if (ctxt == NULL)
13656 return (xmlDoRead(ctxt, NULL, encoding, options, 0));
13674 xmlParserCtxtPtr ctxt;
13676 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
13677 if (ctxt == NULL)
13679 return (xmlDoRead(ctxt, URL, encoding, options, 0));
13698 xmlParserCtxtPtr ctxt;
13709 ctxt = xmlNewParserCtxt();
13710 if (ctxt == NULL) {
13714 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13717 xmlFreeParserCtxt(ctxt);
13720 inputPush(ctxt, stream);
13721 return (xmlDoRead(ctxt, URL, encoding, options, 0));
13741 xmlParserCtxtPtr ctxt;
13752 ctxt = xmlNewParserCtxt();
13753 if (ctxt == NULL) {
13757 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13760 xmlFreeParserCtxt(ctxt);
13763 inputPush(ctxt, stream);
13764 return (xmlDoRead(ctxt, URL, encoding, options, 0));
13769 * @ctxt: an XML parser context
13776 * This reuses the existing @ctxt parser context
13781 xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
13788 if (ctxt == NULL)
13791 xmlCtxtReset(ctxt);
13793 stream = xmlNewStringInputStream(ctxt, cur);
13797 inputPush(ctxt, stream);
13798 return (xmlDoRead(ctxt, URL, encoding, options, 1));
13803 * @ctxt: an XML parser context
13809 * This reuses the existing @ctxt parser context
13814 xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
13821 if (ctxt == NULL)
13824 xmlCtxtReset(ctxt);
13826 stream = xmlLoadExternalEntity(filename, NULL, ctxt);
13830 inputPush(ctxt, stream);
13831 return (xmlDoRead(ctxt, NULL, encoding, options, 1));
13836 * @ctxt: an XML parser context
13844 * This reuses the existing @ctxt parser context
13849 xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
13855 if (ctxt == NULL)
13860 xmlCtxtReset(ctxt);
13867 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13873 inputPush(ctxt, stream);
13874 return (xmlDoRead(ctxt, URL, encoding, options, 1));
13879 * @ctxt: an XML parser context
13886 * This reuses the existing @ctxt parser context
13893 xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
13901 if (ctxt == NULL)
13904 xmlCtxtReset(ctxt);
13911 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13916 inputPush(ctxt, stream);
13917 return (xmlDoRead(ctxt, URL, encoding, options, 1));
13922 * @ctxt: an XML parser context
13931 * This reuses the existing @ctxt parser context
13936 xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
13946 if (ctxt == NULL)
13949 xmlCtxtReset(ctxt);
13955 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13960 inputPush(ctxt, stream);
13961 return (xmlDoRead(ctxt, URL, encoding, options, 1));