Lines Matching refs:ctxt
91 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info);
97 static void xmlHaltParser(xmlParserCtxtPtr ctxt);
126 xmlParserEntityCheck(xmlParserCtxtPtr ctxt, size_t size,
131 if ((ctxt == NULL) || (ctxt->options & XML_PARSE_HUGE))
133 if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
142 (ctxt->errNo != XML_ERR_ENTITY_LOOP)) {
143 unsigned long oldnbent = ctxt->nbentities;
148 ++ctxt->depth;
149 rep = xmlStringDecodeEntities(ctxt, ent->content,
151 --ctxt->depth;
152 if (ctxt->errNo == XML_ERR_ENTITY_LOOP) {
156 ent->checked = (ctxt->nbentities - oldnbent + 1) * 2;
173 if (ctxt->input != NULL) {
174 consumed = ctxt->input->consumed +
175 (ctxt->input->cur - ctxt->input->base);
177 consumed += ctxt->sizeentities;
191 if (ctxt->input != NULL) {
192 consumed = ctxt->input->consumed +
193 (ctxt->input->cur - ctxt->input->base);
195 consumed += ctxt->sizeentities;
198 (ctxt->nbentities * 3 < XML_PARSER_NON_LINEAR * consumed))
209 if (ctxt->input != NULL) {
210 consumed = ctxt->input->consumed +
211 (ctxt->input->cur - ctxt->input->base);
213 consumed += ctxt->sizeentities;
225 if (((ctxt->lastError.code != XML_ERR_UNDECLARED_ENTITY) &&
226 (ctxt->lastError.code != XML_WAR_UNDECLARED_ENTITY)) ||
227 (ctxt->nbentities <= 10000))
230 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
273 /* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
274 static xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
284 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options,
297 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity);
307 * @ctxt: an XML parser context
314 xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
317 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
318 (ctxt->instate == XML_PARSER_EOF))
320 if (ctxt != NULL)
321 ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
324 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
329 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
334 if (ctxt != NULL) {
335 ctxt->wellFormed = 0;
336 if (ctxt->recovery == 0)
337 ctxt->disableSAX = 1;
343 * @ctxt: an XML parser context
350 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)
354 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
355 (ctxt->instate == XML_PARSER_EOF))
539 if (ctxt != NULL)
540 ctxt->errNo = error;
542 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
546 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
550 if (ctxt != NULL) {
551 ctxt->wellFormed = 0;
552 if (ctxt->recovery == 0)
553 ctxt->disableSAX = 1;
559 * @ctxt: an XML parser context
566 xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
569 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
570 (ctxt->instate == XML_PARSER_EOF))
572 if (ctxt != NULL)
573 ctxt->errNo = error;
574 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
576 if (ctxt != NULL) {
577 ctxt->wellFormed = 0;
578 if (ctxt->recovery == 0)
579 ctxt->disableSAX = 1;
585 * @ctxt: an XML parser context
594 xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
599 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
600 (ctxt->instate == XML_PARSER_EOF))
602 if ((ctxt != NULL) && (ctxt->sax != NULL) &&
603 (ctxt->sax->initialized == XML_SAX2_MAGIC))
604 schannel = ctxt->sax->serror;
605 if (ctxt != NULL) {
607 (ctxt->sax) ? ctxt->sax->warning : NULL,
608 ctxt->userData,
609 ctxt, NULL, XML_FROM_PARSER, error,
615 ctxt, NULL, XML_FROM_PARSER, error,
624 * @ctxt: an XML parser context
632 xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
637 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
638 (ctxt->instate == XML_PARSER_EOF))
640 if (ctxt != NULL) {
641 ctxt->errNo = error;
642 if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
643 schannel = ctxt->sax->serror;
645 if (ctxt != NULL) {
647 ctxt->vctxt.error, ctxt->vctxt.userData,
648 ctxt, NULL, XML_FROM_DTD, error,
652 ctxt->valid = 0;
655 ctxt, NULL, XML_FROM_DTD, error,
664 * @ctxt: an XML parser context
672 xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
675 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
676 (ctxt->instate == XML_PARSER_EOF))
678 if (ctxt != NULL)
679 ctxt->errNo = error;
681 ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
683 if (ctxt != NULL) {
684 ctxt->wellFormed = 0;
685 if (ctxt->recovery == 0)
686 ctxt->disableSAX = 1;
692 * @ctxt: an XML parser context
702 xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
706 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
707 (ctxt->instate == XML_PARSER_EOF))
709 if (ctxt != NULL)
710 ctxt->errNo = error;
712 ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
715 if (ctxt != NULL) {
716 ctxt->wellFormed = 0;
717 if (ctxt->recovery == 0)
718 ctxt->disableSAX = 1;
724 * @ctxt: an XML parser context
732 xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
735 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
736 (ctxt->instate == XML_PARSER_EOF))
738 if (ctxt != NULL)
739 ctxt->errNo = error;
740 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
744 if (ctxt != NULL) {
745 ctxt->wellFormed = 0;
746 if (ctxt->recovery == 0)
747 ctxt->disableSAX = 1;
753 * @ctxt: an XML parser context
761 xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
764 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
765 (ctxt->instate == XML_PARSER_EOF))
767 if (ctxt != NULL)
768 ctxt->errNo = error;
769 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
777 * @ctxt: an XML parser context
786 xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
791 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
792 (ctxt->instate == XML_PARSER_EOF))
794 if (ctxt != NULL)
795 ctxt->errNo = error;
796 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
800 if (ctxt != NULL)
801 ctxt->nsWellFormed = 0;
806 * @ctxt: an XML parser context
815 xmlNsWarn(xmlParserCtxtPtr ctxt, xmlParserErrors error,
820 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
821 (ctxt->instate == XML_PARSER_EOF))
823 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
1061 * @ctxt: an XML parser context
1066 xmlDetectSAX2(xmlParserCtxtPtr ctxt) {
1067 if (ctxt == NULL) return;
1069 if ((ctxt->sax) && (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
1070 ((ctxt->sax->startElementNs != NULL) ||
1071 (ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1;
1073 ctxt->sax2 = 1;
1076 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
1077 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
1078 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
1079 if ((ctxt->str_xml==NULL) || (ctxt->str_xmlns==NULL) ||
1080 (ctxt->str_xml_ns == NULL)) {
1081 xmlErrMemory(ctxt, NULL);
1144 xmlAttrNormalizeSpace2(xmlParserCtxtPtr ctxt, xmlChar *src, int *len)
1151 if ((ctxt == NULL) || (src == NULL) || (len == NULL))
1177 xmlErrMemory(ctxt, NULL);
1193 * @ctxt: an XML parser context
1201 xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
1213 if (ctxt->attsSpecial != NULL) {
1214 if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1218 if (ctxt->attsDefault == NULL) {
1219 ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
1220 if (ctxt->attsDefault == NULL)
1230 name = xmlDictLookup(ctxt->dict, fullname, -1);
1233 name = xmlDictLookup(ctxt->dict, name, -1);
1234 prefix = xmlDictLookup(ctxt->dict, fullname, len);
1240 defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
1248 if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1262 if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1275 name = xmlDictLookup(ctxt->dict, fullattr, -1);
1278 name = xmlDictLookup(ctxt->dict, name, -1);
1279 prefix = xmlDictLookup(ctxt->dict, fullattr, len);
1286 value = xmlDictLookup(ctxt->dict, value, len);
1289 if (ctxt->external)
1298 xmlErrMemory(ctxt, NULL);
1304 * @ctxt: an XML parser context
1312 xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
1317 if (ctxt->attsSpecial == NULL) {
1318 ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
1319 if (ctxt->attsSpecial == NULL)
1323 if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1326 xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
1331 xmlErrMemory(ctxt, NULL);
1344 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data;
1347 xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL);
1353 * @ctxt: an XML parser context
1360 xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt)
1362 if (ctxt->attsSpecial == NULL)
1365 xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt);
1367 if (xmlHashSize(ctxt->attsSpecial) == 0) {
1368 xmlHashFree(ctxt->attsSpecial, NULL);
1369 ctxt->attsSpecial = NULL;
1574 static xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
1580 * @ctxt: an XML parser context
1590 nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL)
1592 if (ctxt->options & XML_PARSE_NSCLEAN) {
1594 for (i = ctxt->nsNr - 2;i >= 0;i -= 2) {
1595 if (ctxt->nsTab[i] == prefix) {
1597 if (ctxt->nsTab[i + 1] == URL)
1604 if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) {
1605 ctxt->nsMax = 10;
1606 ctxt->nsNr = 0;
1607 ctxt->nsTab = (const xmlChar **)
1608 xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
1609 if (ctxt->nsTab == NULL) {
1610 xmlErrMemory(ctxt, NULL);
1611 ctxt->nsMax = 0;
1614 } else if (ctxt->nsNr >= ctxt->nsMax) {
1616 ctxt->nsMax *= 2;
1617 tmp = (const xmlChar **) xmlRealloc((char *) ctxt->nsTab,
1618 ctxt->nsMax * sizeof(ctxt->nsTab[0]));
1620 xmlErrMemory(ctxt, NULL);
1621 ctxt->nsMax /= 2;
1624 ctxt->nsTab = tmp;
1626 ctxt->nsTab[ctxt->nsNr++] = prefix;
1627 ctxt->nsTab[ctxt->nsNr++] = URL;
1628 return (ctxt->nsNr);
1632 * @ctxt: an XML parser context
1640 nsPop(xmlParserCtxtPtr ctxt, int nr)
1644 if (ctxt->nsTab == NULL) return(0);
1645 if (ctxt->nsNr < nr) {
1647 nr = ctxt->nsNr;
1649 if (ctxt->nsNr <= 0)
1653 ctxt->nsNr--;
1654 ctxt->nsTab[ctxt->nsNr] = NULL;
1661 xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
1666 if (ctxt->atts == NULL) {
1671 ctxt->atts = atts;
1674 ctxt->attallocs = attallocs;
1675 ctxt->maxatts = maxatts;
1676 } else if (nr + 5 > ctxt->maxatts) {
1678 atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts,
1681 ctxt->atts = atts;
1682 attallocs = (int *) xmlRealloc((void *) ctxt->attallocs,
1685 ctxt->attallocs = attallocs;
1686 ctxt->maxatts = maxatts;
1688 return(ctxt->maxatts);
1690 xmlErrMemory(ctxt, NULL);
1696 * @ctxt: an XML parser context
1704 inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
1706 if ((ctxt == NULL) || (value == NULL))
1708 if (ctxt->inputNr >= ctxt->inputMax) {
1709 ctxt->inputMax *= 2;
1710 ctxt->inputTab =
1711 (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
1712 ctxt->inputMax *
1713 sizeof(ctxt->inputTab[0]));
1714 if (ctxt->inputTab == NULL) {
1715 xmlErrMemory(ctxt, NULL);
1717 ctxt->inputMax /= 2;
1722 ctxt->inputTab[ctxt->inputNr] = value;
1723 ctxt->input = value;
1724 return (ctxt->inputNr++);
1728 * @ctxt: an XML parser context
1735 inputPop(xmlParserCtxtPtr ctxt)
1739 if (ctxt == NULL)
1741 if (ctxt->inputNr <= 0)
1743 ctxt->inputNr--;
1744 if (ctxt->inputNr > 0)
1745 ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
1747 ctxt->input = NULL;
1748 ret = ctxt->inputTab[ctxt->inputNr];
1749 ctxt->inputTab[ctxt->inputNr] = NULL;
1754 * @ctxt: an XML parser context
1762 nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
1764 if (ctxt == NULL) return(0);
1765 if (ctxt->nodeNr >= ctxt->nodeMax) {
1768 tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
1769 ctxt->nodeMax * 2 *
1770 sizeof(ctxt->nodeTab[0]));
1772 xmlErrMemory(ctxt, NULL);
1775 ctxt->nodeTab = tmp;
1776 ctxt->nodeMax *= 2;
1778 if ((((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) &&
1779 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
1780 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
1783 xmlHaltParser(ctxt);
1786 ctxt->nodeTab[ctxt->nodeNr] = value;
1787 ctxt->node = value;
1788 return (ctxt->nodeNr++);
1793 * @ctxt: an XML parser context
1800 nodePop(xmlParserCtxtPtr ctxt)
1804 if (ctxt == NULL) return(NULL);
1805 if (ctxt->nodeNr <= 0)
1807 ctxt->nodeNr--;
1808 if (ctxt->nodeNr > 0)
1809 ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
1811 ctxt->node = NULL;
1812 ret = ctxt->nodeTab[ctxt->nodeNr];
1813 ctxt->nodeTab[ctxt->nodeNr] = NULL;
1820 * @ctxt: an XML parser context
1830 nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
1833 if (ctxt->nameNr >= ctxt->nameMax) {
1836 ctxt->nameMax *= 2;
1837 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1838 ctxt->nameMax *
1839 sizeof(ctxt->nameTab[0]));
1841 ctxt->nameMax /= 2;
1844 ctxt->nameTab = tmp;
1845 tmp2 = (void **) xmlRealloc((void * *)ctxt->pushTab,
1846 ctxt->nameMax * 3 *
1847 sizeof(ctxt->pushTab[0]));
1849 ctxt->nameMax /= 2;
1852 ctxt->pushTab = tmp2;
1854 ctxt->nameTab[ctxt->nameNr] = value;
1855 ctxt->name = value;
1856 ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix;
1857 ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI;
1858 ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr;
1859 return (ctxt->nameNr++);
1861 xmlErrMemory(ctxt, NULL);
1866 * @ctxt: an XML parser context
1873 nameNsPop(xmlParserCtxtPtr ctxt)
1877 if (ctxt->nameNr <= 0)
1879 ctxt->nameNr--;
1880 if (ctxt->nameNr > 0)
1881 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1883 ctxt->name = NULL;
1884 ret = ctxt->nameTab[ctxt->nameNr];
1885 ctxt->nameTab[ctxt->nameNr] = NULL;
1892 * @ctxt: an XML parser context
1900 namePush(xmlParserCtxtPtr ctxt, const xmlChar * value)
1902 if (ctxt == NULL) return (-1);
1904 if (ctxt->nameNr >= ctxt->nameMax) {
1906 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1907 ctxt->nameMax * 2 *
1908 sizeof(ctxt->nameTab[0]));
1912 ctxt->nameTab = tmp;
1913 ctxt->nameMax *= 2;
1915 ctxt->nameTab[ctxt->nameNr] = value;
1916 ctxt->name = value;
1917 return (ctxt->nameNr++);
1919 xmlErrMemory(ctxt, NULL);
1924 * @ctxt: an XML parser context
1931 namePop(xmlParserCtxtPtr ctxt)
1935 if ((ctxt == NULL) || (ctxt->nameNr <= 0))
1937 ctxt->nameNr--;
1938 if (ctxt->nameNr > 0)
1939 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1941 ctxt->name = NULL;
1942 ret = ctxt->nameTab[ctxt->nameNr];
1943 ctxt->nameTab[ctxt->nameNr] = NULL;
1947 static int spacePush(xmlParserCtxtPtr ctxt, int val) {
1948 if (ctxt->spaceNr >= ctxt->spaceMax) {
1951 ctxt->spaceMax *= 2;
1952 tmp = (int *) xmlRealloc(ctxt->spaceTab,
1953 ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
1955 xmlErrMemory(ctxt, NULL);
1956 ctxt->spaceMax /=2;
1959 ctxt->spaceTab = tmp;
1961 ctxt->spaceTab[ctxt->spaceNr] = val;
1962 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
1963 return(ctxt->spaceNr++);
1966 static int spacePop(xmlParserCtxtPtr ctxt) {
1968 if (ctxt->spaceNr <= 0) return(0);
1969 ctxt->spaceNr--;
1970 if (ctxt->spaceNr > 0)
1971 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
1973 ctxt->space = &ctxt->spaceTab[0];
1974 ret = ctxt->spaceTab[ctxt->spaceNr];
1975 ctxt->spaceTab[ctxt->spaceNr] = -1;
2014 #define RAW (*ctxt->input->cur)
2015 #define CUR (*ctxt->input->cur)
2016 #define NXT(val) ctxt->input->cur[(val)]
2017 #define CUR_PTR ctxt->input->cur
2018 #define BASE_PTR ctxt->input->base
2039 ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val); \
2040 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
2041 if ((*ctxt->input->cur == 0) && \
2042 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
2043 xmlPopInput(ctxt); \
2049 if (*(ctxt->input->cur) == '\n') { \
2050 ctxt->input->line++; ctxt->input->col = 1; \
2051 } else ctxt->input->col++; \
2052 ctxt->nbChars++; \
2053 ctxt->input->cur++; \
2055 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
2056 if ((*ctxt->input->cur == 0) && \
2057 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
2058 xmlPopInput(ctxt); \
2061 #define SHRINK if ((ctxt->progressive == 0) && \
2062 (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
2063 (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
2064 xmlSHRINK (ctxt);
2066 static void xmlSHRINK (xmlParserCtxtPtr ctxt) {
2067 xmlParserInputShrink(ctxt->input);
2068 if ((*ctxt->input->cur == 0) &&
2069 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2070 xmlPopInput(ctxt);
2073 #define GROW if ((ctxt->progressive == 0) && \
2074 (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \
2075 xmlGROW (ctxt);
2077 static void xmlGROW (xmlParserCtxtPtr ctxt) {
2078 unsigned long curEnd = ctxt->input->end - ctxt->input->cur;
2079 unsigned long curBase = ctxt->input->cur - ctxt->input->base;
2083 ((ctxt->input->buf) && (ctxt->input->buf->readcallback != (xmlInputReadCallback) xmlNop)) &&
2084 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
2085 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "Huge input lookup");
2086 xmlHaltParser(ctxt);
2089 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2090 if ((ctxt->input->cur > ctxt->input->end) ||
2091 (ctxt->input->cur < ctxt->input->base)) {
2092 xmlHaltParser(ctxt);
2093 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "cur index out of bound");
2096 if ((ctxt->input->cur != NULL) && (*ctxt->input->cur == 0) &&
2097 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2098 xmlPopInput(ctxt);
2101 #define SKIP_BLANKS xmlSkipBlankChars(ctxt)
2103 #define NEXT xmlNextChar(ctxt)
2106 ctxt->input->col++; \
2107 ctxt->input->cur++; \
2108 ctxt->nbChars++; \
2109 if (*ctxt->input->cur == 0) \
2110 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); \
2114 if (*(ctxt->input->cur) == '\n') { \
2115 ctxt->input->line++; ctxt->input->col = 1; \
2116 } else ctxt->input->col++; \
2117 ctxt->input->cur += l; \
2118 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
2121 #define CUR_CHAR(l) xmlCurrentChar(ctxt, &l)
2122 #define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
2130 * @ctxt: the XML parser context
2139 xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
2146 if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) {
2151 cur = ctxt->input->cur;
2154 ctxt->input->line++; ctxt->input->col = 1;
2156 ctxt->input->col++;
2161 ctxt->input->cur = cur;
2162 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2163 cur = ctxt->input->cur;
2166 ctxt->input->cur = cur;
2172 (ctxt->instate != XML_PARSER_EOF))) {
2177 while ((cur == 0) && (ctxt->inputNr > 1) &&
2178 (ctxt->instate != XML_PARSER_COMMENT)) {
2179 xmlPopInput(ctxt);
2185 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);
2187 (ctxt->instate != XML_PARSER_EOF));
2200 * @ctxt: an XML parser context
2202 * xmlPopInput: the current input pointed by ctxt->input came to an end
2208 xmlPopInput(xmlParserCtxtPtr ctxt) {
2209 if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0);
2212 "Popping input %d\n", ctxt->inputNr);
2213 xmlFreeInputStream(inputPop(ctxt));
2214 if ((*ctxt->input->cur == 0) &&
2215 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2216 return(xmlPopInput(ctxt));
2222 * @ctxt: an XML parser context
2230 xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
2235 if ((ctxt->input != NULL) && (ctxt->input->filename))
2237 "%s(%d): ", ctxt->input->filename,
2238 ctxt->input->line);
2240 "Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
2242 ret = inputPush(ctxt, input);
2243 if (ctxt->instate == XML_PARSER_EOF)
2251 * @ctxt: an XML parser context
2265 xmlParseCharRef(xmlParserCtxtPtr ctxt) {
2281 if (ctxt->instate == XML_PARSER_EOF)
2291 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2303 ctxt->input->col++;
2304 ctxt->nbChars ++;
2305 ctxt->input->cur++;
2314 if (ctxt->instate == XML_PARSER_EOF)
2320 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2332 ctxt->input->col++;
2333 ctxt->nbChars ++;
2334 ctxt->input->cur++;
2337 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2348 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2357 * @ctxt: an XML parser context
2374 xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
2394 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2413 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2426 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2439 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2448 * @ctxt: an XML parser context
2460 xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
2465 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
2472 input = xmlNewInputStream(ctxt);
2479 xmlErrMemory(ctxt, NULL);
2499 * @ctxt: the parser context
2530 xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
2536 switch(ctxt->instate) {
2546 xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
2551 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
2562 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
2581 if ((ctxt->external == 0) && (ctxt->inputNr == 1))
2591 name = xmlParseName(ctxt);
2596 xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL);
2600 if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL))
2601 entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
2602 if (ctxt->instate == XML_PARSER_EOF)
2614 if ((ctxt->standalone == 1) ||
2615 ((ctxt->hasExternalSubset == 0) &&
2616 (ctxt->hasPErefs == 0))) {
2617 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
2627 if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
2628 xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
2632 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
2635 ctxt->valid = 0;
2637 xmlParserEntityCheck(ctxt, 0, NULL, 0);
2638 } else if (ctxt->input->free != deallocblankswrapper) {
2639 input = xmlNewBlanksWrapperInputStream(ctxt, entity);
2640 if (xmlPushInput(ctxt, input) < 0)
2657 ((ctxt->options & XML_PARSE_NOENT) == 0) &&
2658 ((ctxt->options & XML_PARSE_DTDVALID) == 0) &&
2659 ((ctxt->options & XML_PARSE_DTDLOAD) == 0) &&
2660 ((ctxt->options & XML_PARSE_DTDATTR) == 0) &&
2661 (ctxt->replaceEntities == 0) &&
2662 (ctxt->validate == 0))
2670 input = xmlNewEntityInputStream(ctxt, entity);
2671 if (xmlPushInput(ctxt, input) < 0)
2684 if (ctxt->instate == XML_PARSER_EOF)
2686 if ((ctxt->input->end - ctxt->input->cur)>=4) {
2693 xmlSwitchEncoding(ctxt, enc);
2700 xmlParseTextDecl(ctxt);
2703 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
2709 xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
2731 * @ctxt: the parser context
2749 xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2761 if ((ctxt == NULL) || (str == NULL) || (len < 0))
2765 if (((ctxt->depth > 40) &&
2766 ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
2767 (ctxt->depth > 1024)) {
2768 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
2792 int val = xmlParseStringCharRef(ctxt, &str);
2804 ent = xmlParseStringEntityRef(ctxt, &str);
2805 if ((ctxt
2806 (ctxt->lastError.code == XML_ERR_INTERNAL_ERROR))
2808 xmlParserEntityCheck(ctxt, 0, ent, 0);
2810 ctxt->nbentities += ent->checked / 2;
2819 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
2823 ctxt->depth++;
2824 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2826 ctxt->depth--;
2828 if ((ctxt->lastError.code == XML_ERR_ENTITY_LOOP) ||
2829 (ctxt->lastError.code == XML_ERR_INTERNAL_ERROR))
2837 if (xmlParserEntityCheck(ctxt, nbchars, ent, 0))
2861 ent = xmlParseStringPEReference(ctxt, &str);
2862 if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
2864 xmlParserEntityCheck(ctxt, 0, ent, 0);
2866 ctxt->nbentities += ent->checked / 2;
2875 if (((ctxt->options & XML_PARSE_NOENT) != 0) ||
2876 ((ctxt->options & XML_PARSE_DTDVALID) != 0) ||
2877 (ctxt->validate != 0)) {
2878 xmlLoadEntityContent(ctxt, ent);
2880 xmlWarningMsg(ctxt, XML_ERR_ENTITY_PROCESSING,
2885 ctxt->depth++;
2886 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2888 ctxt->depth--;
2894 if (xmlParserEntityCheck(ctxt, nbchars, ent, 0))
2919 xmlErrMemory(ctxt, NULL);
2930 * @ctxt: the parser context
2947 xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
2949 if ((ctxt == NULL) || (str == NULL)) return(NULL);
2950 return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what,
2962 * @ctxt: an XML parser context
2972 static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2981 if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
2987 if ((ctxt->space == NULL) || (*(ctxt->space) == 1) ||
2988 (*(ctxt->space) == -2))
3002 if (ctxt->node == NULL) return(0);
3003 if (ctxt->myDoc != NULL) {
3004 ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
3013 if ((ctxt->node->children == NULL) &&
3016 lastChild = xmlGetLastChild(ctxt->node);
3018 if ((ctxt->node->type != XML_ELEMENT_NODE) &&
3019 (ctxt->node->content != NULL)) return(0);
3022 else if ((ctxt->node->children != NULL) &&
3023 (xmlNodeIsText(ctxt->node->children)))
3037 * @ctxt: an XML parser context
3054 xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix) {
3093 xmlErrMemory(ctxt, NULL);
3106 xmlErrMemory(ctxt, NULL);
3152 xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
3172 xmlErrMemory(ctxt, NULL);
3184 xmlErrMemory(ctxt, NULL);
3238 xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) {
3239 if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3269 xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) {
3270 if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3307 static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
3311 xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
3324 if (ctxt->instate == XML_PARSER_EOF)
3327 if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3377 if (ctxt->instate == XML_PARSER_EOF)
3403 if (ctxt->instate == XML_PARSER_EOF)
3412 if (ctxt->instate == XML_PARSER_EOF)
3419 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3420 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
3423 if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
3424 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
3425 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
3430 * @ctxt: an XML parser context
3445 xmlParseName(xmlParserCtxtPtr ctxt) {
3459 in = ctxt->input->cur;
3471 count = in - ctxt->input->cur;
3473 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3474 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
3477 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3478 ctxt->input->cur = in;
3479 ctxt->nbChars += count;
3480 ctxt->input->col += count;
3482 xmlErrMemory(ctxt, NULL);
3487 return(xmlParseNameComplex(ctxt));
3491 xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
3508 (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) {
3513 (xmlIsNameChar(ctxt, c) && (c != ':'))) {
3516 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3517 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3522 if (ctxt->instate == XML_PARSER_EOF)
3535 ctxt->input->cur -= l;
3537 ctxt->input->cur += l;
3538 if (ctxt->instate == XML_PARSER_EOF)
3544 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3545 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3548 return(xmlDictLookup(ctxt->dict, (BASE_PTR + startPosition), len));
3553 * @ctxt: an XML parser context
3567 xmlParseNCName(xmlParserCtxtPtr ctxt) {
3579 in = ctxt->input->cur;
3580 e = ctxt->input->end;
3594 count = in - ctxt->input->cur;
3596 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3597 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3600 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3601 ctxt->input->cur = in;
3602 ctxt->nbChars += count;
3603 ctxt->input->col += count;
3605 xmlErrMemory(ctxt, NULL);
3611 return(xmlParseNCNameComplex(ctxt));
3616 * @ctxt: an XML parser context
3626 xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
3632 if (ctxt->instate == XML_PARSER_EOF)
3635 in = ctxt->input->cur;
3639 ctxt->input->col++;
3643 ctxt->input->cur = in;
3647 ret = xmlParseName (ctxt);
3657 * @ctxt: an XML parser context
3674 xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
3685 if (!xmlIsNameStartChar(ctxt, c)) {
3692 while (xmlIsNameChar(ctxt, c)) {
3706 xmlErrMemory(ctxt, NULL);
3710 while (xmlIsNameChar(ctxt, c)) {
3715 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3716 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3724 xmlErrMemory(ctxt, NULL);
3740 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3741 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3750 * @ctxt: an XML parser context
3762 xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
3773 if (ctxt->instate == XML_PARSER_EOF)
3777 while (xmlIsNameChar(ctxt, c)) {
3788 if (ctxt->instate == XML_PARSER_EOF)
3802 xmlErrMemory(ctxt, NULL);
3806 while (xmlIsNameChar(ctxt, c)) {
3810 if (ctxt->instate == XML_PARSER_EOF) {
3819 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3820 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
3828 xmlErrMemory(ctxt, NULL);
3845 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3846 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
3854 * @ctxt: an XML parser context
3866 xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
3879 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
3884 xmlErrMemory(ctxt, NULL);
3892 ctxt->instate = XML_PARSER_ENTITY_VALUE;
3893 input = ctxt->input;
3895 if (ctxt->instate == XML_PARSER_EOF) {
3911 (ctxt->input != input))) && (ctxt->instate != XML_PARSER_EOF)) {
3918 xmlErrMemory(ctxt, NULL);
3929 while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */
3930 xmlPopInput(ctxt);
3940 if (ctxt->instate == XML_PARSER_EOF) {
3957 name = xmlParseStringName(ctxt, &cur);
3959 xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
3963 if ((tmp == '%') && (ctxt->inSubset == 1) &&
3964 (ctxt->inputNr == 1)) {
3965 xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
3979 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
3989 ++ctxt->depth;
3990 ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
3992 --ctxt->depth;
4004 * @ctxt: an XML parser context
4015 xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) {
4026 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
4031 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
4034 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
4051 (ctxt->instate != XML_PARSER_EOF)) {
4057 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4058 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4066 int val = xmlParseCharRef(ctxt);
4069 if (ctxt->replaceEntities) {
4095 ent = xmlParseEntityRef(ctxt);
4096 ctxt->nbentities++;
4098 ctxt->nbentities += ent->owner;
4104 if ((ctxt->replaceEntities == 0) &&
4115 (ctxt->replaceEntities != 0)) {
4117 ++ctxt->depth;
4118 rep = xmlStringDecodeEntities(ctxt, ent->content,
4121 --ctxt->depth;
4155 unsigned long oldnbent = ctxt->nbentities;
4157 ++ctxt->depth;
4158 rep = xmlStringDecodeEntities(ctxt, ent->content,
4160 --ctxt->depth;
4162 ent->checked = (ctxt->nbentities - oldnbent + 1) * 2;
4206 if (ctxt->instate == XML_PARSER_EOF)
4214 xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
4217 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
4220 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4231 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4240 xmlErrMemory(ctxt, NULL);
4251 * @ctxt: an XML parser context
4284 xmlParseAttValue(xmlParserCtxtPtr ctxt) {
4285 if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL);
4286 return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
4291 * @ctxt: an XML parser context
4301 xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
4307 int state = ctxt->instate;
4318 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4324 xmlErrMemory(ctxt, NULL);
4327 ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
4334 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4335 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "SystemLiteral");
4337 ctxt->instate = (xmlParserInputState) state;
4344 xmlErrMemory(ctxt, NULL);
4345 ctxt->instate = (xmlParserInputState) state;
4354 if (ctxt->instate == XML_PARSER_EOF) {
4369 ctxt->instate = (xmlParserInputState) state;
4371 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4380 * @ctxt: an XML parser context
4390 xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
4397 xmlParserInputState oldstate = ctxt->instate;
4407 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4412 xmlErrMemory(ctxt, NULL);
4415 ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
4422 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4423 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Public ID");
4430 xmlErrMemory(ctxt, NULL);
4441 if (ctxt->instate == XML_PARSER_EOF) {
4456 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4460 ctxt->instate = oldstate;
4464 static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
4506 * @ctxt: an XML parser context
4521 xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
4524 int line = ctxt->input->line;
4525 int col = ctxt->input->col;
4535 in = ctxt->input->cur;
4538 while (*in == 0x20) { in++; ctxt->input->col++; }
4541 ctxt->input->line++; ctxt->input->col = 1;
4547 nbchar = in - ctxt->input->cur;
4549 const xmlChar *tmp = ctxt->input->cur;
4550 ctxt->input->cur = in;
4552 if ((ctxt->sax != NULL) &&
4553 (ctxt->sax->ignorableWhitespace !=
4554 ctxt->sax->characters)) {
4555 if (areBlanks(ctxt, tmp, nbchar, 1)) {
4556 if (ctxt->sax->ignorableWhitespace != NULL)
4557 ctxt->sax->ignorableWhitespace(ctxt->userData,
4560 if (ctxt->sax->characters != NULL)
4561 ctxt->sax->characters(ctxt->userData,
4563 if (*ctxt->space == -1)
4564 *ctxt->space = -2;
4566 } else if ((ctxt->sax != NULL) &&
4567 (ctxt->sax->characters != NULL)) {
4568 ctxt->sax->characters(ctxt->userData,
4576 ccol = ctxt->input->col;
4581 ctxt->input->col = ccol;
4584 ctxt->input->line++; ctxt->input->col = 1;
4591 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4592 ctxt->input->cur = in;
4596 ctxt->input->col++;
4599 nbchar = in - ctxt->input->cur;
4601 if ((ctxt->sax != NULL) &&
4602 (ctxt->sax->ignorableWhitespace !=
4603 ctxt->sax->characters) &&
4604 (IS_BLANK_CH(*ctxt->input->cur))) {
4605 const xmlChar *tmp = ctxt->input->cur;
4606 ctxt->input->cur = in;
4608 if (areBlanks(ctxt, tmp, nbchar, 0)) {
4609 if (ctxt->sax->ignorableWhitespace != NULL)
4610 ctxt->sax->ignorableWhitespace(ctxt->userData,
4613 if (ctxt->sax->characters != NULL)
4614 ctxt->sax->characters(ctxt->userData,
4616 if (*ctxt->space == -1)
4617 *ctxt->space = -2;
4619 line = ctxt->input->line;
4620 ctxt->input->col;
4621 } else if (ctxt->sax != NULL) {
4622 if (ctxt->sax->characters != NULL)
4623 ctxt->sax->characters(ctxt->userData,
4624 ctxt->input->cur, nbchar);
4625 line = ctxt->input->line;
4626 col = ctxt->input->col;
4629 if (ctxt->instate != XML_PARSER_CONTENT)
4632 ctxt->input->cur = in;
4636 ctxt->input->cur = in;
4638 ctxt->input->line++; ctxt->input->col = 1;
4651 if (ctxt->instate == XML_PARSER_EOF)
4653 in = ctxt->input->cur;
4657 ctxt->input->line = line;
4658 ctxt->input->col = col;
4659 xmlParseCharDataComplex(ctxt, cdata);
4664 * @ctxt: an XML parser context
4672 xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
4688 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4698 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4699 if (areBlanks(ctxt, buf, nbchar, 0)) {
4700 if (ctxt->sax->ignorableWhitespace != NULL)
4701 ctxt->sax->ignorableWhitespace(ctxt->userData,
4704 if (ctxt->sax->characters != NULL)
4705 ctxt->sax->characters(ctxt->userData, buf, nbchar);
4706 if ((ctxt->sax->characters !=
4707 ctxt->sax->ignorableWhitespace) &&
4708 (*ctxt->space == -1))
4709 *ctxt->space = -2;
4714 if (ctxt->instate != XML_PARSER_CONTENT)
4721 if (ctxt->instate == XML_PARSER_EOF)
4732 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4733 if (areBlanks(ctxt, buf, nbchar, 0)) {
4734 if (ctxt->sax->ignorableWhitespace != NULL)
4735 ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
4737 if (ctxt->sax->characters != NULL)
4738 ctxt->sax->characters(ctxt->userData, buf, nbchar);
4739 if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) &&
4740 (*ctxt->space == -1))
4741 *ctxt->space = -2;
4747 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4756 * @ctxt: an XML parser context
4777 xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
4786 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4790 URI = xmlParseSystemLiteral(ctxt);
4792 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4797 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4801 *publicID = xmlParsePubidLiteral(ctxt);
4803 xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
4810 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4829 URI = xmlParseSystemLiteral(ctxt);
4831 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4839 * @ctxt: an XML parser context
4852 xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf,
4860 inputid = ctxt->input->id;
4867 xmlErrMemory(ctxt, NULL);
4876 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4887 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4901 xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
4904 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4905 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4918 xmlErrMemory(ctxt, NULL);
4934 if (ctxt->instate == XML_PARSER_EOF) {
4949 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4952 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4956 if (inputid != ctxt->input->id) {
4957 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4961 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4962 (!ctxt->disableSAX))
4963 ctxt->sax->comment(ctxt->userData, buf);
4968 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4976 * @ctxt: an XML parser context
4985 xmlParseComment(xmlParserCtxtPtr ctxt) {
5000 state = ctxt->instate;
5001 ctxt->instate = XML_PARSER_COMMENT;
5002 inputid = ctxt->input->id;
5011 in = ctxt->input->cur;
5015 ctxt->input->line++; ctxt->input->col = 1;
5020 ccol = ctxt->input->col;
5027 ctxt->input->col = ccol;
5030 ctxt->input->line++; ctxt->input->col = 1;
5035 nbchar = in - ctxt->input->cur;
5040 if ((ctxt->sax != NULL) &&
5041 (ctxt->sax->comment != NULL)) {
5049 xmlErrMemory(ctxt, NULL);
5050 ctxt->instate = state;
5061 xmlErrMemory(ctxt, NULL);
5062 ctxt->instate = state;
5067 memcpy(&buf[len], ctxt->input->cur, nbchar);
5073 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
5074 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
5079 ctxt->input->cur = in;
5082 ctxt->input->line++; ctxt->input->col = 1;
5087 ctxt->input->cur = in;
5089 ctxt->input->line++; ctxt->input->col = 1;
5096 if (ctxt->instate == XML_PARSER_EOF) {
5100 in = ctxt->input->cur;
5104 if (ctxt->input->id != inputid) {
5105 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5109 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
5110 (!ctxt->disableSAX)) {
5112 ctxt->sax->comment(ctxt->userData, buf);
5114 ctxt->sax->comment(ctxt->userData, BAD_CAST "");
5118 if (ctxt->instate != XML_PARSER_EOF)
5119 ctxt->instate = state;
5123 xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
5128 xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
5131 ctxt->input->col++;
5134 ctxt->input->col++;
5138 xmlParseCommentComplex(ctxt, buf, len, size);
5139 ctxt->instate = state;
5146 * @ctxt: an XML parser context
5156 xmlParsePITarget(xmlParserCtxtPtr ctxt) {
5159 name = xmlParseName(ctxt);
5167 xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
5171 xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
5179 xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
5184 xmlNsErr(ctxt, XML_NS_ERR_COLON,
5193 * @ctxt: an XML parser context
5207 xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
5238 ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
5244 xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
5254 * @ctxt: an XML parser context
5264 xmlParsePI(xmlParserCtxtPtr ctxt) {
5274 xmlParserInputPtr input = ctxt->input;
5275 state = ctxt->instate;
5276 ctxt->instate = XML_PARSER_PI;
5287 target = xmlParsePITarget(ctxt);
5290 if (input != ctxt->input) {
5291 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5299 if ((ctxt->sax) && (!ctxt->disableSAX) &&
5300 (ctxt->sax->processingInstruction != NULL))
5301 ctxt->sax->processingInstruction(ctxt->userData,
5303 if (ctxt->instate != XML_PARSER_EOF)
5304 ctxt->instate = state;
5309 xmlErrMemory(ctxt, NULL);
5310 ctxt->instate = state;
5315 xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
5327 xmlErrMemory(ctxt, NULL);
5329 ctxt->instate = state;
5338 if (ctxt->instate == XML_PARSER_EOF) {
5344 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
5345 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5348 ctxt->instate = state;
5362 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
5363 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5366 ctxt->instate = state;
5371 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5374 if (input != ctxt->input) {
5375 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5387 xmlParseCatalogPI(ctxt, buf);
5395 if ((ctxt->sax) && (!ctxt->disableSAX) &&
5396 (ctxt->sax->processingInstruction != NULL))
5397 ctxt->sax->processingInstruction(ctxt->userData,
5402 xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
5404 if (ctxt->instate != XML_PARSER_EOF)
5405 ctxt->instate = state;
5411 * @ctxt: an XML parser context
5426 xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
5432 xmlParserInputPtr input = ctxt->input;
5436 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5442 name = xmlParseName(ctxt);
5444 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5448 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5453 xmlNsErr(ctxt, XML_NS_ERR_COLON,
5462 Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
5466 if (input != ctxt->input) {
5467 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5471 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5472 (ctxt->sax->notationDecl != NULL))
5473 ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
5475 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5484 * @ctxt: an XML parser context
5505 xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
5516 xmlParserInputPtr input = ctxt->input;
5521 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5529 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5535 name = xmlParseName(ctxt);
5537 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5542 xmlNsErr(ctxt, XML_NS_ERR_COLON,
5548 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5552 ctxt->instate = XML_PARSER_ENTITY_DECL;
5558 value = xmlParseEntityValue(ctxt, &orig);
5560 if ((ctxt->sax != NULL) &&
5561 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5562 ctxt->sax->entityDecl(ctxt->userData, name,
5567 URI = xmlParseExternalID(ctxt, &literal, 1);
5569 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5576 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5589 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5591 if ((ctxt->sax != NULL) &&
5592 (!ctxt->disableSAX) &&
5593 (ctxt->sax->entityDecl != NULL))
5594 ctxt->sax->entityDecl(ctxt->userData, name,
5604 value = xmlParseEntityValue(ctxt, &orig);
5605 if ((ctxt->sax != NULL) &&
5606 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5607 ctxt->sax->entityDecl(ctxt->userData, name,
5613 if ((ctxt->myDoc == NULL) ||
5614 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
5615 if (ctxt->myDoc == NULL) {
5616 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5617 if (ctxt->myDoc == NULL) {
5618 xmlErrMemory(ctxt, "New Doc failed");
5621 ctxt->myDoc->properties = XML_DOC_INTERNAL;
5623 if (ctxt->myDoc->intSubset == NULL)
5624 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5627 xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
5631 URI = xmlParseExternalID(ctxt, &literal, 1);
5633 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5640 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5653 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5659 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5666 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5670 ndata = xmlParseName(ctxt);
5671 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5672 (ctxt->sax->unparsedEntityDecl != NULL))
5673 ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
5676 if ((ctxt->sax != NULL) &&
5677 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5678 ctxt->sax->entityDecl(ctxt->userData, name,
5685 if ((ctxt->replaceEntities != 0) &&
5686 ((ctxt->myDoc == NULL) ||
5687 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
5688 if (ctxt->myDoc == NULL) {
5689 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5690 if (ctxt->myDoc == NULL) {
5691 xmlErrMemory(ctxt, "New Doc failed");
5694 ctxt->myDoc->properties = XML_DOC_INTERNAL;
5697 if (ctxt->myDoc->intSubset == NULL)
5698 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5700 xmlSAX2EntityDecl(ctxt, name,
5707 if (ctxt->instate == XML_PARSER_EOF)
5711 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
5713 xmlHaltParser(ctxt);
5715 if (input != ctxt->input) {
5716 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5728 if ((ctxt->sax != NULL) &&
5729 (ctxt->sax->getParameterEntity != NULL))
5730 cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
5732 if ((ctxt->sax != NULL) &&
5733 (ctxt->sax->getEntity != NULL))
5734 cur = ctxt->sax->getEntity(ctxt->userData, name);
5735 if ((cur == NULL) && (ctxt->userData==ctxt)) {
5736 cur = xmlSAX2GetEntity(ctxt, name);
5755 * @ctxt: an XML parser context
5783 xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
5801 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5806 ret = xmlParseAttValue(ctxt);
5807 ctxt->instate = XML_PARSER_DTD;
5809 xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
5818 * @ctxt: an XML parser context
5834 xmlParseNotationType(xmlParserCtxtPtr ctxt) {
5839 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5846 name = xmlParseName(ctxt);
5848 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5856 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5859 if (!xmlDictOwns(ctxt->dict, name))
5880 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5890 * @ctxt: an XML parser context
5904 xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
5909 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
5916 name = xmlParseNmtoken(ctxt);
5918 xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
5924 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5927 if (!xmlDictOwns(ctxt->dict, name))
5935 if (!xmlDictOwns(ctxt->dict, name))
5950 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
5959 * @ctxt: an XML parser context
5973 xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5977 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5982 *tree = xmlParseNotationType(ctxt);
5986 *tree = xmlParseEnumerationType(ctxt);
5993 * @ctxt: an XML parser context
6037 xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
6064 return(xmlParseEnumeratedType(ctxt, tree));
6069 * @ctxt: an XML parser context
6079 xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
6085 xmlParserInputPtr input = ctxt->input;
6089 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6093 elemName = xmlParseName(ctxt);
6095 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6101 while ((RAW != '>') && (ctxt->instate != XML_PARSER_EOF)) {
6109 attrName = xmlParseName(ctxt);
6111 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6117 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6123 type = xmlParseAttributeType(ctxt, &tree);
6130 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6138 def = xmlParseDefaultDecl(ctxt, &defaultValue);
6152 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6163 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
6171 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6172 (ctxt->sax->attributeDecl != NULL))
6173 ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
6178 if ((ctxt->sax2) && (defaultValue != NULL) &&
6181 xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
6183 if (ctxt->sax2) {
6184 xmlAddSpecialAttr(ctxt, elemName, attrName, type);
6191 if (input != ctxt->input) {
6192 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6203 * @ctxt: an XML parser context
6221 xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6231 if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6232 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6237 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
6247 ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
6250 while ((RAW == '|') && (ctxt->instate != XML_PARSER_EOF)) {
6253 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6260 n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6262 n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6271 elem = xmlParseName(ctxt);
6273 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6275 xmlFreeDocElementContent(ctxt->myDoc, cur);
6283 cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
6290 if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6291 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6297 xmlFreeDocElementContent(ctxt->myDoc, ret);
6298 xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
6303 xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
6310 * @ctxt: an XML parser context
6341 xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk,
6347 if (((depth > 128) && ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
6349 xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED,
6357 int inputid = ctxt->input->id;
6362 cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6367 elem = xmlParseName(ctxt);
6369 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6372 cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6374 xmlErrMemory(ctxt, NULL);
6394 while ((RAW != ')') && (ctxt->instate != XML_PARSER_EOF)) {
6405 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6409 xmlFreeDocElementContent(ctxt->myDoc, last);
6411 xmlFreeDocElementContent(ctxt->myDoc, ret);
6416 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
6419 xmlFreeDocElementContent(ctxt->myDoc, last);
6420 xmlFreeDocElementContent(ctxt->myDoc, ret);
6445 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6449 xmlFreeDocElementContent(ctxt->myDoc, last);
6451 xmlFreeDocElementContent(ctxt->myDoc, ret);
6456 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6459 xmlFreeDocElementContent(ctxt->myDoc, last);
6461 xmlFreeDocElementContent(ctxt->myDoc, ret);
6480 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
6482 xmlFreeDocElementContent(ctxt->myDoc, last);
6484 xmlFreeDocElementContent(ctxt->myDoc, ret);
6491 int inputid = ctxt->input->id;
6495 last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6499 elem = xmlParseName(ctxt);
6501 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6503 xmlFreeDocElementContent(ctxt->myDoc, ret);
6506 last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6509 xmlFreeDocElementContent(ctxt->myDoc, ret);
6533 if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6534 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6608 * @ctxt: an XML parser context
6637 xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6639 return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1));
6644 * @ctxt: an XML parser context
6657 xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
6661 int inputid = ctxt->input->id;
6667 xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6673 if (ctxt->instate == XML_PARSER_EOF)
6677 tree = xmlParseElementMixedContentDecl(ctxt, inputid);
6680 tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1);
6690 * @ctxt: an XML parser context
6702 xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
6709 xmlParserInputPtr input = ctxt->input;
6713 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6718 name = xmlParseName(ctxt);
6720 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6724 while ((RAW == 0) && (ctxt->inputNr > 1))
6725 xmlPopInput(ctxt);
6727 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6745 ret = xmlParseElementContentDecl(ctxt, name, &content);
6750 if ((RAW == '%') && (ctxt->external == 0) &&
6751 (ctxt->inputNr == 1)) {
6752 xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
6755 xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6765 while ((RAW == 0) && (ctxt->inputNr > 1))
6766 xmlPopInput(ctxt);
6770 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
6772 xmlFreeDocElementContent(ctxt->myDoc, content);
6775 if (input != ctxt->input) {
6776 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6781 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6782 (ctxt->sax->elementDecl != NULL)) {
6785 ctxt->sax->elementDecl(ctxt->userData, name, ret,
6794 xmlFreeDocElementContent(ctxt->myDoc, content);
6797 xmlFreeDocElementContent(ctxt->myDoc, content);
6806 * @ctxt: an XML parser context
6816 xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
6817 int id = ctxt->input->id;
6825 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6826 xmlHaltParser(ctxt);
6829 if (ctxt->input->id != id) {
6830 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6837 if ((ctxt->input != NULL) && (ctxt->input->filename))
6839 "%s(%d): ", ctxt->input->filename,
6840 ctxt->input->line);
6846 (NXT(2) != '>'))) && (ctxt->instate != XML_PARSER_EOF)) {
6848 unsigned int cons = ctxt->input->consumed;
6851 xmlParseConditionalSections(ctxt);
6855 xmlParsePEReference(ctxt);
6857 xmlParseMarkupDecl(ctxt);
6862 while ((RAW == 0) && (ctxt->inputNr > 1))
6863 xmlPopInput(ctxt);
6865 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
6866 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6867 xmlHaltParser(ctxt);
6872 if ((ctxt->input != NULL) && (ctxt->input->filename))
6874 "%s(%d): ", ctxt->input->filename,
6875 ctxt->input->line);
6888 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6889 xmlHaltParser(ctxt);
6892 if (ctxt->input->id != id) {
6893 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6900 if ((ctxt->input != NULL) && (ctxt->input->filename))
6902 "%s(%d): ", ctxt->input->filename,
6903 ctxt->input->line);
6912 state = ctxt->disableSAX;
6913 instate = ctxt->instate;
6914 if (ctxt->recovery == 0) ctxt->disableSAX = 1;
6915 ctxt->instate = XML_PARSER_IGNORE;
6918 (ctxt->instate != XML_PARSER_EOF)) {
6932 ctxt->disableSAX = state;
6933 ctxt->instate = instate;
6936 if ((ctxt->input != NULL) && (ctxt->input->filename))
6938 "%s(%d): ", ctxt->input->filename,
6939 ctxt->input->line);
6945 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
6946 xmlHaltParser(ctxt);
6954 xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
6956 if (ctxt->input->id != id) {
6957 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6961 if ((ctxt-> instate != XML_PARSER_EOF) &&
6962 ((ctxt->input->cur + 3) <= ctxt->input->end))
6969 * @ctxt: an XML parser context
6990 xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
6997 xmlParseElementDecl(ctxt);
6999 xmlParseEntityDecl(ctxt);
7002 xmlParseAttributeListDecl(ctxt);
7005 xmlParseNotationDecl(ctxt);
7008 xmlParseComment(ctxt);
7015 xmlParsePI(ctxt);
7023 if (ctxt->instate == XML_PARSER_EOF)
7030 if ((ctxt->external == 0) && (ctxt->inputNr == 1))
7031 xmlParsePEReference(ctxt);
7037 if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
7039 xmlParseConditionalSections(ctxt);
7043 ctxt->instate = XML_PARSER_DTD;
7048 * @ctxt: an XML parser context
7056 xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
7066 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
7071 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
7079 version = xmlParseVersionInfo(ctxt);
7084 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
7088 ctxt->input->version = version;
7093 encoding = xmlParseEncodingDecl(ctxt);
7094 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
7100 if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
7101 xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
7110 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
7113 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
7121 * @ctxt: an XML parser context
7132 xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
7134 xmlDetectSAX2(ctxt);
7137 if ((ctxt->encoding == NULL) &&
7138 (ctxt->input->end - ctxt->input->cur >= 4)) {
7148 xmlSwitchEncoding(ctxt, enc);
7152 xmlParseTextDecl(ctxt);
7153 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
7157 xmlHaltParser(ctxt);
7161 if (ctxt->myDoc == NULL) {
7162 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
7163 if (ctxt->myDoc == NULL) {
7164 xmlErrMemory(ctxt, "New Doc failed");
7167 ctxt->myDoc->properties = XML_DOC_INTERNAL;
7169 if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
7170 xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
7172 ctxt->instate = XML_PARSER_DTD;
7173 ctxt->external = 1;
7178 unsigned int cons = ctxt->input->consumed;
7182 xmlParseConditionalSections(ctxt);
7186 xmlParsePEReference(ctxt);
7188 xmlParseMarkupDecl(ctxt);
7193 while ((RAW == 0) && (ctxt->inputNr > 1))
7194 xmlPopInput(ctxt);
7196 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
7197 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
7203 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
7210 * @ctxt: an XML parser context
7220 xmlParseReference(xmlParserCtxtPtr ctxt) {
7238 int value = xmlParseCharRef(ctxt);
7242 if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
7251 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7252 (!ctxt->disableSAX))
7253 ctxt->sax->characters(ctxt->userData, out, 1);
7259 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7260 (!ctxt->disableSAX))
7261 ctxt->sax->reference(ctxt->userData, out);
7269 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7270 (!ctxt->disableSAX))
7271 ctxt->sax->characters(ctxt->userData, out, i);
7279 ent = xmlParseEntityRef(ctxt);
7281 if (!ctxt->wellFormed)
7293 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7294 (!ctxt->disableSAX))
7295 ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
7310 ((ent->children == NULL) && (ctxt->options & XML_PARSE_NOENT))) &&
7312 (ctxt->options & (XML_PARSE_NOENT | XML_PARSE_DTDVALID)))) {
7313 unsigned long oldnbent = ctxt->nbentities;
7321 if (ctxt->userData == ctxt)
7324 user_data = ctxt->userData;
7333 ctxt->depth++;
7334 ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content,
7336 ctxt->depth--;
7339 ctxt->depth++;
7340 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax,
7341 user_data, ctxt->depth, ent->URI,
7343 ctxt->depth--;
7346 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
7354 ent->checked = (ctxt->nbentities - oldnbent + 1) * 2;
7358 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7362 if (xmlParserEntityCheck(ctxt, 0, ent, 0)) {
7372 if (ctxt->replaceEntities) {
7379 (ctxt->parseMode == XML_PARSE_READER)) {
7386 list->parent = (xmlNodePtr) ctxt->node;
7387 list->doc = ctxt->myDoc;
7414 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7416 xmlParserEntityCheck(ctxt, 0, ent, 0);
7424 ctxt->nbentities += ent->checked / 2;
7446 if (ctxt->userData == ctxt)
7449 user_data = ctxt->userData;
7452 ctxt->depth++;
7453 ret = xmlParseBalancedChunkMemoryInternal(ctxt,
7455 ctxt->depth--;
7458 ctxt->depth++;
7459 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
7460 ctxt->sax, user_data, ctxt->depth,
7462 ctxt->depth--;
7465 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
7469 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7473 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7474 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7479 ctxt->sax->reference(ctxt->userData, ent->name);
7487 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7488 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7492 ctxt->sax->reference(ctxt->userData, ent->name);
7496 if ((ctxt->replaceEntities) || (ent->children == NULL)) {
7510 if ((ctxt->node != NULL) && (ent->children != NULL)) {
7517 (ctxt->parseMode == XML_PARSE_READER)) {
7523 ctxt->sizeentcopy += ent->length + 5;
7524 if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
7530 if (ctxt->parseMode == XML_PARSE_READER)
7536 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7543 nw = xmlAddChild(ctxt->node, nw);
7550 if ((ctxt->parseMode == XML_PARSE_READER) &&
7564 } else if ((list == NULL) || (ctxt->inputNr > 0)) {
7571 ctxt->sizeentcopy += ent->length + 5;
7572 if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
7589 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7597 xmlAddChild(ctxt->node, cur);
7617 nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
7624 xmlAddChildList(ctxt->node, ent->children);
7631 ctxt->nodemem = 0;
7632 ctxt->nodelen = 0;
7640 * @ctxt: an XML parser context
7667 xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
7672 if (ctxt->instate == XML_PARSER_EOF)
7678 name = xmlParseName(ctxt);
7680 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7685 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7693 if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7702 ctxt->nbentities++;
7708 if (ctxt->sax != NULL) {
7709 if (ctxt->sax->getEntity != NULL)
7710 ent = ctxt->sax->getEntity(ctxt->userData, name);
7711 if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7712 (ctxt->options & XML_PARSE_OLDSAX))
7714 if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7715 (ctxt->userData==ctxt)) {
7716 ent = xmlSAX2GetEntity(ctxt, name);
7719 if (ctxt->instate == XML_PARSER_EOF)
7743 if ((ctxt->standalone == 1) ||
7744 ((ctxt->hasExternalSubset == 0) &&
7745 (ctxt->hasPErefs == 0))) {
7746 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7749 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7751 if ((ctxt->inSubset == 0) &&
7752 (ctxt->sax != NULL) &&
7753 (ctxt->sax->reference != NULL)) {
7754 ctxt->sax->reference(ctxt->userData, name);
7757 xmlParserEntityCheck(ctxt, 0, ent, 0);
7758 ctxt->valid = 0;
7767 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7776 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7778 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7787 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7792 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7804 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7824 * @ctxt: an XML parser context
7854 xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
7868 name = xmlParseStringName(ctxt, &ptr);
7870 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7876 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7887 if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7899 ctxt->nbentities++;
7905 if (ctxt->sax != NULL) {
7906 if (ctxt->sax->getEntity != NULL)
7907 ent = ctxt->sax->getEntity(ctxt->userData, name);
7908 if ((ent == NULL) && (ctxt->options & XML_PARSE_OLDSAX))
7910 if ((ent == NULL) && (ctxt->userData==ctxt)) {
7911 ent = xmlSAX2GetEntity(ctxt, name);
7914 if (ctxt->instate == XML_PARSER_EOF) {
7941 if ((ctxt->standalone == 1) ||
7942 ((ctxt->hasExternalSubset == 0) &&
7943 (ctxt->hasPErefs == 0))) {
7944 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7947 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7951 xmlParserEntityCheck(ctxt, 0, ent, 0);
7952 /* TODO ? check regressions ctxt->valid = 0; */
7961 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7970 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7972 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7981 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7985 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7997 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
8020 * @ctxt: an XML parser context
8048 xmlParsePEReference(xmlParserCtxtPtr ctxt)
8057 name = xmlParseName(ctxt);
8059 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8064 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
8073 ctxt->nbentities++;
8078 if ((ctxt->sax != NULL) &&
8079 (ctxt->sax->getParameterEntity != NULL))
8080 entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
8081 if (ctxt->instate == XML_PARSER_EOF)
8092 if ((ctxt->standalone == 1) ||
8093 ((ctxt->hasExternalSubset == 0) &&
8094 (ctxt->hasPErefs == 0))) {
8095 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
8106 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8109 ctxt->valid = 0;
8111 xmlParserEntityCheck(ctxt, 0, NULL, 0);
8118 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8121 } else if (ctxt->input->free != deallocblankswrapper) {
8122 input = xmlNewBlanksWrapperInputStream(ctxt, entity);
8123 if (xmlPushInput(ctxt, input) < 0)
8131 input = xmlNewEntityInputStream(ctxt, entity);
8132 if (xmlPushInput(ctxt, input) < 0)
8137 xmlParseTextDecl(ctxt);
8138 if (ctxt->errNo ==
8144 xmlHaltParser(ctxt);
8150 ctxt->hasPErefs = 1;
8155 * @ctxt: an XML parser context
8165 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
8171 if ((ctxt == NULL) || (entity == NULL) ||
8175 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8186 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8191 input = xmlNewEntityInputStream(ctxt, entity);
8193 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8203 if (xmlPushInput(ctxt, input) < 0) {
8210 while ((ctxt->input == input) && (ctxt->input->cur < ctxt->input->end) &&
8212 xmlBufferAdd(buf, ctxt->input->cur, l);
8216 if (ctxt->instate == XML_PARSER_EOF) {
8226 if (ctxt->instate == XML_PARSER_EOF) {
8234 if ((ctxt->input == input) && (ctxt->input->cur >= ctxt->input->end)) {
8235 xmlPopInput(ctxt);
8237 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
8252 * @ctxt: an XML parser context
8282 xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
8294 name = xmlParseStringName(ctxt, &ptr);
8296 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8303 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
8313 ctxt->nbentities++;
8318 if ((ctxt->sax != NULL) &&
8319 (ctxt->sax->getParameterEntity != NULL))
8320 entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
8321 if (ctxt->instate == XML_PARSER_EOF) {
8334 if ((ctxt->standalone == 1) ||
8335 ((ctxt->hasExternalSubset == 0) && (ctxt->hasPErefs == 0))) {
8336 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
8346 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8349 ctxt->valid = 0;
8351 xmlParserEntityCheck(ctxt, 0, NULL, 0);
8358 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8363 ctxt->hasPErefs = 1;
8371 * @ctxt: an XML parser context
8384 xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
8399 name = xmlParseName(ctxt);
8401 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8404 ctxt->intSubName = name;
8411 URI = xmlParseExternalID(ctxt, &ExternalID, 1);
8414 ctxt->hasExternalSubset = 1;
8416 ctxt->extSubURI = URI;
8417 ctxt->extSubSystem = ExternalID;
8424 if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
8425 (!ctxt->disableSAX))
8426 ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
8427 if (ctxt->instate == XML_PARSER_EOF)
8441 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8448 * @ctxt: an XML parser context
8456 xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
8461 ctxt->instate = XML_PARSER_DTD;
8468 while ((RAW != ']') && (ctxt->instate != XML_PARSER_EOF)) {
8470 unsigned int cons = ctxt->input->consumed;
8473 xmlParseMarkupDecl(ctxt);
8474 xmlParsePEReference(ctxt);
8479 while ((RAW == 0) && (ctxt->inputNr > 1))
8480 xmlPopInput(ctxt);
8482 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
8483 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8498 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8507 * @ctxt: an XML parser context
8539 xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
8545 name = xmlParseName(ctxt);
8547 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8559 val = xmlParseAttValue(ctxt);
8560 ctxt->instate = XML_PARSER_CONTENT;
8562 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8572 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
8574 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8585 *(ctxt->space) = 0;
8587 *(ctxt->space) = 1;
8589 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8601 * @ctxt: an XML parser context
8628 xmlParseStartTag(xmlParserCtxtPtr ctxt) {
8632 const xmlChar **atts = ctxt->atts;
8634 int maxatts = ctxt->maxatts;
8640 name = xmlParseName(ctxt);
8642 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8657 (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
8659 unsigned int cons = ctxt->input->consumed;
8661 attname = xmlParseAttribute(ctxt, &attvalue);
8670 xmlErrAttributeDup(ctxt, NULL, attname);
8683 xmlErrMemory(ctxt, NULL);
8688 ctxt->atts = atts;
8689 ctxt->maxatts = maxatts;
8697 xmlErrMemory(ctxt, NULL);
8703 ctxt->atts = atts;
8704 ctxt->maxatts = maxatts;
8721 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8725 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
8727 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
8738 if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
8739 (!ctxt->disableSAX)) {
8741 ctxt->sax->startElement(ctxt->userData, name, atts);
8743 ctxt->sax->startElement(ctxt->userData, name, NULL);
8757 * @ctxt: an XML parser context
8771 xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
8776 xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
8782 name = xmlParseNameAndCompare(ctxt,ctxt->name);
8790 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
8802 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
8804 ctxt->name, line, name);
8810 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
8811 (!ctxt->disableSAX))
8812 ctxt->sax->endElement(ctxt->userData, ctxt->name);
8814 namePop(ctxt);
8815 spacePop(ctxt);
8821 * @ctxt: an XML parser context
8833 xmlParseEndTag(xmlParserCtxtPtr ctxt) {
8834 xmlParseEndTag1(ctxt, 0);
8846 * @ctxt: an XML parser context
8850 * The prefix must come from the @ctxt->dict dictionary
8855 xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
8858 if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
8859 for (i = ctxt->nsNr - 2;i >= 0;i-=2)
8860 if (ctxt->nsTab[i] == prefix) {
8861 if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
8863 return(ctxt->nsTab[i + 1]);
8870 * @ctxt: an XML parser context
8883 xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
8888 l = xmlParseNCName(ctxt);
8891 l = xmlParseName(ctxt);
8893 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8904 l = xmlParseNCName(ctxt);
8908 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8910 l = xmlParseNmtoken(ctxt);
8917 p = xmlDictLookup(ctxt->dict, tmp, -1);
8925 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8928 tmp = (xmlChar *) xmlParseName(ctxt);
8931 l = xmlDictLookup(ctxt->dict, tmp, -1);
8937 l = xmlDictLookup(ctxt->dict, tmp, -1);
8950 * @ctxt: an XML parser context
8962 xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
8969 if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
8972 in = ctxt->input->cur;
8988 ctxt->input->cur = in;
8995 ret = xmlParseQName (ctxt, &prefix2);
9003 * @ctxt: an XML parser context
9036 xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len, int *alloc,
9046 line = ctxt->input->line;
9047 col = ctxt->input->col;
9049 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
9052 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
9061 end = ctxt->input->end;
9064 const xmlChar *oldbase = ctxt->input->base;
9066 if (oldbase != ctxt->input->base) {
9067 long delta = ctxt->input->base - oldbase;
9071 end = ctxt->input->end;
9088 const xmlChar *oldbase = ctxt->input->base;
9090 if (ctxt->instate == XML_PARSER_EOF)
9092 if (oldbase != ctxt->input->base) {
9093 long delta = ctxt->input->base - oldbase;
9097 end = ctxt->input->end;
9099 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9100 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9111 const xmlChar *oldbase = ctxt->input->base;
9113 if (ctxt->instate == XML_PARSER_EOF)
9115 if (oldbase != ctxt->input->base) {
9116 long delta = ctxt->input->base - oldbase;
9120 end = ctxt->input->end;
9122 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9123 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9144 const xmlChar *oldbase = ctxt->input->base;
9146 if (ctxt->instate == XML_PARSER_EOF)
9148 if (oldbase != ctxt->input->base) {
9149 long delta = ctxt->input->base - oldbase;
9154 end = ctxt->input->end;
9156 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9157 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9164 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9165 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9176 const xmlChar *oldbase = ctxt->input->base;
9178 if (ctxt->instate == XML_PARSER_EOF)
9180 if (oldbase != ctxt->input->base) {
9181 long delta = ctxt->input->base - oldbase;
9185 end = ctxt->input->end;
9187 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9188 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9196 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9197 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9213 ctxt->input->line = line;
9214 ctxt->input->col = col;
9219 return xmlParseAttValueComplex(ctxt, len, normalize);
9224 * @ctxt: an XML parser context
9238 xmlParseAttribute2(xmlParserCtxtPtr ctxt,
9249 name = xmlParseQName(ctxt, prefix);
9251 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
9259 if (ctxt->attsSpecial != NULL) {
9262 type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial,
9275 val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
9286 val2 = xmlAttrNormalizeSpace2(ctxt, val, len);
9293 ctxt->instate = XML_PARSER_CONTENT;
9295 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
9301 if (*prefix == ctxt->str_xml) {
9307 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
9310 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
9322 *(ctxt->space) = 0;
9324 *(ctxt->space) = 1;
9326 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
9341 * @ctxt: an XML parser context
9369 xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
9377 const xmlChar **atts = ctxt->atts;
9378 int maxatts = ctxt->maxatts;
9383 int nsNr = ctxt->nsNr;
9397 base = ctxt->input->base;
9398 cur = ctxt->input->cur - ctxt->input->base;
9399 inputNr = ctxt->inputNr;
9400 oldline = ctxt->input->line;
9401 oldcol = ctxt->input->col;
9408 ctxt->nsNr = nsNr;
9410 localname = xmlParseQName(ctxt, &prefix);
9412 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
9416 *tlen = ctxt->input->cur - ctxt->input->base - cur;
9425 if ((ctxt->input->base != base) || (inputNr != ctxt->inputNr))
9430 (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
9432 unsigned int cons = ctxt->input->consumed;
9435 attname = xmlParseAttribute2(ctxt, prefix, localname,
9437 if ((ctxt->input->base != base) || (inputNr != ctxt->inputNr)) {
9445 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9446 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
9450 xmlErrMemory(ctxt, "dictionary allocation failure");
9458 xmlNsErr(ctxt, XML_WAR_NS_URI,
9463 xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9469 if (URL == ctxt->str_xml_ns) {
9470 if (attname != ctxt->str_xml) {
9471 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9480 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9490 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
9493 xmlErrAttributeDup(ctxt, NULL, attname);
9495 if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
9504 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9509 if ((ctxt->input->base != base) || (inputNr != ctxt->inputNr))
9513 if (aprefix == ctxt->str_xmlns) {
9514 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
9517 if (attname == ctxt->str_xml) {
9518 if (URL != ctxt->str_xml_ns) {
9519 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9528 if (URL == ctxt->str_xml_ns) {
9529 if (attname != ctxt->str_xml) {
9530 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9536 if (attname == ctxt->str_xmlns) {
9537 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9545 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9551 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9558 xmlNsErr(ctxt, XML_WAR_NS_URI,
9562 if ((ctxt->pedantic) && (uri->scheme == NULL)) {
9563 xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9575 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9578 xmlErrAttributeDup(ctxt, aprefix, attname);
9580 if (nsPush(ctxt, attname, URL) > 0) nbNs++;
9589 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9594 if ((ctxt->input->base != base) || (inputNr != ctxt->inputNr))
9603 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9608 maxatts = ctxt->maxatts;
9609 atts = ctxt->atts;
9611 ctxt->attallocs[nratts++] = alloc;
9630 if (ctxt->instate == XML_PARSER_EOF)
9632 if ((ctxt->input->base != base) || (inputNr != ctxt->inputNr))
9637 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9642 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
9644 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9649 if ((ctxt->input->base != base) || (inputNr != ctxt->inputNr))
9656 if (ctxt->attsDefault != NULL) {
9659 defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
9668 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9673 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
9677 nsname = xmlGetNamespace(ctxt, NULL);
9679 if (nsPush(ctxt, NULL,
9683 } else if (aprefix == ctxt->str_xmlns) {
9688 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9692 nsname = xmlGetNamespace(ctxt, attname);
9694 if (nsPush(ctxt, attname,
9709 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9712 maxatts = ctxt->maxatts;
9713 atts = ctxt->atts;
9720 atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
9723 if ((ctxt->standalone == 1) &&
9725 xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED,
9743 nsname = xmlGetNamespace(ctxt, atts[i + 1]);
9745 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9761 xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
9765 xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
9774 nsname = xmlGetNamespace(ctxt, prefix);
9776 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9786 if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
9787 (!ctxt->disableSAX)) {
9789 ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9790 nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
9793 ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9802 if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9814 if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9822 if (inputNr != ctxt->inputNr) {
9823 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
9828 ctxt->input->cur = ctxt->input->base + cur;
9829 ctxt->input->line = oldline;
9830 ctxt->input->col = oldcol;
9831 if (ctxt->wellFormed == 1) {
9839 * @ctxt: an XML parser context
9853 xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
9860 ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
9865 curLength = ctxt->input->end - ctxt->input->cur;
9867 (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
9869 (ctxt->input->cur[tlen] == '>')) {
9870 ctxt->input->cur += tlen + 1;
9871 ctxt->input->col += tlen + 1;
9874 ctxt->input->cur += tlen;
9875 ctxt->input->col += tlen;
9879 name = xmlParseNameAndCompare(ctxt, ctxt->name);
9881 name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
9888 if (ctxt->instate == XML_PARSER_EOF)
9892 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
9904 if ((line == 0) && (ctxt->node != NULL))
9905 line = ctxt->node->line;
9906 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
9908 ctxt->name, line, name);
9915 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
9916 (!ctxt->disableSAX))
9917 ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
9919 spacePop(ctxt);
9921 nsPop(ctxt, nsNr);
9927 * @ctxt: an XML parser context
9940 xmlParseCDSect(xmlParserCtxtPtr ctxt) {
9955 ctxt->instate = XML_PARSER_CDATA_SECTION;
9958 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9959 ctxt->instate = XML_PARSER_CONTENT;
9965 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9966 ctxt->instate = XML_PARSER_CONTENT;
9973 xmlErrMemory(ctxt, NULL);
9982 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9983 xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
9991 xmlErrMemory(ctxt, NULL);
10005 if (ctxt->instate == XML_PARSER_EOF) {
10015 ctxt->instate = XML_PARSER_CONTENT;
10017 xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
10027 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
10028 if (ctxt->sax->cdataBlock != NULL)
10029 ctxt->sax->cdataBlock(ctxt->userData, buf, len);
10030 else if (ctxt->sax->characters != NULL)
10031 ctxt->sax->characters(ctxt->userData, buf, len);
10038 * @ctxt: an XML parser context
10046 xmlParseContent(xmlParserCtxtPtr ctxt) {
10050 (ctxt->instate != XML_PARSER_EOF)) {
10052 unsigned int cons = ctxt->input->consumed;
10053 const xmlChar *cur = ctxt->input->cur;
10059 xmlParsePI(ctxt);
10067 xmlParseCDSect(ctxt);
10075 xmlParseComment(ctxt);
10076 ctxt->instate = XML_PARSER_CONTENT;
10083 xmlParseElement(ctxt);
10092 xmlParseReference(ctxt);
10099 xmlParseCharData(ctxt, 0);
10106 while ((RAW == 0) && (ctxt->inputNr > 1))
10107 xmlPopInput(ctxt);
10110 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
10111 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
10113 xmlHaltParser(ctxt);
10121 * @ctxt: an XML parser context
10134 xmlParseElement(xmlParserCtxtPtr ctxt) {
10141 int nsNr = ctxt->nsNr;
10143 if (((unsigned int) ctxt->nameNr > xmlParserMaxDepth) &&
10144 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
10145 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
10148 xmlHaltParser(ctxt);
10153 if (ctxt->record_info) {
10154 node_info.begin_pos = ctxt->input->consumed +
10155 (CUR_PTR - ctxt->input->base);
10156 node_info.begin_line = ctxt->input->line;
10159 if (ctxt->spaceNr == 0)
10160 spacePush(ctxt, -1);
10161 else if (*ctxt->space == -2)
10162 spacePush(ctxt, -1);
10164 spacePush(ctxt, *ctxt->space);
10166 line = ctxt->input->line;
10168 if (ctxt->sax2)
10170 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
10173 name = xmlParseStartTag(ctxt);
10175 if (ctxt->instate == XML_PARSER_EOF)
10178 spacePop(ctxt);
10181 namePush(ctxt, name);
10182 ret = ctxt->node;
10190 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
10191 ctxt->node && (ctxt->node == ctxt->myDoc->children))
10192 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
10200 if (ctxt->sax2) {
10201 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
10202 (!ctxt->disableSAX))
10203 ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
10206 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
10207 (!ctxt->disableSAX))
10208 ctxt->sax->endElement(ctxt->userData, name);
10211 namePop(ctxt);
10212 spacePop(ctxt);
10213 if (nsNr != ctxt->nsNr)
10214 nsPop(ctxt, ctxt->nsNr - nsNr);
10215 if ( ret != NULL && ctxt->record_info ) {
10216 node_info.end_pos = ctxt->input->consumed +
10217 (CUR_PTR - ctxt->input->base);
10218 node_info.end_line = ctxt->input->line;
10220 xmlParserAddNodeInfo(ctxt, &node_info);
10227 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
10234 nodePop(ctxt);
10235 namePop(ctxt);
10236 spacePop(ctxt);
10237 if (nsNr != ctxt->nsNr)
10238 nsPop(ctxt, ctxt->nsNr - nsNr);
10243 if ( ret != NULL && ctxt->record_info ) {
10244 node_info.end_pos = ctxt->input->consumed +
10245 (CUR_PTR - ctxt->input->base);
10246 node_info.end_line = ctxt->input->line;
10248 xmlParserAddNodeInfo(ctxt, &node_info);
10256 xmlParseContent(ctxt);
10257 if (ctxt->instate == XML_PARSER_EOF)
10260 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
10267 nodePop(ctxt);
10268 namePop(ctxt);
10269 spacePop(ctxt);
10270 if (nsNr != ctxt->nsNr)
10271 nsPop(ctxt, ctxt->nsNr - nsNr);
10278 if (ctxt->sax2) {
10279 xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
10280 namePop(ctxt);
10284 xmlParseEndTag1(ctxt, line);
10290 if ( ret != NULL && ctxt->record_info ) {
10291 node_info.end_pos = ctxt->input->consumed +
10292 (CUR_PTR - ctxt->input->base);
10293 node_info.end_line = ctxt->input->line;
10295 xmlParserAddNodeInfo(ctxt, &node_info);
10301 * @ctxt: an XML parser context
10312 xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
10320 xmlErrMemory(ctxt, NULL);
10346 xmlErrMemory(ctxt, NULL);
10361 * @ctxt: an XML parser context
10373 xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
10380 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10387 version = xmlParseVersionNum(ctxt);
10389 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10394 version = xmlParseVersionNum(ctxt);
10396 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10400 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10408 * @ctxt: an XML parser context
10417 xmlParseEncName(xmlParserCtxtPtr ctxt) {
10428 xmlErrMemory(ctxt, NULL);
10446 xmlErrMemory(ctxt, NULL);
10463 xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
10470 * @ctxt: an XML parser context
10482 xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
10490 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10497 encoding = xmlParseEncName(ctxt);
10499 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10506 encoding = xmlParseEncName(ctxt);
10508 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10514 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10520 if (ctxt->options & XML_PARSE_IGNORE_ENC) {
10538 if ((ctxt->encoding == NULL) &&
10539 (ctxt->input->buf != NULL) &&
10540 (ctxt->input->buf->encoder == NULL)) {
10541 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_ENCODING,
10544 if (ctxt->encoding != NULL)
10545 xmlFree((xmlChar *) ctxt->encoding);
10546 ctxt->encoding = encoding;
10554 if (ctxt->encoding != NULL)
10555 xmlFree((xmlChar *) ctxt->encoding);
10556 ctxt->encoding = encoding;
10561 if (ctxt->input->encoding != NULL)
10562 xmlFree((xmlChar *) ctxt->input->encoding);
10563 ctxt->input->encoding = encoding;
10567 if (xmlSwitchToEncoding(ctxt, handler) < 0) {
10569 ctxt->errNo = XML_ERR_UNSUPPORTED_ENCODING;
10573 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
10584 * @ctxt: an XML parser context
10614 xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
10622 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10637 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10640 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10653 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10656 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10660 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10668 * @ctxt: an XML parser context
10676 xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
10684 ctxt->input->standalone = -2;
10692 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
10700 version = xmlParseVersionInfo(ctxt);
10702 xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
10708 if (ctxt->options & XML_PARSE_OLD10) {
10709 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10714 xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
10718 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10724 if (ctxt->version != NULL)
10725 xmlFree((void *) ctxt->version);
10726 ctxt->version = version;
10737 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10739 xmlParseEncodingDecl(ctxt);
10740 if ((ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) ||
10741 (ctxt->instate == XML_PARSER_EOF)) {
10751 if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
10756 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10765 ctxt->input->standalone = xmlParseSDDecl(ctxt);
10772 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10775 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10783 * @ctxt: an XML parser context
10791 xmlParseMisc(xmlParserCtxtPtr ctxt) {
10792 while ((ctxt->instate != XML_PARSER_EOF) &&
10797 xmlParsePI(ctxt);
10801 xmlParseComment(ctxt);
10807 * @ctxt: an XML parser context
10821 xmlParseDocument(xmlParserCtxtPtr ctxt) {
10827 if ((ctxt == NULL) || (ctxt->input == NULL))
10835 xmlDetectSAX2(ctxt);
10840 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10841 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
10842 if (ctxt->instate == XML_PARSER_EOF)
10845 if ((ctxt->encoding == NULL) &&
10846 ((ctxt->input->end - ctxt->input->cur) >= 4)) {
10858 xmlSwitchEncoding(ctxt, enc);
10864 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10874 if ((ctxt->input->end - ctxt->input->cur) < 35) {
10882 xmlParseXMLDecl(ctxt);
10883 if ((ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) ||
10884 (ctxt->instate == XML_PARSER_EOF)) {
10890 ctxt->standalone = ctxt->input->standalone;
10893 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10895 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10896 ctxt->sax->startDocument(ctxt->userData);
10897 if (ctxt->instate == XML_PARSER_EOF)
10899 if ((ctxt->myDoc != NULL) && (ctxt->input != NULL) &&
10900 (ctxt->input->buf != NULL) && (ctxt->input->buf->compressed >= 0)) {
10901 ctxt->myDoc->compression = ctxt->input->buf->compressed;
10908 xmlParseMisc(ctxt);
10917 ctxt->inSubset = 1;
10918 xmlParseDocTypeDecl(ctxt);
10920 ctxt->instate = XML_PARSER_DTD;
10921 xmlParseInternalSubset(ctxt);
10922 if (ctxt->instate == XML_PARSER_EOF)
10929 ctxt->inSubset = 2;
10930 if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
10931 (!ctxt->disableSAX))
10932 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
10933 ctxt->extSubSystem, ctxt->extSubURI);
10934 if (ctxt->instate == XML_PARSER_EOF)
10936 ctxt->inSubset = 0;
10938 xmlCleanSpecialAttr(ctxt);
10940 ctxt->instate = XML_PARSER_PROLOG;
10941 xmlParseMisc(ctxt);
10949 xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
10952 ctxt->instate = XML_PARSER_CONTENT;
10953 xmlParseElement(ctxt);
10954 ctxt->instate = XML_PARSER_EPILOG;
10960 xmlParseMisc(ctxt);
10963 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10965 ctxt->instate = XML_PARSER_EOF;
10971 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10972 ctxt->sax->endDocument(ctxt->userData);
10977 if ((ctxt->myDoc != NULL) &&
10978 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
10979 xmlFreeDoc(ctxt->myDoc);
10980 ctxt->myDoc = NULL;
10983 if ((ctxt->wellFormed) && (ctxt->myDoc != NULL)) {
10984 ctxt->myDoc->properties |= XML_DOC_WELLFORMED;
10985 if (ctxt->valid)
10986 ctxt->myDoc->properties |= XML_DOC_DTDVALID;
10987 if (ctxt->nsWellFormed)
10988 ctxt->myDoc->properties |= XML_DOC_NSVALID;
10989 if (ctxt->options & XML_PARSE_OLD10)
10990 ctxt->myDoc->properties |= XML_DOC_OLD10;
10992 if (! ctxt->wellFormed) {
10993 ctxt->valid = 0;
11001 * @ctxt: an XML parser context
11014 xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
11018 if ((ctxt == NULL) || (ctxt->input == NULL))
11023 xmlDetectSAX2(ctxt);
11030 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11031 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
11038 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11045 xmlSwitchEncoding(ctxt, enc);
11051 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11063 xmlParseXMLDecl(ctxt);
11064 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
11072 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11074 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
11075 ctxt->sax->startDocument(ctxt->userData);
11076 if (ctxt->instate == XML_PARSER_EOF)
11082 ctxt->instate = XML_PARSER_CONTENT;
11083 ctxt->validate = 0;
11084 ctxt->loadsubset = 0;
11085 ctxt->depth = 0;
11087 xmlParseContent(ctxt);
11088 if (ctxt->instate == XML_PARSER_EOF)
11092 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11094 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11100 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11101 ctxt->sax->endDocument(ctxt->userData);
11103 if (! ctxt->wellFormed) return(-1);
11116 * @ctxt: an XML parser context
11123 * This function has a side effect of (possibly) incrementing ctxt->checkIndex
11131 xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
11137 in = ctxt->input;
11141 if (ctxt->checkIndex > base)
11142 base = ctxt->checkIndex;
11161 ctxt->checkIndex = 0;
11179 ctxt->checkIndex = base;
11196 * @ctxt: an XML parser context
11203 xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
11207 if ((ctxt == NULL) || (lastlt == NULL) || (lastgt == NULL)) {
11212 if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) {
11213 tmp = ctxt->input->end;
11215 while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
11216 if (tmp < ctxt->input->base) {
11222 while ((tmp < ctxt->input->end) && (*tmp != '>')) {
11225 while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++;
11226 if (tmp < ctxt->input->end) tmp++;
11229 while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++;
11230 if (tmp < ctxt->input->end) tmp++;
11234 if (tmp < ctxt->input->end)
11239 while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
11240 if (tmp >= ctxt->input->base)
11321 * @ctxt: an XML parser context
11329 xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
11335 if (ctxt->input == NULL)
11339 switch (ctxt->instate) {
11391 if ((ctxt->input != NULL) &&
11392 (ctxt->input->cur - ctxt->input->base > 4096)) {
11393 xmlSHRINK(ctxt);
11394 ctxt->checkIndex = 0;
11396 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11398 while (ctxt->instate != XML_PARSER_EOF) {
11399 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
11406 while ((RAW == 0) && (ctxt->inputNr > 1))
11407 xmlPopInput(ctxt);
11409 if (ctxt->input == NULL) break;
11410 if (ctxt->input->buf == NULL)
11411 avail = ctxt->input->length -
11412 (ctxt->input->cur - ctxt->input->base);
11421 if ((ctxt->instate != XML_PARSER_START) &&
11422 (ctxt->input->buf->raw != NULL) &&
11423 (xmlBufIsEmpty(ctxt->input->buf->raw) == 0)) {
11424 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer,
11425 ctxt->input);
11426 size_t current = ctxt->input->cur - ctxt->input->base;
11428 xmlParserInputBufferPush(ctxt->input->buf, 0, "");
11429 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input,
11432 avail = xmlBufUse(ctxt->input->buf->buffer) -
11433 (ctxt->input->cur - ctxt->input->base);
11437 switch (ctxt->instate) {
11444 if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
11466 xmlSwitchEncoding(ctxt, enc);
11472 cur = ctxt->input->cur[0];
11473 next = ctxt->input->cur[1];
11475 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11476 ctxt->sax->setDocumentLocator(ctxt->userData,
11478 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11479 xmlHaltParser(ctxt);
11484 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11485 ctxt->sax->endDocument(ctxt->userData);
11492 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11494 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11495 ctxt->sax->setDocumentLocator(ctxt->userData,
11497 if ((ctxt->input->cur[2] == 'x') &&
11498 (ctxt->input->cur[3] == 'm') &&
11499 (ctxt->input->cur[4] == 'l') &&
11500 (IS_BLANK_CH(ctxt->input->cur[5]))) {
11506 xmlParseXMLDecl(ctxt);
11507 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
11512 xmlHaltParser(ctxt);
11515 ctxt->standalone = ctxt->input->standalone;
11516 if ((ctxt->encoding == NULL) &&
11517 (ctxt->input->encoding != NULL))
11518 ctxt->encoding = xmlStrdup(ctxt->input->encoding);
11519 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11520 (!ctxt->disableSAX))
11521 ctxt->sax->startDocument(ctxt->userData);
11522 ctxt->instate = XML_PARSER_MISC;
11528 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11529 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11530 (!ctxt->disableSAX))
11531 ctxt->sax->startDocument(ctxt->userData);
11532 ctxt->instate = XML_PARSER_MISC;
11539 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11540 ctxt->sax->setDocumentLocator(ctxt->userData,
11542 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11543 if (ctxt->version == NULL) {
11544 xmlErrMemory(ctxt, NULL);
11547 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11548 (!ctxt->disableSAX))
11549 ctxt->sax->startDocument(ctxt->userData);
11550 ctxt->instate = XML_PARSER_MISC;
11561 int nsNr = ctxt->nsNr;
11563 if ((avail < 2) && (ctxt->inputNr == 1))
11565 cur = ctxt->input->cur[0];
11567 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11568 xmlHaltParser(ctxt);
11569 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11570 ctxt->sax->endDocument(ctxt->userData);
11574 if (ctxt->progressive) {
11576 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
11578 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
11582 if (ctxt->spaceNr == 0)
11583 spacePush(ctxt, -1);
11584 else if (*ctxt->space == -2)
11585 spacePush(ctxt, -1);
11587 spacePush(ctxt, *ctxt->space);
11589 if (ctxt->sax2)
11591 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
11594 name = xmlParseStartTag(ctxt);
11596 if (ctxt->instate == XML_PARSER_EOF)
11599 spacePop(ctxt);
11600 xmlHaltParser(ctxt);
11601 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11602 ctxt->sax->endDocument(ctxt->userData);
11611 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
11612 ctxt->node && (ctxt->node == ctxt->myDoc->children))
11613 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
11622 if (ctxt->sax2) {
11623 if ((ctxt->sax != NULL) &&
11624 (ctxt->sax->endElementNs != NULL) &&
11625 (!ctxt->disableSAX))
11626 ctxt->sax->endElementNs(ctxt->userData, name,
11628 if (ctxt->nsNr - nsNr > 0)
11629 nsPop(ctxt, ctxt->nsNr - nsNr);
11632 if ((ctxt->sax != NULL) &&
11633 (ctxt->sax->endElement != NULL) &&
11634 (!ctxt->disableSAX))
11635 ctxt->sax->endElement(ctxt->userData, name);
11638 if (ctxt->instate == XML_PARSER_EOF)
11640 spacePop(ctxt);
11641 if (ctxt->nameNr == 0) {
11642 ctxt->instate = XML_PARSER_EPILOG;
11644 ctxt->instate = XML_PARSER_CONTENT;
11646 ctxt->progressive = 1;
11652 xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
11655 nodePop(ctxt);
11656 spacePop(ctxt);
11658 if (ctxt->sax2)
11659 nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
11662 namePush(ctxt, name);
11665 ctxt->instate = XML_PARSER_CONTENT;
11666 ctxt->progressive = 1;
11672 if ((avail < 2) && (ctxt->inputNr == 1))
11674 cur = ctxt->input->cur[0];
11675 next = ctxt->input->cur[1];
11678 cons = ctxt->input->consumed;
11680 ctxt->instate = XML_PARSER_END_TAG;
11684 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11685 ctxt->progressive = XML_PARSER_PI;
11688 xmlParsePI(ctxt);
11689 ctxt->instate = XML_PARSER_CONTENT;
11690 ctxt->progressive = 1;
11692 ctxt->instate = XML_PARSER_START_TAG;
11695 (ctxt->input->cur[2] == '-') &&
11696 (ctxt->input->cur[3] == '-')) {
11701 ctxt->input->cur += 4;
11702 term = xmlParseLookupSequence(ctxt, '-', '-', '>');
11703 ctxt->input->cur -= 4;
11705 ctxt->progressive = XML_PARSER_COMMENT;
11708 xmlParseComment(ctxt);
11709 ctxt->instate = XML_PARSER_CONTENT;
11710 ctxt->progressive = 1;
11711 } else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
11712 (ctxt->input->cur[2] == '[') &&
11713 (ctxt->input->cur[3] == 'C') &&
11714 (ctxt->input->cur[4] == 'D') &&
11715 (ctxt->input->cur[5] == 'A') &&
11716 (ctxt->input->cur[6] == 'T') &&
11717 (ctxt->input->cur[7] == 'A') &&
11718 (ctxt->input->cur[8] == '[')) {
11720 ctxt->instate = XML_PARSER_CDATA_SECTION;
11727 ctxt, ';', 0, 0) < 0))
11729 xmlParseReference(ctxt);
11743 if ((ctxt->inputNr == 1) &&
11746 if (ctxt->progressive) {
11748 (ctxt->input->cur > lastlt))
11750 } else if (xmlParseLookupSequence(ctxt,
11756 ctxt->checkIndex = 0;
11757 xmlParseCharData(ctxt, 0);
11762 while ((RAW == 0) && (ctxt->inputNr > 1))
11763 xmlPopInput(ctxt);
11764 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
11765 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
11767 xmlHaltParser(ctxt);
11776 if (ctxt->progressive) {
11778 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
11780 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
11784 if (ctxt->sax2) {
11785 xmlParseEndTag2(ctxt,
11786 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 3],
11787 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 2], 0,
11788 (int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
11789 nameNsPop(ctxt);
11793 xmlParseEndTag1(ctxt, 0);
11795 if (ctxt->instate == XML_PARSER_EOF) {
11797 } else if (ctxt->nameNr == 0) {
11798 ctxt->instate = XML_PARSER_EPILOG;
11800 ctxt->instate = XML_PARSER_CONTENT;
11810 base = xmlParseLookupSequence(ctxt, ']', ']', '>');
11815 tmp = xmlCheckCdataPush(ctxt->input->cur,
11819 ctxt->input->cur += tmp;
11822 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
11823 if (ctxt->sax->cdataBlock != NULL)
11824 ctxt->sax->cdataBlock(ctxt->userData,
11825 ctxt->input->cur, tmp);
11826 else if (ctxt->sax->characters != NULL)
11827 ctxt->sax->characters(ctxt->userData,
11828 ctxt->input->cur, tmp);
11830 if (ctxt->instate == XML_PARSER_EOF)
11833 ctxt->checkIndex = 0;
11839 tmp = xmlCheckCdataPush(ctxt->input->cur, base, 1);
11842 ctxt->input->cur += tmp;
11845 if ((ctxt->sax != NULL) && (base == 0) &&
11846 (ctxt->sax->cdataBlock != NULL) &&
11847 (!ctxt->disableSAX)) {
11853 if ((ctxt->input->cur - ctxt->input->base >= 9) &&
11854 (!strncmp((const char *)&ctxt->input->cur[-9],
11856 ctxt->sax->cdataBlock(ctxt->userData,
11858 } else if ((ctxt->sax != NULL) && (base > 0) &&
11859 (!ctxt->disableSAX)) {
11860 if (ctxt->sax->cdataBlock != NULL)
11861 ctxt->sax->cdataBlock(ctxt->userData,
11862 ctxt->input->cur, base);
11863 else if (ctxt->sax->characters != NULL)
11864 ctxt->sax->characters(ctxt->userData,
11865 ctxt->input->cur, base);
11867 if (ctxt->instate == XML_PARSER_EOF)
11870 ctxt->checkIndex = 0;
11871 ctxt->instate = XML_PARSER_CONTENT;
11881 if (ctxt->input->buf == NULL)
11882 avail = ctxt->input->length -
11883 (ctxt->input->cur - ctxt->input->base);
11885 avail = xmlBufUse(ctxt->input->buf->buffer) -
11886 (ctxt->input->cur - ctxt->input->base);
11889 cur = ctxt->input->cur[0];
11890 next = ctxt->input->cur[1];
11893 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11894 ctxt->progressive = XML_PARSER_PI;
11901 xmlParsePI(ctxt);
11902 if (ctxt->instate == XML_PARSER_EOF)
11904 ctxt->instate = XML_PARSER_MISC;
11905 ctxt->progressive = 1;
11906 ctxt->checkIndex = 0;
11908 (ctxt->input->cur[2] == '-') &&
11909 (ctxt->input->cur[3] == '-')) {
11911 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
11912 ctxt->progressive = XML_PARSER_COMMENT;
11919 xmlParseComment(ctxt);
11920 if (ctxt->instate == XML_PARSER_EOF)
11922 ctxt->instate = XML_PARSER_MISC;
11923 ctxt->progressive = 1;
11924 ctxt->checkIndex = 0;
11926 (ctxt->input->cur[2] == 'D') &&
11927 (ctxt->input->cur[3] == 'O') &&
11928 (ctxt->input->cur[4] == 'C') &&
11929 (ctxt->input->cur[5] == 'T') &&
11930 (ctxt->input->cur[6] == 'Y') &&
11931 (ctxt->input->cur[7] == 'P') &&
11932 (ctxt->input->cur[8] == 'E')) {
11934 (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0)) {
11935 ctxt->progressive = XML_PARSER_DTD;
11942 ctxt->inSubset = 1;
11943 ctxt->progressive = 0;
11944 ctxt->checkIndex = 0;
11945 xmlParseDocTypeDecl(ctxt);
11946 if (ctxt->instate == XML_PARSER_EOF)
11949 ctxt->instate = XML_PARSER_DTD;
11958 ctxt->inSubset = 2;
11959 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11960 (ctxt->sax->externalSubset != NULL))
11961 ctxt->sax->externalSubset(ctxt->userData,
11962 ctxt->intSubName, ctxt->extSubSystem,
11963 ctxt->extSubURI);
11964 ctxt->inSubset = 0;
11965 xmlCleanSpecialAttr(ctxt);
11966 ctxt->instate = XML_PARSER_PROLOG;
11976 ctxt->instate = XML_PARSER_START_TAG;
11977 ctxt->progressive = XML_PARSER_START_TAG;
11978 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11987 if (ctxt->input->buf == NULL)
11988 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
11990 avail = xmlBufUse(ctxt->input->buf->buffer) -
11991 (ctxt->input->cur - ctxt->input->base);
11994 cur = ctxt->input->cur[0];
11995 next = ctxt->input->cur[1];
11998 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11999 ctxt->progressive = XML_PARSER_PI;
12006 xmlParsePI(ctxt);
12007 if (ctxt->instate == XML_PARSER_EOF)
12009 ctxt->instate = XML_PARSER_PROLOG;
12010 ctxt->progressive = 1;
12012 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
12014 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
12015 ctxt->progressive = XML_PARSER_COMMENT;
12022 xmlParseComment(ctxt);
12023 if (ctxt->instate == XML_PARSER_EOF)
12025 ctxt->instate = XML_PARSER_PROLOG;
12026 ctxt->progressive = 1;
12031 ctxt->instate = XML_PARSER_START_TAG;
12032 if (ctxt->progressive == 0)
12033 ctxt->progressive = XML_PARSER_START_TAG;
12034 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
12043 if (ctxt->input->buf == NULL)
12044 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
12046 avail = xmlBufUse(ctxt->input->buf->buffer) -
12047 (ctxt->input->cur - ctxt->input->base);
12050 cur = ctxt->input->cur[0];
12051 next = ctxt->input->cur[1];
12054 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
12055 ctxt->progressive = XML_PARSER_PI;
12062 xmlParsePI(ctxt);
12063 if (ctxt->instate == XML_PARSER_EOF)
12065 ctxt->instate = XML_PARSER_EPILOG;
12066 ctxt->progressive = 1;
12068 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
12070 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
12071 ctxt->progressive = XML_PARSER_COMMENT;
12078 xmlParseComment(ctxt);
12079 if (ctxt->instate == XML_PARSER_EOF)
12081 ctxt->instate = XML_PARSER_EPILOG;
12082 ctxt->progressive = 1;
12087 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
12088 xmlHaltParser(ctxt);
12093 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
12094 ctxt->sax->endDocument(ctxt->userData);
12114 base = ctxt->input->cur - ctxt->input->base;
12116 if (ctxt->checkIndex > base)
12117 base = ctxt->checkIndex;
12118 buf = xmlBufContent(ctxt->input->buf->buffer);
12119 use = xmlBufUse(ctxt->input->buf->buffer);
12198 ctxt->checkIndex = base;
12200 ctxt->checkIndex = 0;
12209 ctxt->checkIndex = 0;
12210 xmlParseInternalSubset(ctxt);
12211 if (ctxt->instate == XML_PARSER_EOF)
12213 ctxt->inSubset = 2;
12214 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
12215 (ctxt->sax->externalSubset != NULL))
12216 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
12217 ctxt->extSubSystem, ctxt->extSubURI);
12218 ctxt->inSubset = 0;
12219 xmlCleanSpecialAttr(ctxt);
12220 if (ctxt->instate == XML_PARSER_EOF)
12222 ctxt->instate = XML_PARSER_PROLOG;
12223 ctxt->checkIndex = 0;
12233 ctxt->instate = XML_PARSER_CONTENT;
12242 ctxt->instate = XML_PARSER_DTD;
12251 ctxt->instate = XML_PARSER_CONTENT;
12260 ctxt->instate = XML_PARSER_DTD;
12269 ctxt->instate = XML_PARSER_CONTENT;
12278 ctxt->instate = XML_PARSER_START_TAG;
12287 ctxt->instate = XML_PARSER_START_TAG;
12296 ctxt->instate = XML_PARSER_START_TAG;
12314 ctxt->input->cur[0], ctxt->input->cur[1],
12315 ctxt->input->cur[2], ctxt->input->cur[3]);
12316 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
12325 * @ctxt: an XML parser context
12335 xmlParseCheckTransition(xmlParserCtxtPtr ctxt, const char *chunk, int size) {
12336 if ((ctxt == NULL) || (chunk == NULL) || (size < 0))
12338 if (ctxt->instate == XML_PARSER_START_TAG) {
12343 if (ctxt->progressive == XML_PARSER_COMMENT) {
12348 if (ctxt->instate == XML_PARSER_CDATA_SECTION) {
12353 if (ctxt->progressive == XML_PARSER_PI) {
12358 if (ctxt->instate == XML_PARSER_END_TAG) {
12363 if ((ctxt->progressive == XML_PARSER_DTD) ||
12364 (ctxt->instate == XML_PARSER_DTD)) {
12374 * @ctxt: an XML parser context
12384 xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
12391 if (ctxt == NULL)
12393 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
12394 return(ctxt->errNo);
12395 if (ctxt->instate == XML_PARSER_EOF)
12397 if (ctxt->instate == XML_PARSER_START)
12398 xmlDetectSAX2(ctxt);
12407 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
12408 (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF)) {
12409 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
12410 size_t cur = ctxt->input->cur - ctxt->input->base;
12413 old_avail = xmlBufUse(ctxt->input->buf->buffer);
12419 if ((ctxt->instate == XML_PARSER_START) && (ctxt->input != NULL) &&
12420 (ctxt->input->buf != NULL) && (ctxt->input->buf->encoder != NULL)) {
12423 if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12425 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12428 else if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12430 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12434 if (ctxt->input->buf->rawconsumed < len)
12435 len -= ctxt->input->buf->rawconsumed;
12449 res = xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
12451 ctxt->errNo = XML_PARSER_EOF;
12452 xmlHaltParser(ctxt);
12455 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
12460 } else if (ctxt->instate != XML_PARSER_EOF) {
12461 if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
12462 xmlParserInputBufferPtr in = ctxt->input->buf;
12466 size_t base = xmlBufGetInputBase(in->buffer, ctxt->input);
12467 size_t current = ctxt->input->cur - ctxt->input->base;
12476 xmlBufSetInputBaseCur(in->buffer, ctxt->input, base, current);
12481 xmlParseTryOrFinish(ctxt, 0);
12483 if ((ctxt->input != NULL) && (ctxt->input->buf != NULL))
12484 avail = xmlBufUse(ctxt->input->buf->buffer);
12493 (xmlParseCheckTransition(ctxt,
12494 (const char *)&ctxt->input->base[old_avail],
12496 xmlParseTryOrFinish(ctxt, terminate);
12498 if (ctxt->instate == XML_PARSER_EOF)
12499 return(ctxt->errNo);
12501 if ((ctxt->input != NULL) &&
12502 (((ctxt->input->end - ctxt->input->cur) > XML_MAX_LOOKUP_LIMIT) ||
12503 ((ctxt->input->cur - ctxt->input->base) > XML_MAX_LOOKUP_LIMIT)) &&
12504 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
12505 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "Huge input lookup");
12506 xmlHaltParser(ctxt);
12508 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
12509 return(ctxt->errNo);
12517 if ((end_in_lf == 1) && (ctxt->input != NULL) &&
12518 (ctxt->input->buf != NULL)) {
12519 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer,
12520 ctxt->input);
12521 size_t current = ctxt->input->cur - ctxt->input->base;
12523 xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
12525 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input,
12534 if (ctxt->input != NULL) {
12535 if (ctxt->input->buf == NULL)
12536 cur_avail = ctxt->input->length -
12537 (ctxt->input->cur - ctxt->input->base);
12539 cur_avail = xmlBufUse(ctxt->input->buf->buffer) -
12540 (ctxt->input->cur - ctxt->input->base);
12543 if ((ctxt->instate != XML_PARSER_EOF) &&
12544 (ctxt->instate != XML_PARSER_EPILOG)) {
12545 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
12547 if ((ctxt->instate == XML_PARSER_EPILOG) && (cur_avail > 0)) {
12548 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
12550 if (ctxt->instate != XML_PARSER_EOF) {
12551 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
12552 ctxt->sax->endDocument(ctxt->userData);
12554 ctxt->instate = XML_PARSER_EOF;
12556 if (ctxt->wellFormed == 0)
12557 return((xmlParserErrors) ctxt->errNo);
12590 xmlParserCtxtPtr ctxt;
12604 ctxt = xmlNewParserCtxt();
12605 if (ctxt == NULL) {
12610 ctxt->dictNames = 1;
12611 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * sizeof(xmlChar *));
12612 if (ctxt->pushTab == NULL) {
12613 xmlErrMemory(ctxt, NULL);
12615 xmlFreeParserCtxt(ctxt);
12620 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12622 xmlFree(ctxt->sax);
12623 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
12624 if (ctxt->sax == NULL) {
12625 xmlErrMemory(ctxt, NULL);
12627 xmlFreeParserCtxt(ctxt);
12630 memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
12632 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
12634 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12636 ctxt->userData = user_data;
12639 ctxt->directory = NULL;
12641 ctxt->directory = xmlParserGetDirectory(filename);
12644 inputStream = xmlNewInputStream(ctxt);
12646 xmlFreeParserCtxt(ctxt);
12657 xmlFreeParserCtxt(ctxt);
12664 inputPush(ctxt, inputStream);
12672 ctxt->charset = XML_CHAR_ENCODING_NONE;
12673 } else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) {
12674 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
12675 size_t cur = ctxt->input->cur - ctxt->input->base;
12677 xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
12679 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
12686 xmlSwitchEncoding(ctxt, enc);
12689 return(ctxt);
12695 * @ctxt: an XML parser context
12701 xmlHaltParser(xmlParserCtxtPtr ctxt) {
12702 if (ctxt == NULL)
12704 ctxt->instate = XML_PARSER_EOF;
12705 ctxt->disableSAX = 1;
12706 if (ctxt->input != NULL) {
12711 if (ctxt->input->free != NULL) {
12712 ctxt->input->free((xmlChar *) ctxt->input->base);
12713 ctxt->input->free = NULL;
12715 ctxt->input->cur = BAD_CAST"";
12716 ctxt->input->base = ctxt->input->cur;
12722 * @ctxt: an XML parser context
12727 xmlStopParser(xmlParserCtxtPtr ctxt) {
12728 if (ctxt == NULL)
12730 xmlHaltParser(ctxt);
12731 ctxt->errNo = XML_ERR_USER_STOP;
12752 xmlParserCtxtPtr ctxt;
12765 ctxt = xmlNewParserCtxt();
12766 if (ctxt == NULL) {
12772 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12774 xmlFree(ctxt->sax);
12775 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
12776 if (ctxt->sax == NULL) {
12777 xmlErrMemory(ctxt, NULL);
12778 xmlFreeParserCtxt(ctxt);
12781 memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
12783 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
12785 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12787 ctxt->userData = user_data;
12790 inputStream = xmlNewIOInputStream(ctxt, buf, enc);
12792 xmlFreeParserCtxt(ctxt);
12795 inputPush(ctxt, inputStream);
12797 return(ctxt);
12823 xmlParserCtxtPtr ctxt;
12830 ctxt = xmlNewParserCtxt();
12831 if (ctxt == NULL) {
12837 ctxt->options |= XML_PARSE_DTDLOAD;
12843 if (ctxt->sax != NULL)
12844 xmlFree(ctxt->sax);
12845 ctxt->sax = sax;
12846 ctxt->userData = ctxt;
12848 xmlDetectSAX2(ctxt);
12854 pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
12856 if (sax != NULL) ctxt->sax = NULL;
12858 xmlFreeParserCtxt(ctxt);
12865 if (xmlPushInput(ctxt, pinput) < 0) {
12866 if (sax != NULL) ctxt->sax = NULL;
12867 xmlFreeParserCtxt(ctxt);
12871 xmlSwitchEncoding(ctxt, enc);
12877 pinput->base = ctxt->input->cur;
12878 pinput->cur = ctxt->input->cur;
12884 ctxt->inSubset = 2;
12885 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
12886 if (ctxt->myDoc == NULL) {
12887 xmlErrMemory(ctxt, "New Doc failed");
12890 ctxt->myDoc->properties = XML_DOC_INTERNAL;
12891 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
12895 ((ctxt->input->end - ctxt->input->cur) >= 4)) {
12907 xmlSwitchEncoding(ctxt, enc);
12911 xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
12913 if (ctxt->myDoc != NULL) {
12914 if (ctxt->wellFormed) {
12915 ret = ctxt->myDoc->extSubset;
12916 ctxt->myDoc->extSubset = NULL;
12930 xmlFreeDoc(ctxt->myDoc);
12931 ctxt->myDoc = NULL;
12933 if (sax != NULL) ctxt->sax = NULL;
12934 xmlFreeParserCtxt(ctxt);
12954 xmlParserCtxtPtr ctxt;
12961 ctxt = xmlNewParserCtxt();
12962 if (ctxt == NULL) {
12967 ctxt->options |= XML_PARSE_DTDLOAD;
12973 if (ctxt->sax != NULL)
12974 xmlFree(ctxt->sax);
12975 ctxt->sax = sax;
12976 ctxt->userData = ctxt;
12984 xmlFreeParserCtxt(ctxt);
12992 if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
12993 input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
12996 if (sax != NULL) ctxt->sax = NULL;
12997 xmlFreeParserCtxt(ctxt);
13006 if (xmlPushInput(ctxt, input) < 0) {
13007 if (sax != NULL) ctxt->sax = NULL;
13008 xmlFreeParserCtxt(ctxt);
13013 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
13014 enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
13015 xmlSwitchEncoding(ctxt, enc);
13024 input->base = ctxt->input->cur;
13025 input->cur = ctxt->input->cur;
13031 ctxt->inSubset = 2;
13032 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
13033 if (ctxt->myDoc == NULL) {
13034 xmlErrMemory(ctxt, "New Doc failed");
13035 if (sax != NULL) ctxt->sax = NULL;
13036 xmlFreeParserCtxt(ctxt);
13039 ctxt->myDoc->properties = XML_DOC_INTERNAL;
13040 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
13042 xmlParseExternalSubset(ctxt, ExternalID, SystemID);
13044 if (ctxt->myDoc != NULL) {
13045 if (ctxt->wellFormed) {
13046 ret = ctxt->myDoc->extSubset;
13047 ctxt->myDoc->extSubset = NULL;
13061 xmlFreeDoc(ctxt->myDoc);
13062 ctxt->myDoc = NULL;
13064 if (sax != NULL) ctxt->sax = NULL;
13065 xmlFreeParserCtxt(ctxt);
13113 xmlParserCtxtPtr ctxt;
13135 ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, ctx);
13136 if (ctxt == NULL) {
13140 oldsax = ctxt->sax;
13141 ctxt->sax = ctx->sax;
13142 xmlDetectSAX2(ctxt);
13145 xmlFreeParserCtxt(ctxt);
13162 ctxt->sax = oldsax;
13163 xmlFreeParserCtxt(ctxt);
13170 nodePush(ctxt, newDoc->children);
13172 ctxt->myDoc = newDoc;
13174 ctxt->myDoc = ctx->myDoc;
13184 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
13191 xmlSwitchEncoding(ctxt, enc);
13199 xmlParseTextDecl(ctxt);
13204 (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) {
13205 xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH,
13213 * DOM builder is to have userData == ctxt
13216 ctxt->userData = ctxt;
13218 ctxt->userData = ctx->userData;
13223 ctxt->instate = XML_PARSER_CONTENT;
13224 ctxt->validate = ctx->validate;
13225 ctxt->valid = ctx->valid;
13226 ctxt->loadsubset = ctx->loadsubset;
13227 ctxt->depth = ctx->depth + 1;
13228 ctxt->replaceEntities = ctx->replaceEntities;
13229 if (ctxt->validate) {
13230 ctxt->vctxt.error = ctx->vctxt.error;
13231 ctxt->vctxt.warning = ctx->vctxt.warning;
13233 ctxt->vctxt.error = NULL;
13234 ctxt->vctxt.warning = NULL;
13236 ctxt->vctxt.nodeTab = NULL;
13237 ctxt->vctxt.nodeNr = 0;
13238 ctxt->vctxt.nodeMax = 0;
13239 ctxt->vctxt.node = NULL;
13240 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
13241 ctxt->dict = ctx->dict;
13242 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
13243 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
13244 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
13245 ctxt->dictNames = ctx->dictNames;
13246 ctxt->attsDefault = ctx->attsDefault;
13247 ctxt->attsSpecial = ctx->attsSpecial;
13248 ctxt->linenumbers = ctx->linenumbers;
13250 xmlParseContent(ctxt);
13252 ctx->validate = ctxt->validate;
13253 ctx->valid = ctxt->valid;
13255 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13257 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13259 if (ctxt->node != newDoc->children) {
13260 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13263 if (!ctxt->wellFormed) {
13264 if (ctxt->errNo == 0)
13267 ret = ctxt->errNo;
13286 ctxt->sax = oldsax;
13287 ctxt->dict = NULL;
13288 ctxt->attsDefault = NULL;
13289 ctxt->attsSpecial = NULL;
13290 xmlFreeParserCtxt(ctxt);
13320 xmlParserCtxtPtr ctxt;
13342 ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, oldctxt);
13343 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
13344 ctxt->userData = ctxt;
13346 ctxt->_private = oldctxt->_private;
13347 ctxt->loadsubset = oldctxt->loadsubset;
13348 ctxt->validate = oldctxt->validate;
13349 ctxt->external = oldctxt->external;
13350 ctxt->record_info = oldctxt->record_info;
13351 ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
13352 ctxt->node_seq.length = oldctxt->node_seq.length;
13353 ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
13359 ctxt->_private = NULL;
13360 ctxt->validate = 0;
13361 ctxt->external = 2;
13362 ctxt->loadsubset = 0;
13365 oldsax = ctxt->sax;
13366 ctxt->sax = sax;
13368 ctxt->userData = user_data;
13370 xmlDetectSAX2(ctxt);
13373 ctxt->node_seq.maximum = 0;
13374 ctxt->node_seq.length = 0;
13375 ctxt->node_seq.buffer = NULL;
13376 xmlFreeParserCtxt(ctxt);
13391 ctxt->sax = oldsax;
13392 ctxt->node_seq.maximum = 0;
13393 ctxt->node_seq.length = 0;
13394 ctxt->node_seq.buffer = NULL;
13395 xmlFreeParserCtxt(ctxt);
13402 nodePush(ctxt, newDoc->children);
13403 ctxt->myDoc = doc;
13412 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
13419 ctxt, enc);
13427 xmlParseTextDecl(ctxt);
13430 ctxt->instate = XML_PARSER_CONTENT;
13431 ctxt->depth = depth;
13433 xmlParseContent(ctxt);
13436 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13438 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13440 if (ctxt->node != newDoc->children) {
13441 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13444 if (!ctxt->wellFormed) {
13445 if (ctxt->errNo == 0)
13448 ret = (xmlParserErrors)ctxt->errNo;
13473 oldctxt->nbentities += ctxt->nbentities;
13478 if (ctxt->input != NULL && oldctxt != NULL) {
13479 oldctxt->sizeentities += ctxt->input->consumed;
13480 oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base);
13485 if (ctxt->lastError.code != XML_ERR_OK)
13486 xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
13489 ctxt->sax = oldsax;
13491 oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
13492 oldctxt->node_seq.length = ctxt->node_seq.length;
13493 oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
13495 ctxt->node_seq.maximum = 0;
13496 ctxt->node_seq.length = 0;
13497 ctxt->node_seq.buffer = NULL;
13498 xmlFreeParserCtxt(ctxt);
13586 xmlParserCtxtPtr ctxt;
13611 ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
13612 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
13614 ctxt->userData = user_data;
13616 ctxt->userData = ctxt;
13617 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
13618 ctxt->dict = oldctxt->dict;
13619 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
13620 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
13621 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
13626 nsPush(ctxt, oldctxt->nsTab[i], oldctxt->nsTab[i+1]);
13630 oldsax = ctxt->sax;
13631 ctxt->sax = oldctxt->sax;
13632 xmlDetectSAX2(ctxt);
13633 ctxt->replaceEntities = oldctxt->replaceEntities;
13634 ctxt->options = oldctxt->options;
13636 ctxt->_private = oldctxt->_private;
13640 ctxt->sax = oldsax;
13641 ctxt->dict = NULL;
13642 xmlFreeParserCtxt(ctxt);
13646 newDoc->dict = ctxt->dict;
13648 ctxt->myDoc = newDoc;
13650 ctxt->myDoc = oldctxt->myDoc;
13651 content = ctxt->myDoc->children;
13652 last = ctxt->myDoc->last;
13654 newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
13656 ctxt->sax = oldsax;
13657 ctxt->dict = NULL;
13658 xmlFreeParserCtxt(ctxt);
13664 ctxt->myDoc->children = NULL;
13665 ctxt->myDoc->last = NULL;
13666 xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
13667 nodePush(ctxt, ctxt->myDoc->children);
13668 ctxt->instate = XML_PARSER_CONTENT;
13669 ctxt->depth = oldctxt->depth + 1;
13671 ctxt->validate = 0;
13672 ctxt->loadsubset = oldctxt->loadsubset;
13677 ctxt->loadsubset |= XML_SKIP_IDS;
13679 ctxt->dictNames = oldctxt->dictNames;
13680 ctxt->attsDefault = oldctxt->attsDefault;
13681 ctxt->attsSpecial = oldctxt->attsSpecial;
13683 xmlParseContent(ctxt);
13685 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13687 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13689 if (ctxt->node != ctxt->myDoc->children) {
13690 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13693 if (!ctxt->wellFormed) {
13694 if (ctxt->errNo == 0)
13697 ret = (xmlParserErrors)ctxt->errNo;
13709 cur = ctxt->myDoc->children->children;
13723 ctxt->myDoc->children->children = NULL;
13725 if (ctxt->myDoc != NULL) {
13726 xmlFreeNode(ctxt->myDoc->children);
13727 ctxt->myDoc->children = content;
13728 ctxt->myDoc->last = last;
13736 oldctxt->nbentities += ctxt->nbentities;
13741 if (ctxt->lastError.code != XML_ERR_OK)
13742 xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
13744 ctxt->sax = oldsax;
13745 ctxt->dict = NULL;
13746 ctxt->attsDefault = NULL;
13747 ctxt->attsSpecial = NULL;
13748 xmlFreeParserCtxt(ctxt);
13779 xmlParserCtxtPtr ctxt;
13824 ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
13827 ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
13838 if (ctxt == NULL)
13847 if (ctxt->dict != NULL)
13848 xmlDictFree(ctxt->dict);
13849 ctxt->dict = doc->dict;
13856 if (ctxt->encoding != NULL)
13857 xmlFree((xmlChar *) ctxt->encoding);
13858 ctxt->encoding = xmlStrdup((const xmlChar *) doc->encoding);
13862 xmlSwitchToEncoding(ctxt, hdlr);
13868 xmlCtxtUseOptionsInternal(ctxt, options, NULL);
13869 xmlDetectSAX2(ctxt);
13870 ctxt->myDoc = doc;
13872 ctxt->instate = XML_PARSER_CONTENT;
13876 xmlFreeParserCtxt(ctxt);
13882 nodePush(ctxt, node);
13892 if (ctxt->dict) {
13893 iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
13894 ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
13900 if (xmlGetNamespace(ctxt, iprefix) == NULL) {
13901 nsPush(ctxt, iprefix, ihref);
13910 if ((ctxt->validate) || (ctxt->replaceEntities != 0)) {
13914 ctxt->loadsubset |= XML_SKIP_IDS;
13919 __htmlParseContent(ctxt);
13922 xmlParseContent(ctxt);
13924 nsPop(ctxt, nsnr);
13926 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13928 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13930 if ((ctxt->node != NULL) && (ctxt->node != node)) {
13931 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13932 ctxt->wellFormed = 0;
13935 if (!ctxt->wellFormed) {
13936 if (ctxt->errNo == 0)
13939 ret = (xmlParserErrors)ctxt->errNo;
13974 ctxt->dict = NULL;
13975 xmlFreeParserCtxt(ctxt);
14013 xmlParserCtxtPtr ctxt;
14032 ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
14033 if (ctxt == NULL) return(-1);
14034 ctxt->userData = ctxt;
14036 oldsax = ctxt->sax;
14037 ctxt->sax = sax;
14039 ctxt->userData = user_data;
14043 xmlFreeParserCtxt(ctxt);
14048 xmlDictFree(ctxt->dict);
14049 ctxt->dict = doc->dict;
14050 xmlDictReference(ctxt->dict);
14051 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
14052 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
14053 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
14054 ctxt->dictNames = 1;
14056 xmlCtxtUseOptionsInternal(ctxt, XML_PARSE_NODICT, NULL);
14065 ctxt->sax = oldsax;
14066 xmlFreeParserCtxt(ctxt);
14073 nodePush(ctxt, newRoot);
14075 ctxt->myDoc = newDoc;
14077 ctxt->myDoc = newDoc;
14083 ctxt->instate = XML_PARSER_CONTENT;
14084 ctxt->depth = depth;
14089 ctxt->validate = 0;
14090 ctxt->loadsubset = 0;
14091 xmlDetectSAX2(ctxt);
14096 xmlParseContent(ctxt);
14100 xmlParseContent(ctxt);
14103 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
14105 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
14107 if (ctxt->node != newDoc->children) {
14108 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
14111 if (!ctxt->wellFormed) {
14112 if (ctxt->errNo == 0)
14115 ret = ctxt->errNo;
14138 ctxt->sax = oldsax;
14139 xmlFreeParserCtxt(ctxt);
14167 xmlParserCtxtPtr ctxt;
14169 ctxt = xmlCreateFileParserCtxt(filename);
14170 if (ctxt == NULL) {
14174 if (ctxt->sax != NULL)
14175 xmlFree(ctxt->sax);
14176 ctxt->sax = sax;
14177 ctxt->userData = NULL;
14180 xmlParseExtParsedEnt(ctxt);
14182 if (ctxt->wellFormed)
14183 ret = ctxt->myDoc;
14186 xmlFreeDoc(ctxt->myDoc);
14187 ctxt->myDoc = NULL;
14190 ctxt->sax = NULL;
14191 xmlFreeParserCtxt(ctxt);
14231 xmlParserCtxtPtr ctxt;
14236 ctxt = xmlNewParserCtxt();
14237 if (ctxt == NULL) {
14242 ctxt->options = pctx->options;
14243 ctxt->_private = pctx->_private;
14249 inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
14251 xmlFreeParserCtxt(ctxt);
14255 inputPush(ctxt, inputStream);
14257 if ((ctxt->directory == NULL) && (directory == NULL))
14259 if ((ctxt->directory == NULL) && (directory != NULL))
14260 ctxt->directory = directory;
14262 inputStream = xmlLoadExternalEntity((char *)uri, (char *)ID, ctxt);
14265 xmlFreeParserCtxt(ctxt);
14269 inputPush(ctxt, inputStream);
14271 if ((ctxt->directory == NULL) && (directory == NULL))
14273 if ((ctxt->directory == NULL) && (directory != NULL))
14274 ctxt->directory = directory;
14277 return(ctxt);
14319 xmlParserCtxtPtr ctxt;
14323 ctxt = xmlNewParserCtxt();
14324 if (ctxt == NULL) {
14330 xmlCtxtUseOptionsInternal(ctxt, options, NULL);
14331 ctxt->linenumbers = 1;
14333 inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
14335 xmlFreeParserCtxt(ctxt);
14339 inputPush(ctxt, inputStream);
14340 if ((ctxt->directory == NULL) && (directory == NULL))
14342 if ((ctxt->directory == NULL) && (directory != NULL))
14343 ctxt->directory = directory;
14345 return(ctxt);
14388 xmlParserCtxtPtr ctxt;
14392 ctxt = xmlCreateFileParserCtxt(filename);
14393 if (ctxt == NULL) {
14397 if (ctxt->sax != NULL)
14398 xmlFree(ctxt->sax);
14399 ctxt->sax = sax;
14401 xmlDetectSAX2(ctxt);
14403 ctxt->_private = data;
14406 if (ctxt->directory == NULL)
14407 ctxt->directory = xmlParserGetDirectory(filename);
14409 ctxt->recovery = recovery;
14411 xmlParseDocument(ctxt);
14413 if ((ctxt->wellFormed) || recovery) {
14414 ret = ctxt->myDoc;
14416 if (ctxt->input->buf->compressed > 0)
14419 ret->compression = ctxt->input->buf->compressed;
14424 xmlFreeDoc(ctxt->myDoc);
14425 ctxt->myDoc = NULL;
14428 ctxt->sax = NULL;
14429 xmlFreeParserCtxt(ctxt);
14507 * @ctxt: an XML parser context
14516 xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
14521 if ((ctxt == NULL) || (buffer == NULL))
14524 input = xmlNewInputStream(ctxt);
14527 xmlClearParserCtxt(ctxt);
14531 xmlClearParserCtxt(ctxt);
14537 inputPush(ctxt, input);
14555 xmlParserCtxtPtr ctxt;
14557 ctxt = xmlCreateFileParserCtxt(filename);
14558 if (ctxt == NULL) return -1;
14559 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
14560 xmlFree(ctxt->sax);
14561 ctxt->sax = sax;
14562 xmlDetectSAX2(ctxt);
14565 ctxt->userData = user_data;
14567 xmlParseDocument(ctxt);
14569 if (ctxt->wellFormed)
14572 if (ctxt->errNo != 0)
14573 ret = ctxt->errNo;
14578 ctxt->sax = NULL;
14579 if (ctxt->myDoc != NULL) {
14580 xmlFreeDoc(ctxt->myDoc);
14581 ctxt->myDoc = NULL;
14583 xmlFreeParserCtxt(ctxt);
14606 xmlParserCtxtPtr ctxt;
14615 ctxt = xmlNewParserCtxt();
14616 if (ctxt == NULL)
14622 xmlFreeParserCtxt(ctxt);
14626 input = xmlNewInputStream(ctxt);
14629 xmlFreeParserCtxt(ctxt);
14637 inputPush(ctxt, input);
14638 return(ctxt);
14665 xmlParserCtxtPtr ctxt;
14669 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
14670 if (ctxt == NULL) return(NULL);
14672 if (ctxt->sax != NULL)
14673 xmlFree(ctxt->sax);
14674 ctxt->sax = sax;
14676 xmlDetectSAX2(ctxt);
14678 ctxt->_private=data;
14681 ctxt->recovery = recovery;
14683 xmlParseDocument(ctxt);
14685 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
14688 xmlFreeDoc(ctxt->myDoc);
14689 ctxt->myDoc = NULL;
14692 ctxt->sax = NULL;
14693 xmlFreeParserCtxt(ctxt);
14763 xmlParserCtxtPtr ctxt;
14767 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
14768 if (ctxt == NULL) return -1;
14769 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
14770 xmlFree(ctxt->sax);
14771 ctxt->sax = sax;
14772 xmlDetectSAX2(ctxt);
14775 ctxt->userData = user_data;
14777 xmlParseDocument(ctxt);
14779 if (ctxt->wellFormed)
14782 if (ctxt->errNo != 0)
14783 ret = ctxt->errNo;
14788 ctxt->sax = NULL;
14789 if (ctxt->myDoc != NULL) {
14790 xmlFreeDoc(ctxt->myDoc);
14791 ctxt->myDoc = NULL;
14793 xmlFreeParserCtxt(ctxt);
14835 xmlParserCtxtPtr ctxt;
14841 ctxt = xmlCreateDocParserCtxt(cur);
14842 if (ctxt == NULL) return(NULL);
14844 oldsax = ctxt->sax;
14845 ctxt->sax = sax;
14846 ctxt->userData = NULL;
14848 xmlDetectSAX2(ctxt);
14850 xmlParseDocument(ctxt);
14851 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
14854 xmlFreeDoc(ctxt->myDoc);
14855 ctxt->myDoc = NULL;
14858 ctxt->sax = oldsax;
14859 xmlFreeParserCtxt(ctxt);
15044 * @ctxt: an XML parser context
15049 xmlCtxtReset(xmlParserCtxtPtr ctxt)
15054 if (ctxt == NULL)
15057 dict = ctxt->dict;
15059 while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
15062 ctxt->inputNr = 0;
15063 ctxt->input = NULL;
15065 ctxt->spaceNr = 0;
15066 if (ctxt->spaceTab != NULL) {
15067 ctxt->spaceTab[0] = -1;
15068 ctxt->space = &ctxt->spaceTab[0];
15070 ctxt->space = NULL;
15074 ctxt->nodeNr = 0;
15075 ctxt->node = NULL;
15077 ctxt->nameNr = 0;
15078 ctxt->name = NULL;
15080 DICT_FREE(ctxt->version);
15081 ctxt->version = NULL;
15082 DICT_FREE(ctxt->encoding);
15083 ctxt->encoding = NULL;
15084 DICT_FREE(ctxt->directory);
15085 ctxt->directory = NULL;
15086 DICT_FREE(ctxt->extSubURI);
15087 ctxt->extSubURI = NULL;
15088 DICT_FREE(ctxt->extSubSystem);
15089 ctxt->extSubSystem = NULL;
15090 if (ctxt->myDoc != NULL)
15091 xmlFreeDoc(ctxt->myDoc);
15092 ctxt->myDoc = NULL;
15094 ctxt->standalone = -1;
15095 ctxt->hasExternalSubset = 0;
15096 ctxt->hasPErefs = 0;
15097 ctxt->html = 0;
15098 ctxt->external = 0;
15099 ctxt->instate = XML_PARSER_START;
15100 ctxt->token = 0;
15102 ctxt->wellFormed = 1;
15103 ctxt->nsWellFormed = 1;
15104 ctxt->disableSAX = 0;
15105 ctxt->valid = 1;
15107 ctxt->vctxt.userData = ctxt;
15108 ctxt->vctxt.error = xmlParserValidityError;
15109 ctxt->vctxt.warning = xmlParserValidityWarning;
15111 ctxt->record_info = 0;
15112 ctxt->nbChars = 0;
15113 ctxt->checkIndex = 0;
15114 ctxt->inSubset = 0;
15115 ctxt->errNo = XML_ERR_OK;
15116 ctxt->depth = 0;
15117 ctxt->charset = XML_CHAR_ENCODING_UTF8;
15118 ctxt->catalogs = NULL;
15119 ctxt->nbentities = 0;
15120 ctxt->sizeentities = 0;
15121 ctxt->sizeentcopy = 0;
15122 xmlInitNodeInfoSeq(&ctxt->node_seq);
15124 if (ctxt->attsDefault != NULL) {
15125 xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
15126 ctxt->attsDefault = NULL;
15128 if (ctxt->attsSpecial != NULL) {
15129 xmlHashFree(ctxt->attsSpecial, NULL);
15130 ctxt->attsSpecial = NULL;
15134 if (ctxt->catalogs != NULL)
15135 xmlCatalogFreeLocal(ctxt->catalogs);
15137 if (ctxt->lastError.code != XML_ERR_OK)
15138 xmlResetError(&ctxt->lastError);
15143 * @ctxt: an XML parser context
15154 xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
15161 if (ctxt == NULL)
15171 if (ctxt == NULL) {
15176 xmlCtxtReset(ctxt);
15178 if (ctxt->pushTab == NULL) {
15179 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 *
15181 if (ctxt->pushTab == NULL) {
15182 xmlErrMemory(ctxt, NULL);
15189 ctxt->directory = NULL;
15191 ctxt->directory = xmlParserGetDirectory(filename);
15194 inputStream = xmlNewInputStream(ctxt);
15208 inputPush(ctxt, inputStream);
15210 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
15211 (ctxt->input->buf != NULL)) {
15212 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
15213 size_t cur = ctxt->input->cur - ctxt->input->base;
15215 xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
15217 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
15226 if (ctxt->encoding != NULL)
15227 xmlFree((xmlChar *) ctxt->encoding);
15228 ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
15232 xmlSwitchToEncoding(ctxt, hdlr);
15234 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
15238 xmlSwitchEncoding(ctxt, enc);
15247 * @ctxt: an XML parser context
15257 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, const char *encoding)
15259 if (ctxt == NULL)
15262 if (ctxt->encoding != NULL)
15263 xmlFree((xmlChar *) ctxt->encoding);
15264 ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
15267 ctxt->recovery = 1;
15269 ctxt->options |= XML_PARSE_RECOVER;
15271 ctxt->recovery = 0;
15273 ctxt->loadsubset = XML_DETECT_IDS;
15275 ctxt->options |= XML_PARSE_DTDLOAD;
15277 ctxt->loadsubset = 0;
15279 ctxt->loadsubset |= XML_COMPLETE_ATTRS;
15281 ctxt->options |= XML_PARSE_DTDATTR;
15284 ctxt->replaceEntities = 1;
15285 /* ctxt->loadsubset |= XML_DETECT_IDS; */
15287 ctxt->options |= XML_PARSE_NOENT;
15289 ctxt->replaceEntities = 0;
15291 ctxt->pedantic = 1;
15293 ctxt->options |= XML_PARSE_PEDANTIC;
15295 ctxt->pedantic = 0;
15297 ctxt->keepBlanks = 0;
15298 ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
15300 ctxt->options |= XML_PARSE_NOBLANKS;
15302 ctxt->keepBlanks = 1;
15304 ctxt->validate = 1;
15306 ctxt->vctxt.warning = NULL;
15308 ctxt->vctxt.error = NULL;
15310 ctxt->options |= XML_PARSE_DTDVALID;
15312 ctxt->validate = 0;
15314 ctxt->sax->warning = NULL;
15318 ctxt->sax->error = NULL;
15319 ctxt->sax->fatalError = NULL;
15324 ctxt->sax->startElement = xmlSAX2StartElement;
15325 ctxt->sax->endElement = xmlSAX2EndElement;
15326 ctxt->sax->startElementNs = NULL;
15327 ctxt->sax->endElementNs = NULL;
15328 ctxt->sax->initialized = 1;
15330 ctxt->options |= XML_PARSE_SAX1;
15334 ctxt->dictNames = 0;
15336 ctxt->options |= XML_PARSE_NODICT;
15338 ctxt->dictNames = 1;
15341 ctxt->sax->cdataBlock = NULL;
15343 ctxt->options |= XML_PARSE_NOCDATA;
15346 ctxt->options |= XML_PARSE_NSCLEAN;
15350 ctxt->options |= XML_PARSE_NONET;
15354 ctxt->options |= XML_PARSE_COMPACT;
15358 ctxt->options |= XML_PARSE_OLD10;
15362 ctxt->options |= XML_PARSE_NOBASEFIX;
15366 ctxt->options |= XML_PARSE_HUGE;
15368 if (ctxt->dict != NULL)
15369 xmlDictSetLimit(ctxt->dict, 0);
15372 ctxt->options |= XML_PARSE_OLDSAX;
15376 ctxt->options |= XML_PARSE_IGNORE_ENC;
15380 ctxt->options |= XML_PARSE_BIG_LINES;
15383 ctxt->linenumbers = 1;
15389 * @ctxt: an XML parser context
15398 xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
15400 return(xmlCtxtUseOptionsInternal(ctxt, options, NULL));
15405 * @ctxt: an XML parser context
15416 xmlDoRead(xmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
15421 xmlCtxtUseOptionsInternal(ctxt, options, encoding);
15427 xmlSwitchToEncoding(ctxt, hdlr);
15429 if ((URL != NULL) && (ctxt->input != NULL) &&
15430 (ctxt->input->filename == NULL))
15431 ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
15432 xmlParseDocument(ctxt);
15433 if ((ctxt->wellFormed) || ctxt->recovery)
15434 ret = ctxt->myDoc;
15437 if (ctxt->myDoc != NULL) {
15438 xmlFreeDoc(ctxt->myDoc);
15441 ctxt->myDoc = NULL;
15443 xmlFreeParserCtxt(ctxt);
15463 xmlParserCtxtPtr ctxt;
15469 ctxt = xmlCreateDocParserCtxt(cur);
15470 if (ctxt == NULL)
15472 return (xmlDoRead(ctxt, URL, encoding, options, 0));
15488 xmlParserCtxtPtr ctxt;
15491 ctxt = xmlCreateURLParserCtxt(filename, options);
15492 if (ctxt == NULL)
15494 return (xmlDoRead(ctxt, NULL, encoding, options, 0));
15512 xmlParserCtxtPtr ctxt;
15515 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
15516 if (ctxt == NULL)
15518 return (xmlDoRead(ctxt, URL, encoding, options, 0));
15537 xmlParserCtxtPtr ctxt;
15549 ctxt = xmlNewParserCtxt();
15550 if (ctxt == NULL) {
15554 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15557 xmlFreeParserCtxt(ctxt);
15560 inputPush(ctxt, stream);
15561 return (xmlDoRead(ctxt, URL, encoding, options, 0));
15581 xmlParserCtxtPtr ctxt;
15596 ctxt = xmlNewParserCtxt();
15597 if (ctxt == NULL) {
15601 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15604 xmlFreeParserCtxt(ctxt);
15607 inputPush(ctxt, stream);
15608 return (xmlDoRead(ctxt, URL, encoding, options, 0));
15613 * @ctxt: an XML parser context
15620 * This reuses the existing @ctxt parser context
15625 xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
15632 if (ctxt == NULL)
15636 xmlCtxtReset(ctxt);
15638 stream = xmlNewStringInputStream(ctxt, cur);
15642 inputPush(ctxt, stream);
15643 return (xmlDoRead(ctxt, URL, encoding, options, 1));
15648 * @ctxt: an XML parser context
15654 * This reuses the existing @ctxt parser context
15659 xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
15666 if (ctxt == NULL)
15670 xmlCtxtReset(ctxt);
15672 stream = xmlLoadExternalEntity(filename, NULL, ctxt);
15676 inputPush(ctxt, stream);
15677 return (xmlDoRead(ctxt, NULL, encoding, options, 1));
15682 * @ctxt: an XML parser context
15690 * This reuses the existing @ctxt parser context
15695 xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
15701 if (ctxt == NULL)
15707 xmlCtxtReset(ctxt);
15714 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15720 inputPush(ctxt, stream);
15721 return (xmlDoRead(ctxt, URL, encoding, options, 1));
15726 * @ctxt: an XML parser context
15733 * This reuses the existing @ctxt parser context
15740 xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
15748 if (ctxt == NULL)
15752 xmlCtxtReset(ctxt);
15759 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15764 inputPush(ctxt, stream);
15765 return (xmlDoRead(ctxt, URL, encoding, options, 1));
15770 * @ctxt: an XML parser context
15779 * This reuses the existing @ctxt parser context
15784 xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
15794 if (ctxt == NULL)
15798 xmlCtxtReset(ctxt);
15807 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15812 inputPush(ctxt, stream);
15813 return (xmlDoRead(ctxt, URL, encoding, options, 1));
