Lines Matching refs:ctxt
84 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info);
117 xmlParserEntityCheck(xmlParserCtxtPtr ctxt, unsigned long size,
122 if ((ctxt == NULL) || (ctxt->options & XML_PARSE_HUGE))
124 if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
136 if (ctxt->input != NULL) {
137 consumed = ctxt->input->consumed +
138 (ctxt->input->cur - ctxt->input->base);
140 consumed += ctxt->sizeentities;
143 (ctxt->nbentities * 3 < XML_PARSER_NON_LINEAR * consumed))
154 if (ctxt->input != NULL) {
155 consumed = ctxt->input->consumed +
156 (ctxt->input->cur - ctxt->input->base);
158 consumed += ctxt->sizeentities;
173 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
204 /* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
205 static xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
215 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options,
228 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity);
238 * @ctxt: an XML parser context
245 xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
248 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
249 (ctxt->instate == XML_PARSER_EOF))
251 if (ctxt != NULL)
252 ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
255 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
260 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
265 if (ctxt != NULL) {
266 ctxt->wellFormed = 0;
267 if (ctxt->recovery == 0)
268 ctxt->disableSAX = 1;
274 * @ctxt: an XML parser context
281 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)
285 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
286 (ctxt->instate == XML_PARSER_EOF))
467 if (ctxt != NULL)
468 ctxt->errNo = error;
469 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
472 if (ctxt != NULL) {
473 ctxt->wellFormed = 0;
474 if (ctxt->recovery == 0)
475 ctxt->disableSAX = 1;
481 * @ctxt: an XML parser context
488 xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
491 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
492 (ctxt->instate == XML_PARSER_EOF))
494 if (ctxt != NULL)
495 ctxt->errNo = error;
496 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
498 if (ctxt != NULL) {
499 ctxt->wellFormed = 0;
500 if (ctxt->recovery == 0)
501 ctxt->disableSAX = 1;
507 * @ctxt: an XML parser context
516 xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
521 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
522 (ctxt->instate == XML_PARSER_EOF))
524 if ((ctxt != NULL) && (ctxt->sax != NULL) &&
525 (ctxt->sax->initialized == XML_SAX2_MAGIC))
526 schannel = ctxt->sax->serror;
527 if (ctxt != NULL) {
529 (ctxt->sax) ? ctxt->sax->warning : NULL,
530 ctxt->userData,
531 ctxt, NULL, XML_FROM_PARSER, error,
537 ctxt, NULL, XML_FROM_PARSER, error,
546 * @ctxt: an XML parser context
554 xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
559 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
560 (ctxt->instate == XML_PARSER_EOF))
562 if (ctxt != NULL) {
563 ctxt->errNo = error;
564 if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
565 schannel = ctxt->sax->serror;
567 if (ctxt != NULL) {
569 ctxt->vctxt.error, ctxt->vctxt.userData,
570 ctxt, NULL, XML_FROM_DTD, error,
574 ctxt->valid = 0;
577 ctxt, NULL, XML_FROM_DTD, error,
586 * @ctxt: an XML parser context
594 xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
597 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
598 (ctxt->instate == XML_PARSER_EOF))
600 if (ctxt != NULL)
601 ctxt->errNo = error;
603 ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
605 if (ctxt != NULL) {
606 ctxt->wellFormed = 0;
607 if (ctxt->recovery == 0)
608 ctxt->disableSAX = 1;
614 * @ctxt: an XML parser context
624 xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
628 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
629 (ctxt->instate == XML_PARSER_EOF))
631 if (ctxt != NULL)
632 ctxt->errNo = error;
634 ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
637 if (ctxt != NULL) {
638 ctxt->wellFormed = 0;
639 if (ctxt->recovery == 0)
640 ctxt->disableSAX = 1;
646 * @ctxt: an XML parser context
654 xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
657 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
658 (ctxt->instate == XML_PARSER_EOF))
660 if (ctxt != NULL)
661 ctxt->errNo = error;
662 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
666 if (ctxt != NULL) {
667 ctxt->wellFormed = 0;
668 if (ctxt->recovery == 0)
669 ctxt->disableSAX = 1;
675 * @ctxt: an XML parser context
683 xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
686 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
687 (ctxt->instate == XML_PARSER_EOF))
689 if (ctxt != NULL)
690 ctxt->errNo = error;
691 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
699 * @ctxt: an XML parser context
708 xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
713 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
714 (ctxt->instate == XML_PARSER_EOF))
716 if (ctxt != NULL)
717 ctxt->errNo = error;
718 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
722 if (ctxt != NULL)
723 ctxt->nsWellFormed = 0;
728 * @ctxt: an XML parser context
737 xmlNsWarn(xmlParserCtxtPtr ctxt, xmlParserErrors error,
742 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
743 (ctxt->instate == XML_PARSER_EOF))
745 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
977 * @ctxt: an XML parser context
982 xmlDetectSAX2(xmlParserCtxtPtr ctxt) {
983 if (ctxt == NULL) return;
985 if ((ctxt->sax) && (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
986 ((ctxt->sax->startElementNs != NULL) ||
987 (ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1;
989 ctxt->sax2 = 1;
992 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
993 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
994 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
995 if ((ctxt->str_xml==NULL) || (ctxt->str_xmlns==NULL) ||
996 (ctxt->str_xml_ns == NULL)) {
997 xmlErrMemory(ctxt, NULL);
1060 xmlAttrNormalizeSpace2(xmlParserCtxtPtr ctxt, xmlChar *src, int *len)
1067 if ((ctxt == NULL) || (src == NULL) || (len == NULL))
1093 xmlErrMemory(ctxt, NULL);
1109 * @ctxt: an XML parser context
1117 xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
1129 if (ctxt->attsSpecial != NULL) {
1130 if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1134 if (ctxt->attsDefault == NULL) {
1135 ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
1136 if (ctxt->attsDefault == NULL)
1146 name = xmlDictLookup(ctxt->dict, fullname, -1);
1149 name = xmlDictLookup(ctxt->dict, name, -1);
1150 prefix = xmlDictLookup(ctxt->dict, fullname, len);
1156 defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
1164 if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1178 if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1191 name = xmlDictLookup(ctxt->dict, fullattr, -1);
1194 name = xmlDictLookup(ctxt->dict, name, -1);
1195 prefix = xmlDictLookup(ctxt->dict, fullattr, len);
1202 value = xmlDictLookup(ctxt->dict, value, len);
1205 if (ctxt->external)
1214 xmlErrMemory(ctxt, NULL);
1220 * @ctxt: an XML parser context
1228 xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
1233 if (ctxt->attsSpecial == NULL) {
1234 ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
1235 if (ctxt->attsSpecial == NULL)
1239 if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1242 xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
1247 xmlErrMemory(ctxt, NULL);
1260 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data;
1263 xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL);
1269 * @ctxt: an XML parser context
1276 xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt)
1278 if (ctxt->attsSpecial == NULL)
1281 xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt);
1283 if (xmlHashSize(ctxt->attsSpecial) == 0) {
1284 xmlHashFree(ctxt->attsSpecial, NULL);
1285 ctxt->attsSpecial = NULL;
1368 static xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
1374 * @ctxt: an XML parser context
1384 nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL)
1386 if (ctxt->options & XML_PARSE_NSCLEAN) {
1388 for (i = 0;i < ctxt->nsNr;i += 2) {
1389 if (ctxt->nsTab[i] == prefix) {
1391 if (ctxt->nsTab[i + 1] == URL)
1398 if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) {
1399 ctxt->nsMax = 10;
1400 ctxt->nsNr = 0;
1401 ctxt->nsTab = (const xmlChar **)
1402 xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
1403 if (ctxt->nsTab == NULL) {
1404 xmlErrMemory(ctxt, NULL);
1405 ctxt->nsMax = 0;
1408 } else if (ctxt->nsNr >= ctxt->nsMax) {
1410 ctxt->nsMax *= 2;
1411 tmp = (const xmlChar **) xmlRealloc((char *) ctxt->nsTab,
1412 ctxt->nsMax * sizeof(ctxt->nsTab[0]));
1414 xmlErrMemory(ctxt, NULL);
1415 ctxt->nsMax /= 2;
1418 ctxt->nsTab = tmp;
1420 ctxt->nsTab[ctxt->nsNr++] = prefix;
1421 ctxt->nsTab[ctxt->nsNr++] = URL;
1422 return (ctxt->nsNr);
1426 * @ctxt: an XML parser context
1434 nsPop(xmlParserCtxtPtr ctxt, int nr)
1438 if (ctxt->nsTab == NULL) return(0);
1439 if (ctxt->nsNr < nr) {
1441 nr = ctxt->nsNr;
1443 if (ctxt->nsNr <= 0)
1447 ctxt->nsNr--;
1448 ctxt->nsTab[ctxt->nsNr] = NULL;
1455 xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
1460 if (ctxt->atts == NULL) {
1465 ctxt->atts = atts;
1468 ctxt->attallocs = attallocs;
1469 ctxt->maxatts = maxatts;
1470 } else if (nr + 5 > ctxt->maxatts) {
1472 atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts,
1475 ctxt->atts = atts;
1476 attallocs = (int *) xmlRealloc((void *) ctxt->attallocs,
1479 ctxt->attallocs = attallocs;
1480 ctxt->maxatts = maxatts;
1482 return(ctxt->maxatts);
1484 xmlErrMemory(ctxt, NULL);
1490 * @ctxt: an XML parser context
1498 inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
1500 if ((ctxt == NULL) || (value == NULL))
1502 if (ctxt->inputNr >= ctxt->inputMax) {
1503 ctxt->inputMax *= 2;
1504 ctxt->inputTab =
1505 (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
1506 ctxt->inputMax *
1507 sizeof(ctxt->inputTab[0]));
1508 if (ctxt->inputTab == NULL) {
1509 xmlErrMemory(ctxt, NULL);
1511 ctxt->inputMax /= 2;
1516 ctxt->inputTab[ctxt->inputNr] = value;
1517 ctxt->input = value;
1518 return (ctxt->inputNr++);
1522 * @ctxt: an XML parser context
1529 inputPop(xmlParserCtxtPtr ctxt)
1533 if (ctxt == NULL)
1535 if (ctxt->inputNr <= 0)
1537 ctxt->inputNr--;
1538 if (ctxt->inputNr > 0)
1539 ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
1541 ctxt->input = NULL;
1542 ret = ctxt->inputTab[ctxt->inputNr];
1543 ctxt->inputTab[ctxt->inputNr] = NULL;
1548 * @ctxt: an XML parser context
1556 nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
1558 if (ctxt == NULL) return(0);
1559 if (ctxt->nodeNr >= ctxt->nodeMax) {
1562 tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
1563 ctxt->nodeMax * 2 *
1564 sizeof(ctxt->nodeTab[0]));
1566 xmlErrMemory(ctxt, NULL);
1569 ctxt->nodeTab = tmp;
1570 ctxt->nodeMax *= 2;
1572 if ((((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) &&
1573 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
1574 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
1577 ctxt->instate = XML_PARSER_EOF;
1580 ctxt->nodeTab[ctxt->nodeNr] = value;
1581 ctxt->node = value;
1582 return (ctxt->nodeNr++);
1587 * @ctxt: an XML parser context
1594 nodePop(xmlParserCtxtPtr ctxt)
1598 if (ctxt == NULL) return(NULL);
1599 if (ctxt->nodeNr <= 0)
1601 ctxt->nodeNr--;
1602 if (ctxt->nodeNr > 0)
1603 ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
1605 ctxt->node = NULL;
1606 ret = ctxt->nodeTab[ctxt->nodeNr];
1607 ctxt->nodeTab[ctxt->nodeNr] = NULL;
1614 * @ctxt: an XML parser context
1624 nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
1627 if (ctxt->nameNr >= ctxt->nameMax) {
1630 ctxt->nameMax *= 2;
1631 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1632 ctxt->nameMax *
1633 sizeof(ctxt->nameTab[0]));
1635 ctxt->nameMax /= 2;
1638 ctxt->nameTab = tmp;
1639 tmp2 = (void **) xmlRealloc((void * *)ctxt->pushTab,
1640 ctxt->nameMax * 3 *
1641 sizeof(ctxt->pushTab[0]));
1643 ctxt->nameMax /= 2;
1646 ctxt->pushTab = tmp2;
1648 ctxt->nameTab[ctxt->nameNr] = value;
1649 ctxt->name = value;
1650 ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix;
1651 ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI;
1652 ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr;
1653 return (ctxt->nameNr++);
1655 xmlErrMemory(ctxt, NULL);
1660 * @ctxt: an XML parser context
1667 nameNsPop(xmlParserCtxtPtr ctxt)
1671 if (ctxt->nameNr <= 0)
1673 ctxt->nameNr--;
1674 if (ctxt->nameNr > 0)
1675 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1677 ctxt->name = NULL;
1678 ret = ctxt->nameTab[ctxt->nameNr];
1679 ctxt->nameTab[ctxt->nameNr] = NULL;
1686 * @ctxt: an XML parser context
1694 namePush(xmlParserCtxtPtr ctxt, const xmlChar * value)
1696 if (ctxt == NULL) return (-1);
1698 if (ctxt->nameNr >= ctxt->nameMax) {
1700 ctxt->nameMax *= 2;
1701 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1702 ctxt->nameMax *
1703 sizeof(ctxt->nameTab[0]));
1705 ctxt->nameMax /= 2;
1708 ctxt->nameTab = tmp;
1710 ctxt->nameTab[ctxt->nameNr] = value;
1711 ctxt->name = value;
1712 return (ctxt->nameNr++);
1714 xmlErrMemory(ctxt, NULL);
1719 * @ctxt: an XML parser context
1726 namePop(xmlParserCtxtPtr ctxt)
1730 if ((ctxt == NULL) || (ctxt->nameNr <= 0))
1732 ctxt->nameNr--;
1733 if (ctxt->nameNr > 0)
1734 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1736 ctxt->name = NULL;
1737 ret = ctxt->nameTab[ctxt->nameNr];
1738 ctxt->nameTab[ctxt->nameNr] = NULL;
1742 static int spacePush(xmlParserCtxtPtr ctxt, int val) {
1743 if (ctxt->spaceNr >= ctxt->spaceMax) {
1746 ctxt->spaceMax *= 2;
1747 tmp = (int *) xmlRealloc(ctxt->spaceTab,
1748 ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
1750 xmlErrMemory(ctxt, NULL);
1751 ctxt->spaceMax /=2;
1754 ctxt->spaceTab = tmp;
1756 ctxt->spaceTab[ctxt->spaceNr] = val;
1757 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
1758 return(ctxt->spaceNr++);
1761 static int spacePop(xmlParserCtxtPtr ctxt) {
1763 if (ctxt->spaceNr <= 0) return(0);
1764 ctxt->spaceNr--;
1765 if (ctxt->spaceNr > 0)
1766 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
1768 ctxt->space = &ctxt->spaceTab[0];
1769 ret = ctxt->spaceTab[ctxt->spaceNr];
1770 ctxt->spaceTab[ctxt->spaceNr] = -1;
1809 #define RAW (*ctxt->input->cur)
1810 #define CUR (*ctxt->input->cur)
1811 #define NXT(val) ctxt->input->cur[(val)]
1812 #define CUR_PTR ctxt->input->cur
1833 ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val); \
1834 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1835 if ((*ctxt->input->cur == 0) && \
1836 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
1837 xmlPopInput(ctxt); \
1843 if (*(ctxt->input->cur) == '\n') { \
1844 ctxt->input->line++; ctxt->input->col = 1; \
1845 } else ctxt->input->col++; \
1846 ctxt->nbChars++; \
1847 ctxt->input->cur++; \
1849 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1850 if ((*ctxt->input->cur == 0) && \
1851 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
1852 xmlPopInput(ctxt); \
1855 #define SHRINK if ((ctxt->progressive == 0) && \
1856 (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
1857 (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
1858 xmlSHRINK (ctxt);
1860 static void xmlSHRINK (xmlParserCtxtPtr ctxt) {
1861 xmlParserInputShrink(ctxt->input);
1862 if ((*ctxt->input->cur == 0) &&
1863 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1864 xmlPopInput(ctxt);
1867 #define GROW if ((ctxt->progressive == 0) && \
1868 (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \
1869 xmlGROW (ctxt);
1871 static void xmlGROW (xmlParserCtxtPtr ctxt) {
1872 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
1873 if ((ctxt->input->cur != NULL) && (*ctxt->input->cur == 0) &&
1874 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1875 xmlPopInput(ctxt);
1878 #define SKIP_BLANKS xmlSkipBlankChars(ctxt)
1880 #define NEXT xmlNextChar(ctxt)
1883 ctxt->input->col++; \
1884 ctxt->input->cur++; \
1885 ctxt->nbChars++; \
1886 if (*ctxt->input->cur == 0) \
1887 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); \
1891 if (*(ctxt->input->cur) == '\n') { \
1892 ctxt->input->line++; ctxt->input->col = 1; \
1893 } else ctxt->input->col++; \
1894 ctxt->input->cur += l; \
1895 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1898 #define CUR_CHAR(l) xmlCurrentChar(ctxt, &l)
1899 #define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
1907 * @ctxt: the XML parser context
1916 xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
1923 if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) {
1928 cur = ctxt->input->cur;
1931 ctxt->input->line++; ctxt->input->col = 1;
1936 ctxt->input->cur = cur;
1937 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
1938 cur = ctxt->input->cur;
1941 ctxt->input->cur = cur;
1951 while ((cur == 0) && (ctxt->inputNr > 1) &&
1952 (ctxt->instate != XML_PARSER_COMMENT)) {
1953 xmlPopInput(ctxt);
1959 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);
1973 * @ctxt: an XML parser context
1975 * xmlPopInput: the current input pointed by ctxt->input came to an end
1981 xmlPopInput(xmlParserCtxtPtr ctxt) {
1982 if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0);
1985 "Popping input %d\n", ctxt->inputNr);
1986 xmlFreeInputStream(inputPop(ctxt));
1987 if ((*ctxt->input->cur == 0) &&
1988 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1989 return(xmlPopInput(ctxt));
1995 * @ctxt: an XML parser context
2003 xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
2008 if ((ctxt->input != NULL) && (ctxt->input->filename))
2010 "%s(%d): ", ctxt->input->filename,
2011 ctxt->input->line);
2013 "Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
2015 ret = inputPush(ctxt, input);
2016 if (ctxt->instate == XML_PARSER_EOF)
2024 * @ctxt: an XML parser context
2038 xmlParseCharRef(xmlParserCtxtPtr ctxt) {
2054 if (ctxt->instate == XML_PARSER_EOF)
2064 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2076 ctxt->input->col++;
2077 ctxt->nbChars ++;
2078 ctxt->input->cur++;
2087 if (ctxt->instate == XML_PARSER_EOF)
2093 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2105 ctxt->input->col++;
2106 ctxt->nbChars ++;
2107 ctxt->input->cur++;
2110 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2121 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2130 * @ctxt: an XML parser context
2147 xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
2167 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2186 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2199 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2212 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2221 * @ctxt: an XML parser context
2233 xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
2238 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
2245 input = xmlNewInputStream(ctxt);
2252 xmlErrMemory(ctxt, NULL);
2272 * @ctxt: the parser context
2303 xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
2309 switch(ctxt->instate) {
2319 xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
2324 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
2335 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
2354 if ((ctxt->external == 0) && (ctxt->inputNr == 1))
2364 name = xmlParseName(ctxt);
2369 xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL);
2373 if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL))
2374 entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
2375 if (ctxt->instate == XML_PARSER_EOF)
2387 if ((ctxt->standalone == 1) ||
2388 ((ctxt->hasExternalSubset == 0) &&
2389 (ctxt->hasPErefs == 0))) {
2390 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
2400 if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
2401 xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
2405 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
2408 ctxt->valid = 0;
2410 } else if (ctxt->input->free != deallocblankswrapper) {
2411 input = xmlNewBlanksWrapperInputStream(ctxt, entity);
2412 if (xmlPushInput(ctxt, input) < 0)
2425 input = xmlNewEntityInputStream(ctxt, entity);
2426 if (xmlPushInput(ctxt, input) < 0)
2439 if (ctxt->instate == XML_PARSER_EOF)
2441 if ((ctxt->input->end - ctxt->input->cur)>=4) {
2448 xmlSwitchEncoding(ctxt, enc);
2455 xmlParseTextDecl(ctxt);
2458 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
2464 xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
2484 * @ctxt: the parser context
2502 xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2514 if ((ctxt == NULL) || (str == NULL) || (len < 0))
2518 if (((ctxt->depth > 40) &&
2519 ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
2520 (ctxt->depth > 1024)) {
2521 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
2545 int val = xmlParseStringCharRef(ctxt, &str);
2557 ent = xmlParseStringEntityRef(ctxt, &str);
2558 if ((ctxt->lastError.code == XML_ERR_ENTITY_LOOP) ||
2559 (ctxt->lastError.code == XML_ERR_INTERNAL_ERROR))
2562 ctxt->nbentities += ent->checked;
2571 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
2575 ctxt->depth++;
2576 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2578 ctxt->depth--;
2586 if (xmlParserEntityCheck(ctxt, nbchars, ent))
2610 ent = xmlParseStringPEReference(ctxt, &str);
2611 if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
2614 ctxt->nbentities += ent->checked;
2617 xmlLoadEntityContent(ctxt, ent);
2619 ctxt->depth++;
2620 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2622 ctxt->depth--;
2629 if (xmlParserEntityCheck(ctxt, nbchars, ent))
2654 xmlErrMemory(ctxt, NULL);
2665 * @ctxt: the parser context
2682 xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
2684 if ((ctxt == NULL) || (str == NULL)) return(NULL);
2685 return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what,
2697 * @ctxt: an XML parser context
2707 static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2716 if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
2722 if ((ctxt->space == NULL) || (*(ctxt->space) == 1) ||
2723 (*(ctxt->space) == -2))
2737 if (ctxt->node == NULL) return(0);
2738 if (ctxt->myDoc != NULL) {
2739 ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
2748 if ((ctxt->node->children == NULL) &&
2751 lastChild = xmlGetLastChild(ctxt->node);
2753 if ((ctxt->node->type != XML_ELEMENT_NODE) &&
2754 (ctxt->node->content != NULL)) return(0);
2757 else if ((ctxt->node->children != NULL) &&
2758 (xmlNodeIsText(ctxt->node->children)))
2772 * @ctxt: an XML parser context
2789 xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix) {
2828 xmlErrMemory(ctxt, NULL);
2841 xmlErrMemory(ctxt, NULL);
2887 xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
2907 xmlErrMemory(ctxt, NULL);
2919 xmlErrMemory(ctxt, NULL);
2973 xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) {
2974 if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3004 xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) {
3005 if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3042 static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
3046 xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
3059 if (ctxt->instate == XML_PARSER_EOF)
3062 if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3112 if (ctxt->instate == XML_PARSER_EOF)
3138 if (ctxt->instate == XML_PARSER_EOF)
3146 if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
3147 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
3148 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
3153 * @ctxt: an XML parser context
3168 xmlParseName(xmlParserCtxtPtr ctxt) {
3182 in = ctxt->input->cur;
3194 count = in - ctxt->input->cur;
3195 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3196 ctxt->input->cur = in;
3197 ctxt->nbChars += count;
3198 ctxt->input->col += count;
3200 xmlErrMemory(ctxt, NULL);
3205 return(xmlParseNameComplex(ctxt));
3209 xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
3224 (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) {
3229 (xmlIsNameChar(ctxt, c) && (c != ':'))) {
3233 if (ctxt->instate == XML_PARSER_EOF)
3240 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
3245 * @ctxt: an XML parser context
3259 xmlParseNCName(xmlParserCtxtPtr ctxt) {
3271 in = ctxt->input->cur;
3283 count = in - ctxt->input->cur;
3284 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3285 ctxt->input->cur = in;
3286 ctxt->nbChars += count;
3287 ctxt->input->col += count;
3289 xmlErrMemory(ctxt, NULL);
3294 return(xmlParseNCNameComplex(ctxt));
3299 * @ctxt: an XML parser context
3309 xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
3315 if (ctxt->instate == XML_PARSER_EOF)
3318 in = ctxt->input->cur;
3322 ctxt->input->col++;
3326 ctxt->input->cur = in;
3330 ret = xmlParseName (ctxt);
3340 * @ctxt: an XML parser context
3357 xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
3368 if (!xmlIsNameStartChar(ctxt, c)) {
3375 while (xmlIsNameChar(ctxt, c)) {
3389 xmlErrMemory(ctxt, NULL);
3393 while (xmlIsNameChar(ctxt, c)) {
3400 xmlErrMemory(ctxt, NULL);
3421 * @ctxt: an XML parser context
3433 xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
3444 if (ctxt->instate == XML_PARSER_EOF)
3448 while (xmlIsNameChar(ctxt, c)) {
3466 xmlErrMemory(ctxt, NULL);
3470 while (xmlIsNameChar(ctxt, c)) {
3474 if (ctxt->instate == XML_PARSER_EOF) {
3486 xmlErrMemory(ctxt, NULL);
3507 * @ctxt: an XML parser context
3519 xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
3532 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
3537 xmlErrMemory(ctxt, NULL);
3545 ctxt->instate = XML_PARSER_ENTITY_VALUE;
3546 input = ctxt->input;
3548 if (ctxt->instate == XML_PARSER_EOF) {
3564 (ctxt->input != input))) && (ctxt->instate != XML_PARSER_EOF)) {
3571 xmlErrMemory(ctxt, NULL);
3582 while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */
3583 xmlPopInput(ctxt);
3593 if (ctxt->instate == XML_PARSER_EOF) {
3610 name = xmlParseStringName(ctxt, &cur);
3612 xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
3616 if ((tmp == '%') && (ctxt->inSubset == 1) &&
3617 (ctxt->inputNr == 1)) {
3618 xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
3632 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
3642 ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
3655 * @ctxt: an XML parser context
3666 xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) {
3677 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3682 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3685 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
3702 (ctxt->instate != XML_PARSER_EOF)) {
3707 int val = xmlParseCharRef(ctxt);
3710 if (ctxt->replaceEntities) {
3736 ent = xmlParseEntityRef(ctxt);
3737 ctxt->nbentities++;
3739 ctxt->nbentities += ent->owner;
3745 if ((ctxt->replaceEntities == 0) &&
3756 (ctxt->replaceEntities != 0)) {
3758 rep = xmlStringDecodeEntities(ctxt, ent->content,
3794 rep = xmlStringDecodeEntities(ctxt, ent->content,
3837 if (ctxt->instate == XML_PARSER_EOF)
3845 xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
3848 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
3851 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
3860 xmlErrMemory(ctxt, NULL);
3871 * @ctxt: an XML parser context
3904 xmlParseAttValue(xmlParserCtxtPtr ctxt) {
3905 if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL);
3906 return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
3911 * @ctxt: an XML parser context
3921 xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
3927 int state = ctxt->instate;
3938 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
3944 xmlErrMemory(ctxt, NULL);
3947 ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
3957 xmlErrMemory(ctxt, NULL);
3958 ctxt->instate = (xmlParserInputState) state;
3967 if (ctxt->instate == XML_PARSER_EOF) {
3982 ctxt->instate = (xmlParserInputState) state;
3984 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
3993 * @ctxt: an XML parser context
4003 xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
4010 xmlParserInputState oldstate = ctxt->instate;
4020 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4025 xmlErrMemory(ctxt, NULL);
4028 ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
4037 xmlErrMemory(ctxt, NULL);
4048 if (ctxt->instate == XML_PARSER_EOF) {
4063 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4067 ctxt->instate = oldstate;
4071 static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
4113 * @ctxt: an XML parser context
4128 xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
4131 int line = ctxt->input->line;
4132 int col = ctxt->input->col;
4142 in = ctxt->input->cur;
4145 while (*in == 0x20) { in++; ctxt->input->col++; }
4148 ctxt->input->line++; ctxt->input->col = 1;
4154 nbchar = in - ctxt->input->cur;
4156 const xmlChar *tmp = ctxt->input->cur;
4157 ctxt->input->cur = in;
4159 if ((ctxt->sax != NULL) &&
4160 (ctxt->sax->ignorableWhitespace !=
4161 ctxt->sax->characters)) {
4162 if (areBlanks(ctxt, tmp, nbchar, 1)) {
4163 if (ctxt->sax->ignorableWhitespace != NULL)
4164 ctxt->sax->ignorableWhitespace(ctxt->userData,
4167 if (ctxt->sax->characters != NULL)
4168 ctxt->sax->characters(ctxt->userData,
4170 if (*ctxt->space == -1)
4171 *ctxt->space = -2;
4173 } else if ((ctxt->sax != NULL) &&
4174 (ctxt->sax->characters != NULL)) {
4175 ctxt->sax->characters(ctxt->userData,
4183 ccol = ctxt->input->col;
4188 ctxt->input->col = ccol;
4191 ctxt->input->line++; ctxt->input->col = 1;
4198 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4199 ctxt->input->cur = in;
4203 ctxt->input->col++;
4206 nbchar = in - ctxt->input->cur;
4208 if ((ctxt->sax != NULL) &&
4209 (ctxt->sax->ignorableWhitespace !=
4210 ctxt->sax->characters) &&
4211 (IS_BLANK_CH(*ctxt->input->cur))) {
4212 const xmlChar *tmp = ctxt->input->cur;
4213 ctxt->input->cur = in;
4215 if (areBlanks(ctxt, tmp, nbchar, 0)) {
4216 if (ctxt->sax->ignorableWhitespace != NULL)
4217 ctxt->sax->ignorableWhitespace(ctxt->userData,
4220 if (ctxt->sax->characters != NULL)
4221 ctxt->sax->characters(ctxt->userData,
4223 if (*ctxt->space == -1)
4224 *ctxt->space = -2;
4226 line = ctxt->input->line;
4227 col = ctxt->input->col;
4228 } else if (ctxt->sax != NULL) {
4229 if (ctxt->sax->characters != NULL)
4230 ctxt->sax->characters(ctxt->userData,
4231 ctxt->input->cur, nbchar);
4232 line = ctxt->input->line;
4233 col = ctxt->input->col;
4236 if (ctxt->instate != XML_PARSER_CONTENT)
4239 ctxt->input->cur = in;
4243 ctxt->input->cur = in;
4245 ctxt->input->line++; ctxt->input->col = 1;
4258 if (ctxt->instate == XML_PARSER_EOF)
4260 in = ctxt->input->cur;
4264 ctxt->input->line = line;
4265 ctxt->input->col = col;
4266 xmlParseCharDataComplex(ctxt, cdata);
4271 * @ctxt: an XML parser context
4279 xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
4295 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4305 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4306 if (areBlanks(ctxt, buf, nbchar, 0)) {
4307 if (ctxt->sax->ignorableWhitespace != NULL)
4308 ctxt->sax->ignorableWhitespace(ctxt->userData,
4311 if (ctxt->sax->characters != NULL)
4312 ctxt->sax->characters(ctxt->userData, buf, nbchar);
4313 if ((ctxt->sax->characters !=
4314 ctxt->sax->ignorableWhitespace) &&
4315 (*ctxt->space == -1))
4316 *ctxt->space = -2;
4321 if (ctxt->instate != XML_PARSER_CONTENT)
4328 if (ctxt->instate == XML_PARSER_EOF)
4339 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4340 if (areBlanks(ctxt, buf, nbchar, 0)) {
4341 if (ctxt->sax->ignorableWhitespace != NULL)
4342 ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
4344 if (ctxt->sax->characters != NULL)
4345 ctxt->sax->characters(ctxt->userData, buf, nbchar);
4346 if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) &&
4347 (*ctxt->space == -1))
4348 *ctxt->space = -2;
4354 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4363 * @ctxt: an XML parser context
4384 xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
4393 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4397 URI = xmlParseSystemLiteral(ctxt);
4399 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4404 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4408 *publicID = xmlParsePubidLiteral(ctxt);
4410 xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
4417 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4436 URI = xmlParseSystemLiteral(ctxt);
4438 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4446 * @ctxt: an XML parser context
4459 xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf, int len, int size) {
4466 inputid = ctxt->input->id;
4473 xmlErrMemory(ctxt, NULL);
4482 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4493 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4507 xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
4515 xmlErrMemory(ctxt, NULL);
4530 if (ctxt->instate == XML_PARSER_EOF) {
4545 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4548 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4552 if (inputid != ctxt->input->id) {
4553 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4557 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4558 (!ctxt->disableSAX))
4559 ctxt->sax->comment(ctxt->userData, buf);
4564 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4572 * @ctxt: an XML parser context
4581 xmlParseComment(xmlParserCtxtPtr ctxt) {
4595 state = ctxt->instate;
4596 ctxt->instate = XML_PARSER_COMMENT;
4597 inputid = ctxt->input->id;
4606 in = ctxt->input->cur;
4610 ctxt->input->line++; ctxt->input->col = 1;
4615 ccol = ctxt->input->col;
4622 ctxt->input->col = ccol;
4625 ctxt->input->line++; ctxt->input->col = 1;
4630 nbchar = in - ctxt->input->cur;
4635 if ((ctxt->sax != NULL) &&
4636 (ctxt->sax->comment != NULL)) {
4644 xmlErrMemory(ctxt, NULL);
4645 ctxt->instate = state;
4656 xmlErrMemory(ctxt, NULL);
4657 ctxt->instate = state;
4662 memcpy(&buf[len], ctxt->input->cur, nbchar);
4667 ctxt->input->cur = in;
4670 ctxt->input->line++; ctxt->input->col = 1;
4675 ctxt->input->cur = in;
4677 ctxt->input->line++; ctxt->input->col = 1;
4684 if (ctxt->instate == XML_PARSER_EOF) {
4688 in = ctxt->input->cur;
4692 if (ctxt->input->id != inputid) {
4693 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4697 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4698 (!ctxt->disableSAX)) {
4700 ctxt->sax->comment(ctxt->userData, buf);
4702 ctxt->sax->comment(ctxt->userData, BAD_CAST "");
4706 if (ctxt->instate != XML_PARSER_EOF)
4707 ctxt->instate = state;
4711 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4715 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4718 ctxt->input->col++;
4721 ctxt->input->col++;
4725 xmlParseCommentComplex(ctxt, buf, len, size);
4726 ctxt->instate = state;
4733 * @ctxt: an XML parser context
4743 xmlParsePITarget(xmlParserCtxtPtr ctxt) {
4746 name = xmlParseName(ctxt);
4754 xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
4758 xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
4766 xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
4771 xmlNsErr(ctxt, XML_NS_ERR_COLON,
4780 * @ctxt: an XML parser context
4794 xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
4825 ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
4831 xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
4841 * @ctxt: an XML parser context
4851 xmlParsePI(xmlParserCtxtPtr ctxt) {
4861 xmlParserInputPtr input = ctxt->input;
4862 state = ctxt->instate;
4863 ctxt->instate = XML_PARSER_PI;
4874 target = xmlParsePITarget(ctxt);
4877 if (input != ctxt->input) {
4878 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4886 if ((ctxt->sax) && (!ctxt->disableSAX) &&
4887 (ctxt->sax->processingInstruction != NULL))
4888 ctxt->sax->processingInstruction(ctxt->userData,
4890 if (ctxt->instate != XML_PARSER_EOF)
4891 ctxt->instate = state;
4896 xmlErrMemory(ctxt, NULL);
4897 ctxt->instate = state;
4902 xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
4915 xmlErrMemory(ctxt, NULL);
4917 ctxt->instate = state;
4925 if (ctxt->instate == XML_PARSER_EOF) {
4942 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
4945 if (input != ctxt->input) {
4946 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4958 xmlParseCatalogPI(ctxt, buf);
4966 if ((ctxt->sax) && (!ctxt->disableSAX) &&
4967 (ctxt->sax->processingInstruction != NULL))
4968 ctxt->sax->processingInstruction(ctxt->userData,
4973 xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
4975 if (ctxt->instate != XML_PARSER_EOF)
4976 ctxt->instate = state;
4982 * @ctxt: an XML parser context
4997 xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
5003 xmlParserInputPtr input = ctxt->input;
5007 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5013 name = xmlParseName(ctxt);
5015 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5019 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5024 xmlNsErr(ctxt, XML_NS_ERR_COLON,
5033 Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
5037 if (input != ctxt->input) {
5038 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5042 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5043 (ctxt->sax->notationDecl != NULL))
5044 ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
5046 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5055 * @ctxt: an XML parser context
5076 xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
5087 xmlParserInputPtr input = ctxt->input;
5092 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5100 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5106 name = xmlParseName(ctxt);
5108 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5113 xmlNsErr(ctxt, XML_NS_ERR_COLON,
5119 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5123 ctxt->instate = XML_PARSER_ENTITY_DECL;
5129 value = xmlParseEntityValue(ctxt, &orig);
5131 if ((ctxt->sax != NULL) &&
5132 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5133 ctxt->sax->entityDecl(ctxt->userData, name,
5138 URI = xmlParseExternalID(ctxt, &literal, 1);
5140 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5147 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5160 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5162 if ((ctxt->sax != NULL) &&
5163 (!ctxt->disableSAX) &&
5164 (ctxt->sax->entityDecl != NULL))
5165 ctxt->sax->entityDecl(ctxt->userData, name,
5175 value = xmlParseEntityValue(ctxt, &orig);
5176 if ((ctxt->sax != NULL) &&
5177 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5178 ctxt->sax->entityDecl(ctxt->userData, name,
5184 if ((ctxt->myDoc == NULL) ||
5185 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
5186 if (ctxt->myDoc == NULL) {
5187 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5188 if (ctxt->myDoc == NULL) {
5189 xmlErrMemory(ctxt, "New Doc failed");
5192 ctxt->myDoc->properties = XML_DOC_INTERNAL;
5194 if (ctxt->myDoc->intSubset == NULL)
5195 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5198 xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
5202 URI = xmlParseExternalID(ctxt, &literal, 1);
5204 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5211 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5224 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5230 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5237 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5241 ndata = xmlParseName(ctxt);
5242 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5243 (ctxt->sax->unparsedEntityDecl != NULL))
5244 ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
5247 if ((ctxt->sax != NULL) &&
5248 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5249 ctxt->sax->entityDecl(ctxt->userData, name,
5256 if ((ctxt->replaceEntities != 0) &&
5257 ((ctxt->myDoc == NULL) ||
5258 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
5259 if (ctxt->myDoc == NULL) {
5260 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5261 if (ctxt->myDoc == NULL) {
5262 xmlErrMemory(ctxt, "New Doc failed");
5265 ctxt->myDoc->properties = XML_DOC_INTERNAL;
5268 if (ctxt->myDoc->intSubset == NULL)
5269 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5271 xmlSAX2EntityDecl(ctxt, name,
5278 if (ctxt->instate == XML_PARSER_EOF)
5282 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
5285 if (input != ctxt->input) {
5286 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5298 if ((ctxt->sax != NULL) &&
5299 (ctxt->sax->getParameterEntity != NULL))
5300 cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
5302 if ((ctxt->sax != NULL) &&
5303 (ctxt->sax->getEntity != NULL))
5304 cur = ctxt->sax->getEntity(ctxt->userData, name);
5305 if ((cur == NULL) && (ctxt->userData==ctxt)) {
5306 cur = xmlSAX2GetEntity(ctxt, name);
5325 * @ctxt: an XML parser context
5353 xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
5371 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5376 ret = xmlParseAttValue(ctxt);
5377 ctxt->instate = XML_PARSER_DTD;
5379 xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
5388 * @ctxt: an XML parser context
5404 xmlParseNotationType(xmlParserCtxtPtr ctxt) {
5409 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5416 name = xmlParseName(ctxt);
5418 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5426 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5429 if (!xmlDictOwns(ctxt->dict, name))
5450 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5460 * @ctxt: an XML parser context
5474 xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
5479 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
5486 name = xmlParseNmtoken(ctxt);
5488 xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
5494 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5497 if (!xmlDictOwns(ctxt->dict, name))
5505 if (!xmlDictOwns(ctxt->dict, name))
5520 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
5529 * @ctxt: an XML parser context
5543 xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5547 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5552 *tree = xmlParseNotationType(ctxt);
5556 *tree = xmlParseEnumerationType(ctxt);
5563 * @ctxt: an XML parser context
5607 xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5634 return(xmlParseEnumeratedType(ctxt, tree));
5639 * @ctxt: an XML parser context
5649 xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
5655 xmlParserInputPtr input = ctxt->input;
5659 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5663 elemName = xmlParseName(ctxt);
5665 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5671 while ((RAW != '>') && (ctxt->instate != XML_PARSER_EOF)) {
5679 attrName = xmlParseName(ctxt);
5681 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5687 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5693 type = xmlParseAttributeType(ctxt, &tree);
5700 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5708 def = xmlParseDefaultDecl(ctxt, &defaultValue);
5722 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5733 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
5741 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5742 (ctxt->sax->attributeDecl != NULL))
5743 ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
5748 if ((ctxt->sax2) && (defaultValue != NULL) &&
5751 xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
5753 if (ctxt->sax2) {
5754 xmlAddSpecialAttr(ctxt, elemName, attrName, type);
5761 if (input != ctxt->input) {
5762 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5773 * @ctxt: an XML parser context
5791 xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
5801 if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5802 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5807 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5817 ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5820 while ((RAW == '|') && (ctxt->instate != XML_PARSER_EOF)) {
5823 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5830 n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5832 n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5841 elem = xmlParseName(ctxt);
5843 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5845 xmlFreeDocElementContent(ctxt->myDoc, cur);
5853 cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
5860 if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5861 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5867 xmlFreeDocElementContent(ctxt->myDoc, ret);
5868 xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
5873 xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
5880 * @ctxt: an XML parser context
5911 xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk,
5917 if (((depth > 128) && ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
5919 xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED,
5927 int inputid = ctxt->input->id;
5932 cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
5937 elem = xmlParseName(ctxt);
5939 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
5942 cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5944 xmlErrMemory(ctxt, NULL);
5964 while ((RAW != ')') && (ctxt->instate != XML_PARSER_EOF)) {
5975 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
5979 xmlFreeDocElementContent(ctxt->myDoc, last);
5981 xmlFreeDocElementContent(ctxt->myDoc, ret);
5986 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
5989 xmlFreeDocElementContent(ctxt->myDoc, last);
5990 xmlFreeDocElementContent(ctxt->myDoc, ret);
6015 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6019 xmlFreeDocElementContent(ctxt->myDoc, last);
6021 xmlFreeDocElementContent(ctxt->myDoc, ret);
6026 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6029 xmlFreeDocElementContent(ctxt->myDoc, last);
6031 xmlFreeDocElementContent(ctxt->myDoc, ret);
6050 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
6052 xmlFreeDocElementContent(ctxt->myDoc, last);
6054 xmlFreeDocElementContent(ctxt->myDoc, ret);
6061 int inputid = ctxt->input->id;
6065 last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6069 elem = xmlParseName(ctxt);
6071 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6073 xmlFreeDocElementContent(ctxt->myDoc, ret);
6076 last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6079 xmlFreeDocElementContent(ctxt->myDoc, ret);
6103 if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6104 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6178 * @ctxt: an XML parser context
6207 xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6209 return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1));
6214 * @ctxt: an XML parser context
6227 xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
6231 int inputid = ctxt->input->id;
6237 xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6243 if (ctxt->instate == XML_PARSER_EOF)
6247 tree = xmlParseElementMixedContentDecl(ctxt, inputid);
6250 tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1);
6260 * @ctxt: an XML parser context
6272 xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
6279 xmlParserInputPtr input = ctxt->input;
6283 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6287 name = xmlParseName(ctxt);
6289 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6293 while ((RAW == 0) && (ctxt->inputNr > 1))
6294 xmlPopInput(ctxt);
6296 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6314 ret = xmlParseElementContentDecl(ctxt, name, &content);
6319 if ((RAW == '%') && (ctxt->external == 0) &&
6320 (ctxt->inputNr == 1)) {
6321 xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
6324 xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6334 while ((RAW == 0) && (ctxt->inputNr > 1))
6335 xmlPopInput(ctxt);
6339 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
6341 xmlFreeDocElementContent(ctxt->myDoc, content);
6344 if (input != ctxt->input) {
6345 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6350 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6351 (ctxt->sax->elementDecl != NULL)) {
6354 ctxt->sax->elementDecl(ctxt->userData, name, ret,
6363 xmlFreeDocElementContent(ctxt->myDoc, content);
6366 xmlFreeDocElementContent(ctxt->myDoc, content);
6375 * @ctxt: an XML parser context
6385 xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
6386 int id = ctxt->input->id;
6394 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6396 if (ctxt->input->id != id) {
6397 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6404 if ((ctxt->input != NULL) && (ctxt->input->filename))
6406 "%s(%d): ", ctxt->input->filename,
6407 ctxt->input->line);
6413 (NXT(2) != '>'))) && (ctxt->instate != XML_PARSER_EOF)) {
6415 unsigned int cons = ctxt->input->consumed;
6418 xmlParseConditionalSections(ctxt);
6422 xmlParsePEReference(ctxt);
6424 xmlParseMarkupDecl(ctxt);
6429 while ((RAW == 0) && (ctxt->inputNr > 1))
6430 xmlPopInput(ctxt);
6432 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
6433 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6438 if ((ctxt->input != NULL) && (ctxt->input->filename))
6440 "%s(%d): ", ctxt->input->filename,
6441 ctxt->input->line);
6454 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6456 if (ctxt->input->id != id) {
6457 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6464 if ((ctxt->input != NULL) && (ctxt->input->filename))
6466 "%s(%d): ", ctxt->input->filename,
6467 ctxt->input->line);
6476 state = ctxt->disableSAX;
6477 instate = ctxt->instate;
6478 if (ctxt->recovery == 0) ctxt->disableSAX = 1;
6479 ctxt->instate = XML_PARSER_IGNORE;
6482 (ctxt->instate != XML_PARSER_EOF)) {
6496 ctxt->disableSAX = state;
6497 ctxt->instate = instate;
6500 if ((ctxt->input != NULL) && (ctxt->input->filename))
6502 "%s(%d): ", ctxt->input->filename,
6503 ctxt->input->line);
6509 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
6516 xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
6518 if (ctxt->input->id != id) {
6519 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6529 * @ctxt: an XML parser context
6550 xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
6557 xmlParseElementDecl(ctxt);
6559 xmlParseEntityDecl(ctxt);
6562 xmlParseAttributeListDecl(ctxt);
6565 xmlParseNotationDecl(ctxt);
6568 xmlParseComment(ctxt);
6575 xmlParsePI(ctxt);
6582 if ((ctxt->external == 0) && (ctxt->inputNr == 1))
6583 xmlParsePEReference(ctxt);
6589 if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
6591 xmlParseConditionalSections(ctxt);
6595 ctxt->instate = XML_PARSER_DTD;
6600 * @ctxt: an XML parser context
6608 xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
6618 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
6623 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6631 version = xmlParseVersionInfo(ctxt);
6636 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6640 ctxt->input->version = version;
6645 encoding = xmlParseEncodingDecl(ctxt);
6646 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
6652 if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
6653 xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
6662 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
6665 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
6673 * @ctxt: an XML parser context
6684 xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
6686 xmlDetectSAX2(ctxt);
6689 if ((ctxt->encoding == (const xmlChar *)XML_CHAR_ENCODING_NONE) &&
6690 (ctxt->input->end - ctxt->input->cur >= 4)) {
6700 xmlSwitchEncoding(ctxt, enc);
6704 xmlParseTextDecl(ctxt);
6705 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
6709 ctxt->instate = XML_PARSER_EOF;
6713 if (ctxt->myDoc == NULL) {
6714 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
6715 if (ctxt->myDoc == NULL) {
6716 xmlErrMemory(ctxt, "New Doc failed");
6719 ctxt->myDoc->properties = XML_DOC_INTERNAL;
6721 if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
6722 xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
6724 ctxt->instate = XML_PARSER_DTD;
6725 ctxt->external = 1;
6730 unsigned int cons = ctxt->input->consumed;
6734 xmlParseConditionalSections(ctxt);
6738 xmlParsePEReference(ctxt);
6740 xmlParseMarkupDecl(ctxt);
6745 while ((RAW == 0) && (ctxt->inputNr > 1))
6746 xmlPopInput(ctxt);
6748 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
6749 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6755 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6762 * @ctxt: an XML parser context
6772 xmlParseReference(xmlParserCtxtPtr ctxt) {
6790 int value = xmlParseCharRef(ctxt);
6794 if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
6803 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6804 (!ctxt->disableSAX))
6805 ctxt->sax->characters(ctxt->userData, out, 1);
6811 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
6812 (!ctxt->disableSAX))
6813 ctxt->sax->reference(ctxt->userData, out);
6821 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6822 (!ctxt->disableSAX))
6823 ctxt->sax->characters(ctxt->userData, out, i);
6831 ent = xmlParseEntityRef(ctxt);
6833 if (!ctxt->wellFormed)
6845 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6846 (!ctxt->disableSAX))
6847 ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
6857 unsigned long oldnbent = ctxt->nbentities;
6865 if (ctxt->userData == ctxt)
6868 user_data = ctxt->userData;
6877 ctxt->depth++;
6878 ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content,
6880 ctxt->depth--;
6883 ctxt->depth++;
6884 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax,
6885 user_data, ctxt->depth, ent->URI,
6887 ctxt->depth--;
6890 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
6898 ent->checked = ctxt->nbentities - oldnbent;
6900 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6904 if (xmlParserEntityCheck(ctxt, 0, ent)) {
6914 if (ctxt->replaceEntities) {
6921 (ctxt->parseMode == XML_PARSE_READER)) {
6928 list->parent = (xmlNodePtr) ctxt->node;
6929 list->doc = ctxt->myDoc;
6955 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6964 ctxt->nbentities += ent->checked;
6986 if (ctxt->userData == ctxt)
6989 user_data = ctxt->userData;
6992 ctxt->depth++;
6993 ret = xmlParseBalancedChunkMemoryInternal(ctxt,
6995 ctxt->depth--;
6998 ctxt->depth++;
6999 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
7000 ctxt->sax, user_data, ctxt->depth,
7002 ctxt->depth--;
7005 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
7009 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7013 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7014 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7019 ctxt->sax->reference(ctxt->userData, ent->name);
7027 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7028 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7032 ctxt->sax->reference(ctxt->userData, ent->name);
7036 if ((ctxt->replaceEntities) || (ent->children == NULL)) {
7050 if ((ctxt->node != NULL) && (ent->children != NULL)) {
7059 (ctxt->parseMode == XML_PARSE_READER)) {
7065 if (ctxt->parseMode == XML_PARSE_READER)
7071 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7078 nw = xmlAddChild(ctxt->node, nw);
7085 if ((ctxt->parseMode == XML_PARSE_READER) &&
7116 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7124 xmlAddChild(ctxt->node, cur);
7144 nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
7151 xmlAddChildList(ctxt->node, ent->children);
7158 ctxt->nodemem = 0;
7159 ctxt->nodelen = 0;
7167 * @ctxt: an XML parser context
7194 xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
7199 if (ctxt->instate == XML_PARSER_EOF)
7205 name = xmlParseName(ctxt);
7207 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7212 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7220 if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7229 ctxt->nbentities++;
7235 if (ctxt->sax != NULL) {
7236 if (ctxt->sax->getEntity != NULL)
7237 ent = ctxt->sax->getEntity(ctxt->userData, name);
7238 if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7239 (ctxt->options & XML_PARSE_OLDSAX))
7241 if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7242 (ctxt->userData==ctxt)) {
7243 ent = xmlSAX2GetEntity(ctxt, name);
7246 if (ctxt->instate == XML_PARSER_EOF)
7270 if ((ctxt->standalone == 1) ||
7271 ((ctxt->hasExternalSubset == 0) &&
7272 (ctxt->hasPErefs == 0))) {
7273 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7276 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7278 if ((ctxt->inSubset == 0) &&
7279 (ctxt->sax != NULL) &&
7280 (ctxt->sax->reference != NULL)) {
7281 ctxt->sax->reference(ctxt->userData, name);
7284 ctxt->valid = 0;
7293 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7302 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7304 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7313 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7317 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7328 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7348 * @ctxt: an XML parser context
7378 xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
7392 name = xmlParseStringName(ctxt, &ptr);
7394 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7400 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7411 if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7423 ctxt->nbentities++;
7429 if (ctxt->sax != NULL) {
7430 if (ctxt->sax->getEntity != NULL)
7431 ent = ctxt->sax->getEntity(ctxt->userData, name);
7432 if ((ent == NULL) && (ctxt->options & XML_PARSE_OLDSAX))
7434 if ((ent == NULL) && (ctxt->userData==ctxt)) {
7435 ent = xmlSAX2GetEntity(ctxt, name);
7438 if (ctxt->instate == XML_PARSER_EOF) {
7465 if ((ctxt->standalone == 1) ||
7466 ((ctxt->hasExternalSubset == 0) &&
7467 (ctxt->hasPErefs == 0))) {
7468 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7471 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7475 /* TODO ? check regressions ctxt->valid = 0; */
7484 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7493 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7495 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7504 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7508 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7520 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7543 * @ctxt: an XML parser context
7571 xmlParsePEReference(xmlParserCtxtPtr ctxt)
7580 name = xmlParseName(ctxt);
7582 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7587 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7596 ctxt->nbentities++;
7601 if ((ctxt->sax != NULL) &&
7602 (ctxt->sax->getParameterEntity != NULL))
7603 entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
7604 if (ctxt->instate == XML_PARSER_EOF)
7615 if ((ctxt->standalone == 1) ||
7616 ((ctxt->hasExternalSubset == 0) &&
7617 (ctxt->hasPErefs == 0))) {
7618 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7629 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7632 ctxt->valid = 0;
7640 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7643 } else if (ctxt->input->free != deallocblankswrapper) {
7644 input = xmlNewBlanksWrapperInputStream(ctxt, entity);
7645 if (xmlPushInput(ctxt, input) < 0)
7653 input = xmlNewEntityInputStream(ctxt, entity);
7654 if (xmlPushInput(ctxt, input) < 0)
7659 xmlParseTextDecl(ctxt);
7660 if (ctxt->errNo ==
7666 ctxt->instate = XML_PARSER_EOF;
7672 ctxt->hasPErefs = 1;
7677 * @ctxt: an XML parser context
7687 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
7693 if ((ctxt == NULL) || (entity == NULL) ||
7697 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7708 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7713 input = xmlNewEntityInputStream(ctxt, entity);
7715 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7725 if (xmlPushInput(ctxt, input) < 0) {
7732 while ((ctxt->input == input) && (ctxt->input->cur < ctxt->input->end) &&
7734 xmlBufferAdd(buf, ctxt->input->cur, l);
7738 if (ctxt->instate == XML_PARSER_EOF) {
7747 if ((ctxt->input == input) && (ctxt->input->cur >= ctxt->input->end)) {
7748 xmlPopInput(ctxt);
7750 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
7765 * @ctxt: an XML parser context
7795 xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
7807 name = xmlParseStringName(ctxt, &ptr);
7809 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7816 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7826 ctxt->nbentities++;
7831 if ((ctxt->sax != NULL) &&
7832 (ctxt->sax->getParameterEntity != NULL))
7833 entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
7834 if (ctxt->instate == XML_PARSER_EOF) {
7847 if ((ctxt->standalone == 1) ||
7848 ((ctxt->hasExternalSubset == 0) && (ctxt->hasPErefs == 0))) {
7849 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7859 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7862 ctxt->valid = 0;
7870 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7875 ctxt->hasPErefs = 1;
7883 * @ctxt: an XML parser context
7896 xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
7911 name = xmlParseName(ctxt);
7913 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7916 ctxt->intSubName = name;
7923 URI = xmlParseExternalID(ctxt, &ExternalID, 1);
7926 ctxt->hasExternalSubset = 1;
7928 ctxt->extSubURI = URI;
7929 ctxt->extSubSystem = ExternalID;
7936 if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
7937 (!ctxt->disableSAX))
7938 ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
7939 if (ctxt->instate == XML_PARSER_EOF)
7953 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
7960 * @ctxt: an XML parser context
7968 xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
7973 ctxt->instate = XML_PARSER_DTD;
7980 while ((RAW != ']') && (ctxt->instate != XML_PARSER_EOF)) {
7982 unsigned int cons = ctxt->input->consumed;
7985 xmlParseMarkupDecl(ctxt);
7986 xmlParsePEReference(ctxt);
7991 while ((RAW == 0) && (ctxt->inputNr > 1))
7992 xmlPopInput(ctxt);
7994 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
7995 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8010 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8018 * @ctxt: an XML parser context
8050 xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
8056 name = xmlParseName(ctxt);
8058 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8070 val = xmlParseAttValue(ctxt);
8071 ctxt->instate = XML_PARSER_CONTENT;
8073 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8083 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
8085 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8096 *(ctxt->space) = 0;
8098 *(ctxt->space) = 1;
8100 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8112 * @ctxt: an XML parser context
8139 xmlParseStartTag(xmlParserCtxtPtr ctxt) {
8143 const xmlChar **atts = ctxt->atts;
8145 int maxatts = ctxt->maxatts;
8151 name = xmlParseName(ctxt);
8153 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8168 (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
8170 unsigned int cons = ctxt->input->consumed;
8172 attname = xmlParseAttribute(ctxt, &attvalue);
8181 xmlErrAttributeDup(ctxt, NULL, attname);
8194 xmlErrMemory(ctxt, NULL);
8199 ctxt->atts = atts;
8200 ctxt->maxatts = maxatts;
8208 xmlErrMemory(ctxt, NULL);
8214 ctxt->atts = atts;
8215 ctxt->maxatts = maxatts;
8232 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8236 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
8238 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
8249 if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
8250 (!ctxt->disableSAX)) {
8252 ctxt->sax->startElement(ctxt->userData, name, atts);
8254 ctxt->sax->startElement(ctxt->userData, name, NULL);
8268 * @ctxt: an XML parser context
8282 xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
8287 xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
8293 name = xmlParseNameAndCompare(ctxt,ctxt->name);
8301 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
8313 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
8315 ctxt->name, line, name);
8321 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
8322 (!ctxt->disableSAX))
8323 ctxt->sax->endElement(ctxt->userData, ctxt->name);
8325 namePop(ctxt);
8326 spacePop(ctxt);
8332 * @ctxt: an XML parser context
8344 xmlParseEndTag(xmlParserCtxtPtr ctxt) {
8345 xmlParseEndTag1(ctxt, 0);
8357 * @ctxt: an XML parser context
8361 * The prefix must come from the @ctxt->dict dictionnary
8366 xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
8369 if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
8370 for (i = ctxt->nsNr - 2;i >= 0;i-=2)
8371 if (ctxt->nsTab[i] == prefix) {
8372 if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
8374 return(ctxt->nsTab[i + 1]);
8381 * @ctxt: an XML parser context
8394 xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
8399 l = xmlParseNCName(ctxt);
8402 l = xmlParseName(ctxt);
8404 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8415 l = xmlParseNCName(ctxt);
8419 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8421 l = xmlParseNmtoken(ctxt);
8428 p = xmlDictLookup(ctxt->dict, tmp, -1);
8436 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8439 tmp = (xmlChar *) xmlParseName(ctxt);
8442 l = xmlDictLookup(ctxt->dict, tmp, -1);
8448 l = xmlDictLookup(ctxt->dict, tmp, -1);
8461 * @ctxt: an XML parser context
8473 xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
8480 if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
8483 in = ctxt->input->cur;
8499 ctxt->input->cur = in;
8506 ret = xmlParseQName (ctxt, &prefix2);
8514 * @ctxt: an XML parser context
8547 xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len, int *alloc,
8557 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
8560 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
8568 end = ctxt->input->end;
8571 const xmlChar *oldbase = ctxt->input->base;
8573 if (oldbase != ctxt->input->base) {
8574 long delta = ctxt->input->base - oldbase;
8578 end = ctxt->input->end;
8590 const xmlChar *oldbase = ctxt->input->base;
8592 if (ctxt->instate == XML_PARSER_EOF)
8594 if (oldbase != ctxt->input->base) {
8595 long delta = ctxt->input->base - oldbase;
8599 end = ctxt->input->end;
8606 const xmlChar *oldbase = ctxt->input->base;
8608 if (ctxt->instate == XML_PARSER_EOF)
8610 if (oldbase != ctxt->input->base) {
8611 long delta = ctxt->input->base - oldbase;
8615 end = ctxt->input->end;
8628 const xmlChar *oldbase = ctxt->input->base;
8630 if (ctxt->instate == XML_PARSER_EOF)
8632 if (oldbase != ctxt->input->base) {
8633 long delta = ctxt->input->base - oldbase;
8638 end = ctxt->input->end;
8647 const xmlChar *oldbase = ctxt->input->base;
8649 if (ctxt->instate == XML_PARSER_EOF)
8651 if (oldbase != ctxt->input->base) {
8652 long delta = ctxt->input->base - oldbase;
8656 end = ctxt->input->end;
8675 return xmlParseAttValueComplex(ctxt, len, normalize);
8680 * @ctxt: an XML parser context
8694 xmlParseAttribute2(xmlParserCtxtPtr ctxt,
8705 name = xmlParseQName(ctxt, prefix);
8707 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8715 if (ctxt->attsSpecial != NULL) {
8718 type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial,
8731 val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
8742 val2 = xmlAttrNormalizeSpace2(ctxt, val, len);
8749 ctxt->instate = XML_PARSER_CONTENT;
8751 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8757 if (*prefix == ctxt->str_xml) {
8763 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
8766 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8778 *(ctxt->space) = 0;
8780 *(ctxt->space) = 1;
8782 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8797 * @ctxt: an XML parser context
8825 xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
8833 const xmlChar **atts = ctxt->atts;
8834 int maxatts = ctxt->maxatts;
8839 int nsNr = ctxt->nsNr;
8853 base = ctxt->input->base;
8854 cur = ctxt->input->cur - ctxt->input->base;
8855 oldline = ctxt->input->line;
8856 oldcol = ctxt->input->col;
8863 ctxt->nsNr = nsNr;
8865 localname = xmlParseQName(ctxt, &prefix);
8867 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8871 *tlen = ctxt->input->cur - ctxt->input->base - cur;
8880 if (ctxt->input->base != base) goto base_changed;
8884 (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
8886 unsigned int cons = ctxt->input->consumed;
8889 attname = xmlParseAttribute2(ctxt, prefix, localname,
8891 if (ctxt->input->base != base) {
8899 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
8900 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
8906 xmlNsErr(ctxt, XML_WAR_NS_URI,
8911 xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
8917 if (URL == ctxt->str_xml_ns) {
8918 if (attname != ctxt->str_xml) {
8919 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8928 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8938 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
8941 xmlErrAttributeDup(ctxt, NULL, attname);
8943 if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
8949 if (aprefix == ctxt->str_xmlns) {
8950 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
8953 if (attname == ctxt->str_xml) {
8954 if (URL != ctxt->str_xml_ns) {
8955 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8964 if (URL == ctxt->str_xml_ns) {
8965 if (attname != ctxt->str_xml) {
8966 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8972 if (attname == ctxt->str_xmlns) {
8973 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8981 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8987 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8994 xmlNsErr(ctxt, XML_WAR_NS_URI,
8998 if ((ctxt->pedantic) && (uri->scheme == NULL)) {
8999 xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9011 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9014 xmlErrAttributeDup(ctxt, aprefix, attname);
9016 if (nsPush(ctxt, attname, URL) > 0) nbNs++;
9020 if (ctxt->input->base != base) goto base_changed;
9028 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9033 maxatts = ctxt->maxatts;
9034 atts = ctxt->atts;
9036 ctxt->attallocs[nratts++] = alloc;
9055 if (ctxt->instate == XML_PARSER_EOF)
9057 if (ctxt->input->base != base) goto base_changed;
9061 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9066 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
9068 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9073 if (ctxt->input->base != base) goto base_changed;
9079 if (ctxt->attsDefault != NULL) {
9082 defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
9091 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9096 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
9100 nsname = xmlGetNamespace(ctxt, NULL);
9102 if (nsPush(ctxt, NULL,
9106 } else if (aprefix == ctxt->str_xmlns) {
9111 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9115 nsname = xmlGetNamespace(ctxt, attname);
9117 if (nsPush(ctxt, attname,
9132 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9135 maxatts = ctxt->maxatts;
9136 atts = ctxt->atts;
9143 atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
9146 if ((ctxt->standalone == 1) &&
9148 xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED,
9166 nsname = xmlGetNamespace(ctxt, atts[i + 1]);
9168 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9184 xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
9188 xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
9197 nsname = xmlGetNamespace(ctxt, prefix);
9199 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9209 if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
9210 (!ctxt->disableSAX)) {
9212 ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9213 nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
9216 ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9225 if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9237 if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9240 ctxt->input->cur = ctxt->input->base + cur;
9241 ctxt->input->line = oldline;
9242 ctxt->input->col = oldcol;
9243 if (ctxt->wellFormed == 1) {
9251 * @ctxt: an XML parser context
9265 xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
9271 xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
9276 if ((tlen > 0) && (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
9277 if (ctxt->input->cur[tlen] == '>') {
9278 ctxt->input->cur += tlen + 1;
9281 ctxt->input->cur += tlen;
9285 name = xmlParseNameAndCompare(ctxt, ctxt->name);
9287 name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
9294 if (ctxt->instate == XML_PARSER_EOF)
9298 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
9310 if ((line == 0) && (ctxt->node != NULL))
9311 line = ctxt->node->line;
9312 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
9314 ctxt->name, line, name);
9321 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
9322 (!ctxt->disableSAX))
9323 ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
9325 spacePop(ctxt);
9327 nsPop(ctxt, nsNr);
9333 * @ctxt: an XML parser context
9346 xmlParseCDSect(xmlParserCtxtPtr ctxt) {
9361 ctxt->instate = XML_PARSER_CDATA_SECTION;
9364 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9365 ctxt->instate = XML_PARSER_CONTENT;
9371 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9372 ctxt->instate = XML_PARSER_CONTENT;
9379 xmlErrMemory(ctxt, NULL);
9391 xmlErrMemory(ctxt, NULL);
9404 if (ctxt->instate == XML_PARSER_EOF) {
9414 ctxt->instate = XML_PARSER_CONTENT;
9416 xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
9426 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
9427 if (ctxt->sax->cdataBlock != NULL)
9428 ctxt->sax->cdataBlock(ctxt->userData, buf, len);
9429 else if (ctxt->sax->characters != NULL)
9430 ctxt->sax->characters(ctxt->userData, buf, len);
9437 * @ctxt: an XML parser context
9445 xmlParseContent(xmlParserCtxtPtr ctxt) {
9449 (ctxt->instate != XML_PARSER_EOF)) {
9451 unsigned int cons = ctxt->input->consumed;
9452 const xmlChar *cur = ctxt->input->cur;
9458 xmlParsePI(ctxt);
9466 xmlParseCDSect(ctxt);
9474 xmlParseComment(ctxt);
9475 ctxt->instate = XML_PARSER_CONTENT;
9482 xmlParseElement(ctxt);
9491 xmlParseReference(ctxt);
9498 xmlParseCharData(ctxt, 0);
9505 while ((RAW == 0) && (ctxt->inputNr > 1))
9506 xmlPopInput(ctxt);
9509 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
9510 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9512 ctxt->instate = XML_PARSER_EOF;
9520 * @ctxt: an XML parser context
9533 xmlParseElement(xmlParserCtxtPtr ctxt) {
9540 int nsNr = ctxt->nsNr;
9542 if (((unsigned int) ctxt->nameNr > xmlParserMaxDepth) &&
9543 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9544 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
9547 ctxt->instate = XML_PARSER_EOF;
9552 if (ctxt->record_info) {
9553 node_info.begin_pos = ctxt->input->consumed +
9554 (CUR_PTR - ctxt->input->base);
9555 node_info.begin_line = ctxt->input->line;
9558 if (ctxt->spaceNr == 0)
9559 spacePush(ctxt, -1);
9560 else if (*ctxt->space == -2)
9561 spacePush(ctxt, -1);
9563 spacePush(ctxt, *ctxt->space);
9565 line = ctxt->input->line;
9567 if (ctxt->sax2)
9569 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
9572 name = xmlParseStartTag(ctxt);
9574 if (ctxt->instate == XML_PARSER_EOF)
9577 spacePop(ctxt);
9580 namePush(ctxt, name);
9581 ret = ctxt->node;
9589 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
9590 ctxt->node && (ctxt->node == ctxt->myDoc->children))
9591 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
9599 if (ctxt->sax2) {
9600 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
9601 (!ctxt->disableSAX))
9602 ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
9605 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
9606 (!ctxt->disableSAX))
9607 ctxt->sax->endElement(ctxt->userData, name);
9610 namePop(ctxt);
9611 spacePop(ctxt);
9612 if (nsNr != ctxt->nsNr)
9613 nsPop(ctxt, ctxt->nsNr - nsNr);
9614 if ( ret != NULL && ctxt->record_info ) {
9615 node_info.end_pos = ctxt->input->consumed +
9616 (CUR_PTR - ctxt->input->base);
9617 node_info.end_line = ctxt->input->line;
9619 xmlParserAddNodeInfo(ctxt, &node_info);
9626 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
9633 nodePop(ctxt);
9634 namePop(ctxt);
9635 spacePop(ctxt);
9636 if (nsNr != ctxt->nsNr)
9637 nsPop(ctxt, ctxt->nsNr - nsNr);
9642 if ( ret != NULL && ctxt->record_info ) {
9643 node_info.end_pos = ctxt->input->consumed +
9644 (CUR_PTR - ctxt->input->base);
9645 node_info.end_line = ctxt->input->line;
9647 xmlParserAddNodeInfo(ctxt, &node_info);
9655 xmlParseContent(ctxt);
9656 if (ctxt->instate == XML_PARSER_EOF)
9659 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
9666 nodePop(ctxt);
9667 namePop(ctxt);
9668 spacePop(ctxt);
9669 if (nsNr != ctxt->nsNr)
9670 nsPop(ctxt, ctxt->nsNr - nsNr);
9677 if (ctxt->sax2) {
9678 xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
9679 namePop(ctxt);
9683 xmlParseEndTag1(ctxt, line);
9689 if ( ret != NULL && ctxt->record_info ) {
9690 node_info.end_pos = ctxt->input->consumed +
9691 (CUR_PTR - ctxt->input->base);
9692 node_info.end_line = ctxt->input->line;
9694 xmlParserAddNodeInfo(ctxt, &node_info);
9700 * @ctxt: an XML parser context
9711 xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
9719 xmlErrMemory(ctxt, NULL);
9745 xmlErrMemory(ctxt, NULL);
9760 * @ctxt: an XML parser context
9772 xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
9779 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
9786 version = xmlParseVersionNum(ctxt);
9788 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9793 version = xmlParseVersionNum(ctxt);
9795 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9799 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
9807 * @ctxt: an XML parser context
9816 xmlParseEncName(xmlParserCtxtPtr ctxt) {
9827 xmlErrMemory(ctxt, NULL);
9845 xmlErrMemory(ctxt, NULL);
9862 xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
9869 * @ctxt: an XML parser context
9881 xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
9889 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
9896 encoding = xmlParseEncName(ctxt);
9898 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9903 encoding = xmlParseEncName(ctxt);
9905 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9909 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
9924 if ((ctxt->encoding == NULL) &&
9925 (ctxt->input->buf != NULL) &&
9926 (ctxt->input->buf->encoder == NULL)) {
9927 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_ENCODING,
9930 if (ctxt->encoding != NULL)
9931 xmlFree((xmlChar *) ctxt->encoding);
9932 ctxt->encoding = encoding;
9940 if (ctxt->encoding != NULL)
9941 xmlFree((xmlChar *) ctxt->encoding);
9942 ctxt->encoding = encoding;
9947 if (ctxt->input->encoding != NULL)
9948 xmlFree((xmlChar *) ctxt->input->encoding);
9949 ctxt->input->encoding = encoding;
9953 xmlSwitchToEncoding(ctxt, handler);
9955 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
9966 * @ctxt: an XML parser context
9996 xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
10004 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10019 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10022 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10035 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10038 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10042 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10050 * @ctxt: an XML parser context
10058 xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
10066 ctxt->input->standalone = -2;
10074 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
10082 version = xmlParseVersionInfo(ctxt);
10084 xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
10090 if (ctxt->options & XML_PARSE_OLD10) {
10091 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10096 xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
10100 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10106 if (ctxt->version != NULL)
10107 xmlFree((void *) ctxt->version);
10108 ctxt->version = version;
10119 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10121 xmlParseEncodingDecl(ctxt);
10122 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10132 if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
10137 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10146 ctxt->input->standalone = xmlParseSDDecl(ctxt);
10153 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10156 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10164 * @ctxt: an XML parser context
10172 xmlParseMisc(xmlParserCtxtPtr ctxt) {
10173 while ((ctxt->instate != XML_PARSER_EOF) &&
10178 xmlParsePI(ctxt);
10182 xmlParseComment(ctxt);
10188 * @ctxt: an XML parser context
10202 xmlParseDocument(xmlParserCtxtPtr ctxt) {
10208 if ((ctxt == NULL) || (ctxt->input == NULL))
10216 xmlDetectSAX2(ctxt);
10221 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10222 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
10223 if (ctxt->instate == XML_PARSER_EOF)
10226 if ((ctxt->encoding == (const xmlChar *)XML_CHAR_ENCODING_NONE) &&
10227 ((ctxt->input->end - ctxt->input->cur) >= 4)) {
10239 xmlSwitchEncoding(ctxt, enc);
10245 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10254 if ((ctxt->input->end - ctxt->input->cur) < 35) {
10262 xmlParseXMLDecl(ctxt);
10263 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10269 ctxt->standalone = ctxt->input->standalone;
10272 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10274 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10275 ctxt->sax->startDocument(ctxt->userData);
10276 if (ctxt->instate == XML_PARSER_EOF)
10283 xmlParseMisc(ctxt);
10292 ctxt->inSubset = 1;
10293 xmlParseDocTypeDecl(ctxt);
10295 ctxt->instate = XML_PARSER_DTD;
10296 xmlParseInternalSubset(ctxt);
10297 if (ctxt->instate == XML_PARSER_EOF)
10304 ctxt->inSubset = 2;
10305 if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
10306 (!ctxt->disableSAX))
10307 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
10308 ctxt->extSubSystem, ctxt->extSubURI);
10309 if (ctxt->instate == XML_PARSER_EOF)
10311 ctxt->inSubset = 0;
10313 xmlCleanSpecialAttr(ctxt);
10315 ctxt->instate = XML_PARSER_PROLOG;
10316 xmlParseMisc(ctxt);
10324 xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
10327 ctxt->instate = XML_PARSER_CONTENT;
10328 xmlParseElement(ctxt);
10329 ctxt->instate = XML_PARSER_EPILOG;
10335 xmlParseMisc(ctxt);
10338 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10340 ctxt->instate = XML_PARSER_EOF;
10346 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10347 ctxt->sax->endDocument(ctxt->userData);
10352 if ((ctxt->myDoc != NULL) &&
10353 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
10354 xmlFreeDoc(ctxt->myDoc);
10355 ctxt->myDoc = NULL;
10358 if ((ctxt->wellFormed) && (ctxt->myDoc != NULL)) {
10359 ctxt->myDoc->properties |= XML_DOC_WELLFORMED;
10360 if (ctxt->valid)
10361 ctxt->myDoc->properties |= XML_DOC_DTDVALID;
10362 if (ctxt->nsWellFormed)
10363 ctxt->myDoc->properties |= XML_DOC_NSVALID;
10364 if (ctxt->options & XML_PARSE_OLD10)
10365 ctxt->myDoc->properties |= XML_DOC_OLD10;
10367 if (! ctxt->wellFormed) {
10368 ctxt->valid = 0;
10376 * @ctxt: an XML parser context
10389 xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
10393 if ((ctxt == NULL) || (ctxt->input == NULL))
10398 xmlDetectSAX2(ctxt);
10405 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10406 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
10413 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
10420 xmlSwitchEncoding(ctxt, enc);
10426 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10438 xmlParseXMLDecl(ctxt);
10439 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10447 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10449 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10450 ctxt->sax->startDocument(ctxt->userData);
10451 if (ctxt->instate == XML_PARSER_EOF)
10457 ctxt->instate = XML_PARSER_CONTENT;
10458 ctxt->validate = 0;
10459 ctxt->loadsubset = 0;
10460 ctxt->depth = 0;
10462 xmlParseContent(ctxt);
10463 if (ctxt->instate == XML_PARSER_EOF)
10467 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
10469 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
10475 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10476 ctxt->sax->endDocument(ctxt->userData);
10478 if (! ctxt->wellFormed) return(-1);
10491 * @ctxt: an XML parser context
10498 * This function has a side effect of (possibly) incrementing ctxt->checkIndex
10506 xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
10512 in = ctxt->input;
10516 if (ctxt->checkIndex > base)
10517 base = ctxt->checkIndex;
10536 ctxt->checkIndex = 0;
10554 ctxt->checkIndex = base;
10571 * @ctxt: an XML parser context
10578 xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
10582 if ((ctxt == NULL) || (lastlt == NULL) || (lastgt == NULL)) {
10587 if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) {
10588 tmp = ctxt->input->end;
10590 while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
10591 if (tmp < ctxt->input->base) {
10597 while ((tmp < ctxt->input->end) && (*tmp != '>')) {
10600 while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++;
10601 if (tmp < ctxt->input->end) tmp++;
10604 while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++;
10605 if (tmp < ctxt->input->end) tmp++;
10609 if (tmp < ctxt->input->end)
10614 while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
10615 if (tmp >= ctxt->input->base)
10695 * @ctxt: an XML parser context
10703 xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
10709 if (ctxt->input == NULL)
10713 switch (ctxt->instate) {
10765 if ((ctxt->input != NULL) &&
10766 (ctxt->input->cur - ctxt->input->base > 4096)) {
10767 xmlSHRINK(ctxt);
10768 ctxt->checkIndex = 0;
10770 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
10772 while (ctxt->instate != XML_PARSER_EOF) {
10773 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
10780 while ((RAW == 0) && (ctxt->inputNr > 1))
10781 xmlPopInput(ctxt);
10783 if (ctxt->input == NULL) break;
10784 if (ctxt->input->buf == NULL)
10785 avail = ctxt->input->length -
10786 (ctxt->input->cur - ctxt->input->base);
10793 if ((ctxt->input->buf->raw != NULL) &&
10794 (ctxt->input->buf->raw->use > 0)) {
10795 int base = ctxt->input->base -
10796 ctxt->input->buf->buffer->content;
10797 int current = ctxt->input->cur - ctxt->input->base;
10799 xmlParserInputBufferPush(ctxt->input->buf, 0, "");
10800 ctxt->input->base = ctxt->input->buf->buffer->content + base;
10801 ctxt->input->cur = ctxt->input->base + current;
10802 ctxt->input->end =
10803 &ctxt->input->buf->buffer->content[
10804 ctxt->input->buf->buffer->use];
10806 avail = ctxt->input->buf->buffer->use -
10807 (ctxt->input->cur - ctxt->input->base);
10811 switch (ctxt->instate) {
10818 if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
10840 xmlSwitchEncoding(ctxt, enc);
10846 cur = ctxt->input->cur[0];
10847 next = ctxt->input->cur[1];
10849 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10850 ctxt->sax->setDocumentLocator(ctxt->userData,
10852 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10853 ctxt->instate = XML_PARSER_EOF;
10858 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10859 ctxt->sax->endDocument(ctxt->userData);
10866 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10868 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10869 ctxt->sax->setDocumentLocator(ctxt->userData,
10871 if ((ctxt->input->cur[2] == 'x') &&
10872 (ctxt->input->cur[3] == 'm') &&
10873 (ctxt->input->cur[4] == 'l') &&
10874 (IS_BLANK_CH(ctxt->input->cur[5]))) {
10880 xmlParseXMLDecl(ctxt);
10881 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10886 ctxt->instate = XML_PARSER_EOF;
10889 ctxt->standalone = ctxt->input->standalone;
10890 if ((ctxt->encoding == NULL) &&
10891 (ctxt->input->encoding != NULL))
10892 ctxt->encoding = xmlStrdup(ctxt->input->encoding);
10893 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
10894 (!ctxt->disableSAX))
10895 ctxt->sax->startDocument(ctxt->userData);
10896 ctxt->instate = XML_PARSER_MISC;
10902 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10903 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
10904 (!ctxt->disableSAX))
10905 ctxt->sax->startDocument(ctxt->userData);
10906 ctxt->instate = XML_PARSER_MISC;
10913 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10914 ctxt->sax->setDocumentLocator(ctxt->userData,
10916 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10917 if (ctxt->version == NULL) {
10918 xmlErrMemory(ctxt, NULL);
10921 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
10922 (!ctxt->disableSAX))
10923 ctxt->sax->startDocument(ctxt->userData);
10924 ctxt->instate = XML_PARSER_MISC;
10935 int nsNr = ctxt->nsNr;
10937 if ((avail < 2) && (ctxt->inputNr == 1))
10939 cur = ctxt->input->cur[0];
10941 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10942 ctxt->instate = XML_PARSER_EOF;
10943 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10944 ctxt->sax->endDocument(ctxt->userData);
10948 if (ctxt->progressive) {
10950 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
10952 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
10956 if (ctxt->spaceNr == 0)
10957 spacePush(ctxt, -1);
10958 else if (*ctxt->space == -2)
10959 spacePush(ctxt, -1);
10961 spacePush(ctxt, *ctxt->space);
10963 if (ctxt->sax2)
10965 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
10968 name = xmlParseStartTag(ctxt);
10970 if (ctxt->instate == XML_PARSER_EOF)
10973 spacePop(ctxt);
10974 ctxt->instate = XML_PARSER_EOF;
10975 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10976 ctxt->sax->endDocument(ctxt->userData);
10985 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
10986 ctxt->node && (ctxt->node == ctxt->myDoc->children))
10987 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
10996 if (ctxt->sax2) {
10997 if ((ctxt->sax != NULL) &&
10998 (ctxt->sax->endElementNs != NULL) &&
10999 (!ctxt->disableSAX))
11000 ctxt->sax->endElementNs(ctxt->userData, name,
11002 if (ctxt->nsNr - nsNr > 0)
11003 nsPop(ctxt, ctxt->nsNr - nsNr);
11006 if ((ctxt->sax != NULL) &&
11007 (ctxt->sax->endElement != NULL) &&
11008 (!ctxt->disableSAX))
11009 ctxt->sax->endElement(ctxt->userData, name);
11012 if (ctxt->instate == XML_PARSER_EOF)
11014 spacePop(ctxt);
11015 if (ctxt->nameNr == 0) {
11016 ctxt->instate = XML_PARSER_EPILOG;
11018 ctxt->instate = XML_PARSER_CONTENT;
11025 xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
11028 nodePop(ctxt);
11029 spacePop(ctxt);
11031 if (ctxt->sax2)
11032 nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
11035 namePush(ctxt, name);
11038 ctxt->instate = XML_PARSER_CONTENT;
11044 if ((avail < 2) && (ctxt->inputNr == 1))
11046 cur = ctxt->input->cur[0];
11047 next = ctxt->input->cur[1];
11050 cons = ctxt->input->consumed;
11052 ctxt->instate = XML_PARSER_END_TAG;
11056 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11058 xmlParsePI(ctxt);
11060 ctxt->instate = XML_PARSER_START_TAG;
11063 (ctxt->input->cur[2] == '-') &&
11064 (ctxt->input->cur[3] == '-')) {
11069 ctxt->input->cur += 4;
11070 term = xmlParseLookupSequence(ctxt, '-', '-', '>');
11071 ctxt->input->cur -= 4;
11074 xmlParseComment(ctxt);
11075 ctxt->instate = XML_PARSER_CONTENT;
11076 } else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
11077 (ctxt->input->cur[2] == '[') &&
11078 (ctxt->input->cur[3] == 'C') &&
11079 (ctxt->input->cur[4] == 'D') &&
11080 (ctxt->input->cur[5] == 'A') &&
11081 (ctxt->input->cur[6] == 'T') &&
11082 (ctxt->input->cur[7] == 'A') &&
11083 (ctxt->input->cur[8] == '[')) {
11085 ctxt->instate = XML_PARSER_CDATA_SECTION;
11092 (xmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
11094 xmlParseReference(ctxt);
11108 if ((ctxt->inputNr == 1) &&
11111 if (ctxt->progressive) {
11113 (ctxt->input->cur > lastlt))
11115 } else if (xmlParseLookupSequence(ctxt,
11121 ctxt->checkIndex = 0;
11122 xmlParseCharData(ctxt, 0);
11127 while ((RAW == 0) && (ctxt->inputNr > 1))
11128 xmlPopInput(ctxt);
11129 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
11130 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
11132 ctxt->instate = XML_PARSER_EOF;
11141 if (ctxt->progressive) {
11143 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
11145 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
11149 if (ctxt->sax2) {
11150 xmlParseEndTag2(ctxt,
11151 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 3],
11152 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 2], 0,
11153 (int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
11154 nameNsPop(ctxt);
11158 xmlParseEndTag1(ctxt, 0);
11160 if (ctxt->instate == XML_PARSER_EOF) {
11162 } else if (ctxt->nameNr == 0) {
11163 ctxt->instate = XML_PARSER_EPILOG;
11165 ctxt->instate = XML_PARSER_CONTENT;
11175 base = xmlParseLookupSequence(ctxt, ']', ']', '>');
11180 tmp = xmlCheckCdataPush(ctxt->input->cur,
11184 ctxt->input->cur += tmp;
11187 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
11188 if (ctxt->sax->cdataBlock != NULL)
11189 ctxt->sax->cdataBlock(ctxt->userData,
11190 ctxt->input->cur, tmp);
11191 else if (ctxt->sax->characters != NULL)
11192 ctxt->sax->characters(ctxt->userData,
11193 ctxt->input->cur, tmp);
11195 if (ctxt->instate == XML_PARSER_EOF)
11198 ctxt->checkIndex = 0;
11204 tmp = xmlCheckCdataPush(ctxt->input->cur, base);
11207 ctxt->input->cur += tmp;
11210 if ((ctxt->sax != NULL) && (base == 0) &&
11211 (ctxt->sax->cdataBlock != NULL) &&
11212 (!ctxt->disableSAX)) {
11218 if ((ctxt->input->cur - ctxt->input->base >= 9) &&
11219 (!strncmp((const char *)&ctxt->input->cur[-9],
11221 ctxt->sax->cdataBlock(ctxt->userData,
11223 } else if ((ctxt->sax != NULL) && (base > 0) &&
11224 (!ctxt->disableSAX)) {
11225 if (ctxt->sax->cdataBlock != NULL)
11226 ctxt->sax->cdataBlock(ctxt->userData,
11227 ctxt->input->cur, base);
11228 else if (ctxt->sax->characters != NULL)
11229 ctxt->sax->characters(ctxt->userData,
11230 ctxt->input->cur, base);
11232 if (ctxt->instate == XML_PARSER_EOF)
11235 ctxt->checkIndex = 0;
11236 ctxt->instate = XML_PARSER_CONTENT;
11246 if (ctxt->input->buf == NULL)
11247 avail = ctxt->input->length -
11248 (ctxt->input->cur - ctxt->input->base);
11250 avail = ctxt->input->buf->buffer->use -
11251 (ctxt->input->cur - ctxt->input->base);
11254 cur = ctxt->input->cur[0];
11255 next = ctxt->input->cur[1];
11258 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11264 xmlParsePI(ctxt);
11265 if (ctxt->instate == XML_PARSER_EOF)
11267 ctxt->checkIndex = 0;
11269 (ctxt->input->cur[2] == '-') &&
11270 (ctxt->input->cur[3] == '-')) {
11272 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
11278 xmlParseComment(ctxt);
11279 if (ctxt->instate == XML_PARSER_EOF)
11281 ctxt->instate = XML_PARSER_MISC;
11282 ctxt->checkIndex = 0;
11284 (ctxt->input->cur[2] == 'D') &&
11285 (ctxt->input->cur[3] == 'O') &&
11286 (ctxt->input->cur[4] == 'C') &&
11287 (ctxt->input->cur[5] == 'T') &&
11288 (ctxt->input->cur[6] == 'Y') &&
11289 (ctxt->input->cur[7] == 'P') &&
11290 (ctxt->input->cur[8] == 'E')) {
11292 (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0))
11298 ctxt->inSubset = 1;
11299 xmlParseDocTypeDecl(ctxt);
11300 if (ctxt->instate == XML_PARSER_EOF)
11303 ctxt->instate = XML_PARSER_DTD;
11312 ctxt->inSubset = 2;
11313 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11314 (ctxt->sax->externalSubset != NULL))
11315 ctxt->sax->externalSubset(ctxt->userData,
11316 ctxt->intSubName, ctxt->extSubSystem,
11317 ctxt->extSubURI);
11318 ctxt->inSubset = 0;
11319 xmlCleanSpecialAttr(ctxt);
11320 ctxt->instate = XML_PARSER_PROLOG;
11330 ctxt->instate = XML_PARSER_START_TAG;
11331 ctxt->progressive = 1;
11332 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11341 if (ctxt->input->buf == NULL)
11342 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
11344 avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
11347 cur = ctxt->input->cur[0];
11348 next = ctxt->input->cur[1];
11351 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11357 xmlParsePI(ctxt);
11358 if (ctxt->instate == XML_PARSER_EOF)
11361 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
11363 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
11369 xmlParseComment(ctxt);
11370 if (ctxt->instate == XML_PARSER_EOF)
11372 ctxt->instate = XML_PARSER_PROLOG;
11377 ctxt->instate = XML_PARSER_START_TAG;
11378 if (ctxt->progressive == 0)
11379 ctxt->progressive = 1;
11380 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11389 if (ctxt->input->buf == NULL)
11390 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
11392 avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
11395 cur = ctxt->input->cur[0];
11396 next = ctxt->input->cur[1];
11399 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11405 xmlParsePI(ctxt);
11406 if (ctxt->instate == XML_PARSER_EOF)
11408 ctxt->instate = XML_PARSER_EPILOG;
11410 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
11412 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
11418 xmlParseComment(ctxt);
11419 if (ctxt->instate == XML_PARSER_EOF)
11421 ctxt->instate = XML_PARSER_EPILOG;
11426 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
11427 ctxt->instate = XML_PARSER_EOF;
11432 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11433 ctxt->sax->endDocument(ctxt->userData);
11452 base = ctxt->input->cur - ctxt->input->base;
11454 if (ctxt->checkIndex > base)
11455 base = ctxt->checkIndex;
11456 buf = ctxt->input->buf->buffer->content;
11457 for (;(unsigned int) base < ctxt->input->buf->buffer->use;
11468 ctxt->input->buf->buffer->use) &&
11473 ctxt->input->buf->buffer->use; base++) {
11505 ctxt->input->buf->buffer->use)
11513 (unsigned int) base + i < ctxt->input->buf->buffer->use;
11548 xmlParseInternalSubset(ctxt);
11549 if (ctxt->instate == XML_PARSER_EOF)
11551 ctxt->inSubset = 2;
11552 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11553 (ctxt->sax->externalSubset != NULL))
11554 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
11555 ctxt->extSubSystem, ctxt->extSubURI);
11556 ctxt->inSubset = 0;
11557 xmlCleanSpecialAttr(ctxt);
11558 if (ctxt->instate == XML_PARSER_EOF)
11560 ctxt->instate = XML_PARSER_PROLOG;
11561 ctxt->checkIndex = 0;
11571 ctxt->instate = XML_PARSER_CONTENT;
11580 ctxt->instate = XML_PARSER_DTD;
11589 ctxt->instate = XML_PARSER_CONTENT;
11598 ctxt->instate = XML_PARSER_DTD;
11607 ctxt->instate = XML_PARSER_CONTENT;
11616 ctxt->instate = XML_PARSER_START_TAG;
11625 ctxt->instate = XML_PARSER_START_TAG;
11634 ctxt->instate = XML_PARSER_START_TAG;
11652 ctxt->input->cur[0], ctxt->input->cur[1],
11653 ctxt->input->cur[2], ctxt->input->cur[3]);
11654 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
11663 * @ctxt: an XML parser context
11673 xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
11678 if (ctxt == NULL)
11680 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
11681 return(ctxt->errNo);
11682 if (ctxt->instate == XML_PARSER_EOF)
11684 if (ctxt->instate == XML_PARSER_START)
11685 xmlDetectSAX2(ctxt);
11694 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
11695 (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF)) {
11696 int base = ctxt->input->base - ctxt->input->buf->buffer->content;
11697 int cur = ctxt->input->cur - ctxt->input->base;
11705 if ((ctxt->instate == XML_PARSER_START) && (ctxt->input != NULL) &&
11706 (ctxt->input->buf != NULL) && (ctxt->input->buf->encoder != NULL)) {
11709 if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
11711 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
11714 else if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
11716 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
11720 if (ctxt->input->buf->rawconsumed < len)
11721 len -= ctxt->input->buf->rawconsumed;
11735 res =xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
11737 ctxt->errNo = XML_PARSER_EOF;
11738 ctxt->disableSAX = 1;
11741 ctxt->input->base = ctxt->input->buf->buffer->content + base;
11742 ctxt->input->cur = ctxt->input->base + cur;
11743 ctxt->input->end =
11744 &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
11749 } else if (ctxt->instate != XML_PARSER_EOF) {
11750 if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
11751 xmlParserInputBufferPtr in = ctxt->input->buf;
11767 xmlParseTryOrFinish(ctxt, 0);
11769 xmlParseTryOrFinish(ctxt, terminate);
11770 if (ctxt->instate == XML_PARSER_EOF)
11771 return(ctxt->errNo);
11772 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
11773 return(ctxt->errNo);
11781 if ((end_in_lf == 1) && (ctxt->input != NULL) &&
11782 (ctxt->input->buf != NULL)) {
11783 xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
11791 if (ctxt->input != NULL) {
11792 if (ctxt->input->buf == NULL)
11793 avail = ctxt->input->length -
11794 (ctxt->input->cur - ctxt->input->base);
11796 avail = ctxt->input->buf->buffer->use -
11797 (ctxt->input->cur - ctxt->input->base);
11800 if ((ctxt->instate != XML_PARSER_EOF) &&
11801 (ctxt->instate != XML_PARSER_EPILOG)) {
11802 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
11804 if ((ctxt->instate == XML_PARSER_EPILOG) && (avail > 0)) {
11805 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
11807 if (ctxt->instate != XML_PARSER_EOF) {
11808 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11809 ctxt->sax->endDocument(ctxt->userData);
11811 ctxt->instate = XML_PARSER_EOF;
11813 return((xmlParserErrors) ctxt->errNo);
11844 xmlParserCtxtPtr ctxt;
11858 ctxt = xmlNewParserCtxt();
11859 if (ctxt == NULL) {
11864 ctxt->dictNames = 1;
11865 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * sizeof(xmlChar *));
11866 if (ctxt->pushTab == NULL) {
11867 xmlErrMemory(ctxt, NULL);
11869 xmlFreeParserCtxt(ctxt);
11874 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
11876 xmlFree(ctxt->sax);
11877 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
11878 if (ctxt->sax == NULL) {
11879 xmlErrMemory(ctxt, NULL);
11881 xmlFreeParserCtxt(ctxt);
11884 memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
11886 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
11888 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
11890 ctxt->userData = user_data;
11893 ctxt->directory = NULL;
11895 ctxt->directory = xmlParserGetDirectory(filename);
11898 inputStream = xmlNewInputStream(ctxt);
11900 xmlFreeParserCtxt(ctxt);
11911 xmlFreeParserCtxt(ctxt);
11922 inputPush(ctxt, inputStream);
11930 ctxt->charset = XML_CHAR_ENCODING_NONE;
11931 } else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) {
11932 int base = ctxt->input->base - ctxt->input->buf->buffer->content;
11933 int cur = ctxt->input->cur - ctxt->input->base;
11935 xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
11937 ctxt->input->base = ctxt->input->buf->buffer->content + base;
11938 ctxt->input->cur = ctxt->input->base + cur;
11939 ctxt->input->end =
11940 &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
11947 xmlSwitchEncoding(ctxt, enc);
11950 return(ctxt);
11956 * @ctxt: an XML parser context
11961 xmlStopParser(xmlParserCtxtPtr ctxt) {
11962 if (ctxt == NULL)
11964 ctxt->instate = XML_PARSER_EOF;
11965 ctxt->errNo = XML_ERR_USER_STOP;
11966 ctxt->disableSAX = 1;
11967 if (ctxt->input != NULL) {
11968 ctxt->input->cur = BAD_CAST"";
11969 ctxt->input->base = ctxt->input->cur;
11991 xmlParserCtxtPtr ctxt;
12000 ctxt = xmlNewParserCtxt();
12001 if (ctxt == NULL) {
12007 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12009 xmlFree(ctxt->sax);
12010 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
12011 if (ctxt->sax == NULL) {
12012 xmlErrMemory(ctxt, NULL);
12013 xmlFreeParserCtxt(ctxt);
12016 memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
12018 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
12020 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12022 ctxt->userData = user_data;
12025 inputStream = xmlNewIOInputStream(ctxt, buf, enc);
12027 xmlFreeParserCtxt(ctxt);
12030 inputPush(ctxt, inputStream);
12032 return(ctxt);
12058 xmlParserCtxtPtr ctxt;
12065 ctxt = xmlNewParserCtxt();
12066 if (ctxt == NULL) {
12075 if (ctxt->sax != NULL)
12076 xmlFree(ctxt->sax);
12077 ctxt->sax = sax;
12078 ctxt->userData = ctxt;
12080 xmlDetectSAX2(ctxt);
12086 pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
12088 if (sax != NULL) ctxt->sax = NULL;
12090 xmlFreeParserCtxt(ctxt);
12097 if (xmlPushInput(ctxt, pinput) < 0) {
12098 if (sax != NULL) ctxt->sax = NULL;
12099 xmlFreeParserCtxt(ctxt);
12103 xmlSwitchEncoding(ctxt, enc);
12109 pinput->base = ctxt->input->cur;
12110 pinput->cur = ctxt->input->cur;
12116 ctxt->inSubset = 2;
12117 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
12118 if (ctxt->myDoc == NULL) {
12119 xmlErrMemory(ctxt, "New Doc failed");
12122 ctxt->myDoc->properties = XML_DOC_INTERNAL;
12123 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
12127 ((ctxt->input->end - ctxt->input->cur) >= 4)) {
12139 xmlSwitchEncoding(ctxt, enc);
12143 xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
12145 if (ctxt->myDoc != NULL) {
12146 if (ctxt->wellFormed) {
12147 ret = ctxt->myDoc->extSubset;
12148 ctxt->myDoc->extSubset = NULL;
12162 xmlFreeDoc(ctxt->myDoc);
12163 ctxt->myDoc = NULL;
12165 if (sax != NULL) ctxt->sax = NULL;
12166 xmlFreeParserCtxt(ctxt);
12186 xmlParserCtxtPtr ctxt;
12193 ctxt = xmlNewParserCtxt();
12194 if (ctxt == NULL) {
12202 if (ctxt->sax != NULL)
12203 xmlFree(ctxt->sax);
12204 ctxt->sax = sax;
12205 ctxt->userData = ctxt;
12213 xmlFreeParserCtxt(ctxt);
12221 if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
12222 input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
12225 if (sax != NULL) ctxt->sax = NULL;
12226 xmlFreeParserCtxt(ctxt);
12235 if (xmlPushInput(ctxt, input) < 0) {
12236 if (sax != NULL) ctxt->sax = NULL;
12237 xmlFreeParserCtxt(ctxt);
12242 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
12243 enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
12244 xmlSwitchEncoding(ctxt, enc);
12253 input->base = ctxt->input->cur;
12254 input->cur = ctxt->input->cur;
12260 ctxt->inSubset = 2;
12261 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
12262 if (ctxt->myDoc == NULL) {
12263 xmlErrMemory(ctxt, "New Doc failed");
12264 if (sax != NULL) ctxt->sax = NULL;
12265 xmlFreeParserCtxt(ctxt);
12268 ctxt->myDoc->properties = XML_DOC_INTERNAL;
12269 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
12271 xmlParseExternalSubset(ctxt, ExternalID, SystemID);
12273 if (ctxt->myDoc != NULL) {
12274 if (ctxt->wellFormed) {
12275 ret = ctxt->myDoc->extSubset;
12276 ctxt->myDoc->extSubset = NULL;
12290 xmlFreeDoc(ctxt->myDoc);
12291 ctxt->myDoc = NULL;
12293 if (sax != NULL) ctxt->sax = NULL;
12294 xmlFreeParserCtxt(ctxt);
12342 xmlParserCtxtPtr ctxt;
12364 ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, ctx);
12365 if (ctxt == NULL) {
12369 oldsax = ctxt->sax;
12370 ctxt->sax = ctx->sax;
12371 xmlDetectSAX2(ctxt);
12374 xmlFreeParserCtxt(ctxt);
12391 ctxt->sax = oldsax;
12392 xmlFreeParserCtxt(ctxt);
12399 nodePush(ctxt, newDoc->children);
12401 ctxt->myDoc = newDoc;
12403 ctxt->myDoc = ctx->myDoc;
12413 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
12420 xmlSwitchEncoding(ctxt, enc);
12428 xmlParseTextDecl(ctxt);
12433 (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) {
12434 xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH,
12442 ctxt->instate = XML_PARSER_CONTENT;
12443 ctxt->validate = ctx->validate;
12444 ctxt->valid = ctx->valid;
12445 ctxt->loadsubset = ctx->loadsubset;
12446 ctxt->depth = ctx->depth + 1;
12447 ctxt->replaceEntities = ctx->replaceEntities;
12448 if (ctxt->validate) {
12449 ctxt->vctxt.error = ctx->vctxt.error;
12450 ctxt->vctxt.warning = ctx->vctxt.warning;
12452 ctxt->vctxt.error = NULL;
12453 ctxt->vctxt.warning = NULL;
12455 ctxt->vctxt.nodeTab = NULL;
12456 ctxt->vctxt.nodeNr = 0;
12457 ctxt->vctxt.nodeMax = 0;
12458 ctxt->vctxt.node = NULL;
12459 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
12460 ctxt->dict = ctx->dict;
12461 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
12462 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
12463 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
12464 ctxt->dictNames = ctx->dictNames;
12465 ctxt->attsDefault = ctx->attsDefault;
12466 ctxt->attsSpecial = ctx->attsSpecial;
12467 ctxt->linenumbers = ctx->linenumbers;
12469 xmlParseContent(ctxt);
12471 ctx->validate = ctxt->validate;
12472 ctx->valid = ctxt->valid;
12474 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12476 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12478 if (ctxt->node != newDoc->children) {
12479 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12482 if (!ctxt->wellFormed) {
12483 if (ctxt->errNo == 0)
12486 ret = ctxt->errNo;
12505 ctxt->sax = oldsax;
12506 ctxt->dict = NULL;
12507 ctxt->attsDefault = NULL;
12508 ctxt->attsSpecial = NULL;
12509 xmlFreeParserCtxt(ctxt);
12539 xmlParserCtxtPtr ctxt;
12561 ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, oldctxt);
12562 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
12563 ctxt->userData = ctxt;
12565 ctxt->_private = oldctxt->_private;
12566 ctxt->loadsubset = oldctxt->loadsubset;
12567 ctxt->validate = oldctxt->validate;
12568 ctxt->external = oldctxt->external;
12569 ctxt->record_info = oldctxt->record_info;
12570 ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
12571 ctxt->node_seq.length = oldctxt->node_seq.length;
12572 ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
12578 ctxt->_private = NULL;
12579 ctxt->validate = 0;
12580 ctxt->external = 2;
12581 ctxt->loadsubset = 0;
12584 oldsax = ctxt->sax;
12585 ctxt->sax = sax;
12587 ctxt->userData = user_data;
12589 xmlDetectSAX2(ctxt);
12592 ctxt->node_seq.maximum = 0;
12593 ctxt->node_seq.length = 0;
12594 ctxt->node_seq.buffer = NULL;
12595 xmlFreeParserCtxt(ctxt);
12610 ctxt->sax = oldsax;
12611 ctxt->node_seq.maximum = 0;
12612 ctxt->node_seq.length = 0;
12613 ctxt->node_seq.buffer = NULL;
12614 xmlFreeParserCtxt(ctxt);
12621 nodePush(ctxt, newDoc->children);
12622 ctxt->myDoc = doc;
12631 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
12638 xmlSwitchEncoding(ctxt, enc);
12646 xmlParseTextDecl(ctxt);
12649 ctxt->instate = XML_PARSER_CONTENT;
12650 ctxt->depth = depth;
12652 xmlParseContent(ctxt);
12655 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12657 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12659 if (ctxt->node != newDoc->children) {
12660 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12663 if (!ctxt->wellFormed) {
12664 if (ctxt->errNo == 0)
12667 ret = (xmlParserErrors)ctxt->errNo;
12692 oldctxt->nbentities += ctxt->nbentities;
12697 if (ctxt->input != NULL) {
12698 oldctxt->sizeentities += ctxt->input->consumed;
12699 oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base);
12704 if (ctxt->lastError.code != XML_ERR_OK)
12705 xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
12708 ctxt->sax = oldsax;
12709 oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
12710 oldctxt->node_seq.length = ctxt->node_seq.length;
12711 oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
12712 ctxt->node_seq.maximum = 0;
12713 ctxt->node_seq.length = 0;
12714 ctxt->node_seq.buffer = NULL;
12715 xmlFreeParserCtxt(ctxt);
12803 xmlParserCtxtPtr ctxt;
12828 ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
12829 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
12831 ctxt->userData = user_data;
12833 ctxt->userData = ctxt;
12834 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
12835 ctxt->dict = oldctxt->dict;
12836 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
12837 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
12838 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
12843 nsPush(ctxt, oldctxt->nsTab[i], oldctxt->nsTab[i+1]);
12847 oldsax = ctxt->sax;
12848 ctxt->sax = oldctxt->sax;
12849 xmlDetectSAX2(ctxt);
12850 ctxt->replaceEntities = oldctxt->replaceEntities;
12851 ctxt->options = oldctxt->options;
12853 ctxt->_private = oldctxt->_private;
12857 ctxt->sax = oldsax;
12858 ctxt->dict = NULL;
12859 xmlFreeParserCtxt(ctxt);
12863 newDoc->dict = ctxt->dict;
12865 ctxt->myDoc = newDoc;
12867 ctxt->myDoc = oldctxt->myDoc;
12868 content = ctxt->myDoc->children;
12869 last = ctxt->myDoc->last;
12871 newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
12873 ctxt->sax = oldsax;
12874 ctxt->dict = NULL;
12875 xmlFreeParserCtxt(ctxt);
12881 ctxt->myDoc->children = NULL;
12882 ctxt->myDoc->last = NULL;
12883 xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
12884 nodePush(ctxt, ctxt->myDoc->children);
12885 ctxt->instate = XML_PARSER_CONTENT;
12886 ctxt->depth = oldctxt->depth + 1;
12888 ctxt->validate = 0;
12889 ctxt->loadsubset = oldctxt->loadsubset;
12894 ctxt->loadsubset |= XML_SKIP_IDS;
12896 ctxt->dictNames = oldctxt->dictNames;
12897 ctxt->attsDefault = oldctxt->attsDefault;
12898 ctxt->attsSpecial = oldctxt->attsSpecial;
12900 xmlParseContent(ctxt);
12902 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12904 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12906 if (ctxt->node != ctxt->myDoc->children) {
12907 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12910 if (!ctxt->wellFormed) {
12911 if (ctxt->errNo == 0)
12914 ret = (xmlParserErrors)ctxt->errNo;
12926 cur = ctxt->myDoc->children->children;
12940 ctxt->myDoc->children->children = NULL;
12942 if (ctxt->myDoc != NULL) {
12943 xmlFreeNode(ctxt->myDoc->children);
12944 ctxt->myDoc->children = content;
12945 ctxt->myDoc->last = last;
12953 oldctxt->nbentities += ctxt->nbentities;
12958 if (ctxt->lastError.code != XML_ERR_OK)
12959 xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
12961 ctxt->sax = oldsax;
12962 ctxt->dict = NULL;
12963 ctxt->attsDefault = NULL;
12964 ctxt->attsSpecial = NULL;
12965 xmlFreeParserCtxt(ctxt);
12996 xmlParserCtxtPtr ctxt;
13041 ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
13044 ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
13055 if (ctxt == NULL)
13064 if (ctxt->dict != NULL)
13065 xmlDictFree(ctxt->dict);
13066 ctxt->dict = doc->dict;
13073 if (ctxt->encoding != NULL)
13074 xmlFree((xmlChar *) ctxt->encoding);
13075 ctxt->encoding = xmlStrdup((const xmlChar *) doc->encoding);
13079 xmlSwitchToEncoding(ctxt, hdlr);
13085 xmlCtxtUseOptionsInternal(ctxt, options, NULL);
13086 xmlDetectSAX2(ctxt);
13087 ctxt->myDoc = doc;
13091 xmlFreeParserCtxt(ctxt);
13097 nodePush(ctxt, node);
13107 if (ctxt->dict) {
13108 iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
13109 ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
13115 if (xmlGetNamespace(ctxt, iprefix) == NULL) {
13116 nsPush(ctxt, iprefix, ihref);
13123 ctxt->instate = XML_PARSER_CONTENT;
13126 if ((ctxt->validate) || (ctxt->replaceEntities != 0)) {
13130 ctxt->loadsubset |= XML_SKIP_IDS;
13135 __htmlParseContent(ctxt);
13138 xmlParseContent(ctxt);
13140 nsPop(ctxt, nsnr);
13142 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13144 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13146 if ((ctxt->node != NULL) && (ctxt->node != node)) {
13147 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13148 ctxt->wellFormed = 0;
13151 if (!ctxt->wellFormed) {
13152 if (ctxt->errNo == 0)
13155 ret = (xmlParserErrors)ctxt->errNo;
13190 ctxt->dict = NULL;
13191 xmlFreeParserCtxt(ctxt);
13229 xmlParserCtxtPtr ctxt;
13248 ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
13249 if (ctxt == NULL) return(-1);
13250 ctxt->userData = ctxt;
13252 oldsax = ctxt->sax;
13253 ctxt->sax = sax;
13255 ctxt->userData = user_data;
13259 xmlFreeParserCtxt(ctxt);
13264 xmlDictFree(ctxt->dict);
13265 ctxt->dict = doc->dict;
13266 xmlDictReference(ctxt->dict);
13267 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
13268 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
13269 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
13270 ctxt->dictNames = 1;
13272 xmlCtxtUseOptionsInternal(ctxt, XML_PARSE_NODICT, NULL);
13281 ctxt->sax = oldsax;
13282 xmlFreeParserCtxt(ctxt);
13289 nodePush(ctxt, newRoot);
13291 ctxt->myDoc = newDoc;
13293 ctxt->myDoc = newDoc;
13299 ctxt->instate = XML_PARSER_CONTENT;
13300 ctxt->depth = depth;
13305 ctxt->validate = 0;
13306 ctxt->loadsubset = 0;
13307 xmlDetectSAX2(ctxt);
13312 xmlParseContent(ctxt);
13316 xmlParseContent(ctxt);
13319 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13321 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13323 if (ctxt->node != newDoc->children) {
13324 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13327 if (!ctxt->wellFormed) {
13328 if (ctxt->errNo == 0)
13331 ret = ctxt->errNo;
13354 ctxt->sax = oldsax;
13355 xmlFreeParserCtxt(ctxt);
13383 xmlParserCtxtPtr ctxt;
13385 ctxt = xmlCreateFileParserCtxt(filename);
13386 if (ctxt == NULL) {
13390 if (ctxt->sax != NULL)
13391 xmlFree(ctxt->sax);
13392 ctxt->sax = sax;
13393 ctxt->userData = NULL;
13396 xmlParseExtParsedEnt(ctxt);
13398 if (ctxt->wellFormed)
13399 ret = ctxt->myDoc;
13402 xmlFreeDoc(ctxt->myDoc);
13403 ctxt->myDoc = NULL;
13406 ctxt->sax = NULL;
13407 xmlFreeParserCtxt(ctxt);
13447 xmlParserCtxtPtr ctxt;
13452 ctxt = xmlNewParserCtxt();
13453 if (ctxt == NULL) {
13458 ctxt->options = pctx->options;
13459 ctxt->_private = pctx->_private;
13465 inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
13467 xmlFreeParserCtxt(ctxt);
13471 inputPush(ctxt, inputStream);
13473 if ((ctxt->directory == NULL) && (directory == NULL))
13475 if ((ctxt->directory == NULL) && (directory != NULL))
13476 ctxt->directory = directory;
13478 inputStream = xmlLoadExternalEntity((char *)uri, (char *)ID, ctxt);
13481 xmlFreeParserCtxt(ctxt);
13485 inputPush(ctxt, inputStream);
13487 if ((ctxt->directory == NULL) && (directory == NULL))
13489 if ((ctxt->directory == NULL) && (directory != NULL))
13490 ctxt->directory = directory;
13493 return(ctxt);
13535 xmlParserCtxtPtr ctxt;
13539 ctxt = xmlNewParserCtxt();
13540 if (ctxt == NULL) {
13546 xmlCtxtUseOptionsInternal(ctxt, options, NULL);
13547 ctxt->linenumbers = 1;
13549 inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
13551 xmlFreeParserCtxt(ctxt);
13555 inputPush(ctxt, inputStream);
13556 if ((ctxt->directory == NULL) && (directory == NULL))
13558 if ((ctxt->directory == NULL) && (directory != NULL))
13559 ctxt->directory = directory;
13561 return(ctxt);
13604 xmlParserCtxtPtr ctxt;
13608 ctxt = xmlCreateFileParserCtxt(filename);
13609 if (ctxt == NULL) {
13613 if (ctxt->sax != NULL)
13614 xmlFree(ctxt->sax);
13615 ctxt->sax = sax;
13617 xmlDetectSAX2(ctxt);
13619 ctxt->_private = data;
13622 if (ctxt->directory == NULL)
13623 ctxt->directory = xmlParserGetDirectory(filename);
13625 ctxt->recovery = recovery;
13627 xmlParseDocument(ctxt);
13629 if ((ctxt->wellFormed) || recovery) {
13630 ret = ctxt->myDoc;
13632 if (ctxt->input->buf->compressed > 0)
13635 ret->compression = ctxt->input->buf->compressed;
13640 xmlFreeDoc(ctxt->myDoc);
13641 ctxt->myDoc = NULL;
13644 ctxt->sax = NULL;
13645 xmlFreeParserCtxt(ctxt);
13723 * @ctxt: an XML parser context
13732 xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
13737 if ((ctxt == NULL) || (buffer == NULL))
13740 input = xmlNewInputStream(ctxt);
13743 xmlClearParserCtxt(ctxt);
13747 xmlClearParserCtxt(ctxt);
13753 inputPush(ctxt, input);
13771 xmlParserCtxtPtr ctxt;
13773 ctxt = xmlCreateFileParserCtxt(filename);
13774 if (ctxt == NULL) return -1;
13775 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
13776 xmlFree(ctxt->sax);
13777 ctxt->sax = sax;
13778 xmlDetectSAX2(ctxt);
13781 ctxt->userData = user_data;
13783 xmlParseDocument(ctxt);
13785 if (ctxt->wellFormed)
13788 if (ctxt->errNo != 0)
13789 ret = ctxt->errNo;
13794 ctxt->sax = NULL;
13795 if (ctxt->myDoc != NULL) {
13796 xmlFreeDoc(ctxt->myDoc);
13797 ctxt->myDoc = NULL;
13799 xmlFreeParserCtxt(ctxt);
13822 xmlParserCtxtPtr ctxt;
13831 ctxt = xmlNewParserCtxt();
13832 if (ctxt == NULL)
13838 xmlFreeParserCtxt(ctxt);
13842 input = xmlNewInputStream(ctxt);
13845 xmlFreeParserCtxt(ctxt);
13855 inputPush(ctxt, input);
13856 return(ctxt);
13883 xmlParserCtxtPtr ctxt;
13887 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
13888 if (ctxt == NULL) return(NULL);
13890 if (ctxt->sax != NULL)
13891 xmlFree(ctxt->sax);
13892 ctxt->sax = sax;
13894 xmlDetectSAX2(ctxt);
13896 ctxt->_private=data;
13899 ctxt->recovery = recovery;
13901 xmlParseDocument(ctxt);
13903 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
13906 xmlFreeDoc(ctxt->myDoc);
13907 ctxt->myDoc = NULL;
13910 ctxt->sax = NULL;
13911 xmlFreeParserCtxt(ctxt);
13981 xmlParserCtxtPtr ctxt;
13985 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
13986 if (ctxt == NULL) return -1;
13987 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
13988 xmlFree(ctxt->sax);
13989 ctxt->sax = sax;
13990 xmlDetectSAX2(ctxt);
13993 ctxt->userData = user_data;
13995 xmlParseDocument(ctxt);
13997 if (ctxt->wellFormed)
14000 if (ctxt->errNo != 0)
14001 ret = ctxt->errNo;
14006 ctxt->sax = NULL;
14007 if (ctxt->myDoc != NULL) {
14008 xmlFreeDoc(ctxt->myDoc);
14009 ctxt->myDoc = NULL;
14011 xmlFreeParserCtxt(ctxt);
14053 xmlParserCtxtPtr ctxt;
14059 ctxt = xmlCreateDocParserCtxt(cur);
14060 if (ctxt == NULL) return(NULL);
14062 oldsax = ctxt->sax;
14063 ctxt->sax = sax;
14064 ctxt->userData = NULL;
14066 xmlDetectSAX2(ctxt);
14068 xmlParseDocument(ctxt);
14069 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
14072 xmlFreeDoc(ctxt->myDoc);
14073 ctxt->myDoc = NULL;
14076 ctxt->sax = oldsax;
14077 xmlFreeParserCtxt(ctxt);
14261 * @ctxt: an XML parser context
14266 xmlCtxtReset(xmlParserCtxtPtr ctxt)
14271 if (ctxt == NULL)
14274 dict = ctxt->dict;
14276 while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
14279 ctxt->inputNr = 0;
14280 ctxt->input = NULL;
14282 ctxt->spaceNr = 0;
14283 if (ctxt->spaceTab != NULL) {
14284 ctxt->spaceTab[0] = -1;
14285 ctxt->space = &ctxt->spaceTab[0];
14287 ctxt->space = NULL;
14291 ctxt->nodeNr = 0;
14292 ctxt->node = NULL;
14294 ctxt->nameNr = 0;
14295 ctxt->name = NULL;
14297 DICT_FREE(ctxt->version);
14298 ctxt->version = NULL;
14299 DICT_FREE(ctxt->encoding);
14300 ctxt->encoding = NULL;
14301 DICT_FREE(ctxt->directory);
14302 ctxt->directory = NULL;
14303 DICT_FREE(ctxt->extSubURI);
14304 ctxt->extSubURI = NULL;
14305 DICT_FREE(ctxt->extSubSystem);
14306 ctxt->extSubSystem = NULL;
14307 if (ctxt->myDoc != NULL)
14308 xmlFreeDoc(ctxt->myDoc);
14309 ctxt->myDoc = NULL;
14311 ctxt->standalone = -1;
14312 ctxt->hasExternalSubset = 0;
14313 ctxt->hasPErefs = 0;
14314 ctxt->html = 0;
14315 ctxt->external = 0;
14316 ctxt->instate = XML_PARSER_START;
14317 ctxt->token = 0;
14319 ctxt->wellFormed = 1;
14320 ctxt->nsWellFormed = 1;
14321 ctxt->disableSAX = 0;
14322 ctxt->valid = 1;
14324 ctxt->vctxt.userData = ctxt;
14325 ctxt->vctxt.error = xmlParserValidityError;
14326 ctxt->vctxt.warning = xmlParserValidityWarning;
14328 ctxt->record_info = 0;
14329 ctxt->nbChars = 0;
14330 ctxt->checkIndex = 0;
14331 ctxt->inSubset = 0;
14332 ctxt->errNo = XML_ERR_OK;
14333 ctxt->depth = 0;
14334 ctxt->charset = XML_CHAR_ENCODING_UTF8;
14335 ctxt->catalogs = NULL;
14336 ctxt->nbentities = 0;
14337 ctxt->sizeentities = 0;
14338 xmlInitNodeInfoSeq(&ctxt->node_seq);
14340 if (ctxt->attsDefault != NULL) {
14341 xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
14342 ctxt->attsDefault = NULL;
14344 if (ctxt->attsSpecial != NULL) {
14345 xmlHashFree(ctxt->attsSpecial, NULL);
14346 ctxt->attsSpecial = NULL;
14350 if (ctxt->catalogs != NULL)
14351 xmlCatalogFreeLocal(ctxt->catalogs);
14353 if (ctxt->lastError.code != XML_ERR_OK)
14354 xmlResetError(&ctxt->lastError);
14359 * @ctxt: an XML parser context
14370 xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
14377 if (ctxt == NULL)
14387 if (ctxt == NULL) {
14392 xmlCtxtReset(ctxt);
14394 if (ctxt->pushTab == NULL) {
14395 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 *
14397 if (ctxt->pushTab == NULL) {
14398 xmlErrMemory(ctxt, NULL);
14405 ctxt->directory = NULL;
14407 ctxt->directory = xmlParserGetDirectory(filename);
14410 inputStream = xmlNewInputStream(ctxt);
14427 inputPush(ctxt, inputStream);
14429 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
14430 (ctxt->input->buf != NULL)) {
14431 int base = ctxt->input->base - ctxt->input->buf->buffer->content;
14432 int cur = ctxt->input->cur - ctxt->input->base;
14434 xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
14436 ctxt->input->base = ctxt->input->buf->buffer->content + base;
14437 ctxt->input->cur = ctxt->input->base + cur;
14438 ctxt->input->end =
14439 &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->
14449 if (ctxt->encoding != NULL)
14450 xmlFree((xmlChar *) ctxt->encoding);
14451 ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
14455 xmlSwitchToEncoding(ctxt, hdlr);
14457 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
14461 xmlSwitchEncoding(ctxt, enc);
14470 * @ctxt: an XML parser context
14480 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, const char *encoding)
14482 if (ctxt == NULL)
14485 if (ctxt->encoding != NULL)
14486 xmlFree((xmlChar *) ctxt->encoding);
14487 ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
14490 ctxt->recovery = 1;
14492 ctxt->options |= XML_PARSE_RECOVER;
14494 ctxt->recovery = 0;
14496 ctxt->loadsubset = XML_DETECT_IDS;
14498 ctxt->options |= XML_PARSE_DTDLOAD;
14500 ctxt->loadsubset = 0;
14502 ctxt->loadsubset |= XML_COMPLETE_ATTRS;
14504 ctxt->options |= XML_PARSE_DTDATTR;
14507 ctxt->replaceEntities = 1;
14508 /* ctxt->loadsubset |= XML_DETECT_IDS; */
14510 ctxt->options |= XML_PARSE_NOENT;
14512 ctxt->replaceEntities = 0;
14514 ctxt->pedantic = 1;
14516 ctxt->options |= XML_PARSE_PEDANTIC;
14518 ctxt->pedantic = 0;
14520 ctxt->keepBlanks = 0;
14521 ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
14523 ctxt->options |= XML_PARSE_NOBLANKS;
14525 ctxt->keepBlanks = 1;
14527 ctxt->validate = 1;
14529 ctxt->vctxt.warning = NULL;
14531 ctxt->vctxt.error = NULL;
14533 ctxt->options |= XML_PARSE_DTDVALID;
14535 ctxt->validate = 0;
14537 ctxt->sax->warning = NULL;
14541 ctxt->sax->error = NULL;
14542 ctxt->sax->fatalError = NULL;
14547 ctxt->sax->startElement = xmlSAX2StartElement;
14548 ctxt->sax->endElement = xmlSAX2EndElement;
14549 ctxt->sax->startElementNs = NULL;
14550 ctxt->sax->endElementNs = NULL;
14551 ctxt->sax->initialized = 1;
14553 ctxt->options |= XML_PARSE_SAX1;
14557 ctxt->dictNames = 0;
14559 ctxt->options |= XML_PARSE_NODICT;
14561 ctxt->dictNames = 1;
14564 ctxt->sax->cdataBlock = NULL;
14566 ctxt->options |= XML_PARSE_NOCDATA;
14569 ctxt->options |= XML_PARSE_NSCLEAN;
14573 ctxt->options |= XML_PARSE_NONET;
14577 ctxt->options |= XML_PARSE_COMPACT;
14581 ctxt->options |= XML_PARSE_OLD10;
14585 ctxt->options |= XML_PARSE_NOBASEFIX;
14589 ctxt->options |= XML_PARSE_HUGE;
14593 ctxt->options |= XML_PARSE_OLDSAX;
14596 ctxt->linenumbers = 1;
14602 * @ctxt: an XML parser context
14611 xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
14613 return(xmlCtxtUseOptionsInternal(ctxt, options, NULL));
14618 * @ctxt: an XML parser context
14629 xmlDoRead(xmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
14634 xmlCtxtUseOptionsInternal(ctxt, options, encoding);
14640 xmlSwitchToEncoding(ctxt, hdlr);
14642 if ((URL != NULL) && (ctxt->input != NULL) &&
14643 (ctxt->input->filename == NULL))
14644 ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
14645 xmlParseDocument(ctxt);
14646 if ((ctxt->wellFormed) || ctxt->recovery)
14647 ret = ctxt->myDoc;
14650 if (ctxt->myDoc != NULL) {
14651 xmlFreeDoc(ctxt->myDoc);
14654 ctxt->myDoc = NULL;
14656 xmlFreeParserCtxt(ctxt);
14676 xmlParserCtxtPtr ctxt;
14681 ctxt = xmlCreateDocParserCtxt(cur);
14682 if (ctxt == NULL)
14684 return (xmlDoRead(ctxt, URL, encoding, options, 0));
14700 xmlParserCtxtPtr ctxt;
14702 ctxt = xmlCreateURLParserCtxt(filename, options);
14703 if (ctxt == NULL)
14705 return (xmlDoRead(ctxt, NULL, encoding, options, 0));
14723 xmlParserCtxtPtr ctxt;
14725 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
14726 if (ctxt == NULL)
14728 return (xmlDoRead(ctxt, URL, encoding, options, 0));
14747 xmlParserCtxtPtr ctxt;
14758 ctxt = xmlNewParserCtxt();
14759 if (ctxt == NULL) {
14763 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
14766 xmlFreeParserCtxt(ctxt);
14769 inputPush(ctxt, stream);
14770 return (xmlDoRead(ctxt, URL, encoding, options, 0));
14790 xmlParserCtxtPtr ctxt;
14801 ctxt = xmlNewParserCtxt();
14802 if (ctxt == NULL) {
14806 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
14809 xmlFreeParserCtxt(ctxt);
14812 inputPush(ctxt, stream);
14813 return (xmlDoRead(ctxt, URL, encoding, options, 0));
14818 * @ctxt: an XML parser context
14825 * This reuses the existing @ctxt parser context
14830 xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
14837 if (ctxt == NULL)
14840 xmlCtxtReset(ctxt);
14842 stream = xmlNewStringInputStream(ctxt, cur);
14846 inputPush(ctxt, stream);
14847 return (xmlDoRead(ctxt, URL, encoding, options, 1));
14852 * @ctxt: an XML parser context
14858 * This reuses the existing @ctxt parser context
14863 xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
14870 if (ctxt == NULL)
14873 xmlCtxtReset(ctxt);
14875 stream = xmlLoadExternalEntity(filename, NULL, ctxt);
14879 inputPush(ctxt, stream);
14880 return (xmlDoRead(ctxt, NULL, encoding, options, 1));
14885 * @ctxt: an XML parser context
14893 * This reuses the existing @ctxt parser context
14898 xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
14904 if (ctxt == NULL)
14909 xmlCtxtReset(ctxt);
14916 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
14922 inputPush(ctxt, stream);
14923 return (xmlDoRead(ctxt, URL, encoding, options, 1));
14928 * @ctxt: an XML parser context
14935 * This reuses the existing @ctxt parser context
14942 xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
14950 if (ctxt == NULL)
14953 xmlCtxtReset(ctxt);
14960 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
14965 inputPush(ctxt, stream);
14966 return (xmlDoRead(ctxt, URL, encoding, options, 1));
14971 * @ctxt: an XML parser context
14980 * This reuses the existing @ctxt parser context
14985 xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
14995 if (ctxt == NULL)
14998 xmlCtxtReset(ctxt);
15004 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15009 inputPush(ctxt, stream);
15010 return (xmlDoRead(ctxt, URL, encoding, options, 1));