Lines Matching full: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 ((rep == NULL) || (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);
1149 xmlAttrNormalizeSpace2(xmlParserCtxtPtr ctxt, xmlChar *src, int *len)
1156 if ((ctxt == NULL) || (src == NULL) || (len == NULL))
1182 xmlErrMemory(ctxt, NULL);
1198 * @ctxt: an XML parser context
1206 xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
1218 if (ctxt->attsSpecial != NULL) {
1219 if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1223 if (ctxt->attsDefault == NULL) {
1224 ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
1225 if (ctxt->attsDefault == NULL)
1235 name = xmlDictLookup(ctxt->dict, fullname, -1);
1238 name = xmlDictLookup(ctxt->dict, name, -1);
1239 prefix = xmlDictLookup(ctxt->dict, fullname, len);
1245 defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
1253 if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1267 if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1280 name = xmlDictLookup(ctxt->dict, fullattr, -1);
1283 name = xmlDictLookup(ctxt->dict, name, -1);
1284 prefix = xmlDictLookup(ctxt->dict, fullattr, len);
1291 value = xmlDictLookup(ctxt->dict, value, len);
1294 if (ctxt->external)
1303 xmlErrMemory(ctxt, NULL);
1309 * @ctxt: an XML parser context
1317 xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
1322 if (ctxt->attsSpecial == NULL) {
1323 ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
1324 if (ctxt->attsSpecial == NULL)
1328 if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1331 xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
1336 xmlErrMemory(ctxt, NULL);
1349 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data;
1352 xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL);
1358 * @ctxt: an XML parser context
1365 xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt)
1367 if (ctxt->attsSpecial == NULL)
1370 xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt);
1372 if (xmlHashSize(ctxt->attsSpecial) == 0) {
1373 xmlHashFree(ctxt->attsSpecial, NULL);
1374 ctxt->attsSpecial = NULL;
1579 static xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
1585 * @ctxt: an XML parser context
1595 nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL)
1597 if (ctxt->options & XML_PARSE_NSCLEAN) {
1599 for (i = ctxt->nsNr - 2;i >= 0;i -= 2) {
1600 if (ctxt->nsTab[i] == prefix) {
1602 if (ctxt->nsTab[i + 1] == URL)
1609 if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) {
1610 ctxt->nsMax = 10;
1611 ctxt->nsNr = 0;
1612 ctxt->nsTab = (const xmlChar **)
1613 xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
1614 if (ctxt->nsTab == NULL) {
1615 xmlErrMemory(ctxt, NULL);
1616 ctxt->nsMax = 0;
1619 } else if (ctxt->nsNr >= ctxt->nsMax) {
1621 ctxt->nsMax *= 2;
1622 tmp = (const xmlChar **) xmlRealloc((char *) ctxt->nsTab,
1623 ctxt->nsMax * sizeof(ctxt->nsTab[0]));
1625 xmlErrMemory(ctxt, NULL);
1626 ctxt->nsMax /= 2;
1629 ctxt->nsTab = tmp;
1631 ctxt->nsTab[ctxt->nsNr++] = prefix;
1632 ctxt->nsTab[ctxt->nsNr++] = URL;
1633 return (ctxt->nsNr);
1637 * @ctxt: an XML parser context
1645 nsPop(xmlParserCtxtPtr ctxt, int nr)
1649 if (ctxt->nsTab == NULL) return(0);
1650 if (ctxt->nsNr < nr) {
1652 nr = ctxt->nsNr;
1654 if (ctxt->nsNr <= 0)
1658 ctxt->nsNr--;
1659 ctxt->nsTab[ctxt->nsNr] = NULL;
1666 xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
1671 if (ctxt->atts == NULL) {
1676 ctxt->atts = atts;
1679 ctxt->attallocs = attallocs;
1680 ctxt->maxatts = maxatts;
1681 } else if (nr + 5 > ctxt->maxatts) {
1683 atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts,
1686 ctxt->atts = atts;
1687 attallocs = (int *) xmlRealloc((void *) ctxt->attallocs,
1690 ctxt->attallocs = attallocs;
1691 ctxt->maxatts = maxatts;
1693 return(ctxt->maxatts);
1695 xmlErrMemory(ctxt, NULL);
1701 * @ctxt: an XML parser context
1709 inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
1711 if ((ctxt == NULL) || (value == NULL))
1713 if (ctxt->inputNr >= ctxt->inputMax) {
1714 ctxt->inputMax *= 2;
1715 ctxt->inputTab =
1716 (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
1717 ctxt->inputMax *
1718 sizeof(ctxt->inputTab[0]));
1719 if (ctxt->inputTab == NULL) {
1720 xmlErrMemory(ctxt, NULL);
1722 ctxt->inputMax /= 2;
1727 ctxt->inputTab[ctxt->inputNr] = value;
1728 ctxt->input = value;
1729 return (ctxt->inputNr++);
1733 * @ctxt: an XML parser context
1740 inputPop(xmlParserCtxtPtr ctxt)
1744 if (ctxt == NULL)
1746 if (ctxt->inputNr <= 0)
1748 ctxt->inputNr--;
1749 if (ctxt->inputNr > 0)
1750 ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
1752 ctxt->input = NULL;
1753 ret = ctxt->inputTab[ctxt->inputNr];
1754 ctxt->inputTab[ctxt->inputNr] = NULL;
1759 * @ctxt: an XML parser context
1767 nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
1769 if (ctxt == NULL) return(0);
1770 if (ctxt->nodeNr >= ctxt->nodeMax) {
1773 tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
1774 ctxt->nodeMax * 2 *
1775 sizeof(ctxt->nodeTab[0]));
1777 xmlErrMemory(ctxt, NULL);
1780 ctxt->nodeTab = tmp;
1781 ctxt->nodeMax *= 2;
1783 if ((((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) &&
1784 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
1785 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
1788 xmlHaltParser(ctxt);
1791 ctxt->nodeTab[ctxt->nodeNr] = value;
1792 ctxt->node = value;
1793 return (ctxt->nodeNr++);
1798 * @ctxt: an XML parser context
1805 nodePop(xmlParserCtxtPtr ctxt)
1809 if (ctxt == NULL) return(NULL);
1810 if (ctxt->nodeNr <= 0)
1812 ctxt->nodeNr--;
1813 if (ctxt->nodeNr > 0)
1814 ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
1816 ctxt->node = NULL;
1817 ret = ctxt->nodeTab[ctxt->nodeNr];
1818 ctxt->nodeTab[ctxt->nodeNr] = NULL;
1825 * @ctxt: an XML parser context
1835 nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
1838 if (ctxt->nameNr >= ctxt->nameMax) {
1841 ctxt->nameMax *= 2;
1842 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1843 ctxt->nameMax *
1844 sizeof(ctxt->nameTab[0]));
1846 ctxt->nameMax /= 2;
1849 ctxt->nameTab = tmp;
1850 tmp2 = (void **) xmlRealloc((void * *)ctxt->pushTab,
1851 ctxt->nameMax * 3 *
1852 sizeof(ctxt->pushTab[0]));
1854 ctxt->nameMax /= 2;
1857 ctxt->pushTab = tmp2;
1859 ctxt->nameTab[ctxt->nameNr] = value;
1860 ctxt->name = value;
1861 ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix;
1862 ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI;
1863 ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (ptrdiff_t) nsNr;
1864 return (ctxt->nameNr++);
1866 xmlErrMemory(ctxt, NULL);
1871 * @ctxt: an XML parser context
1878 nameNsPop(xmlParserCtxtPtr ctxt)
1882 if (ctxt->nameNr <= 0)
1884 ctxt->nameNr--;
1885 if (ctxt->nameNr > 0)
1886 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1888 ctxt->name = NULL;
1889 ret = ctxt->nameTab[ctxt->nameNr];
1890 ctxt->nameTab[ctxt->nameNr] = NULL;
1897 * @ctxt: an XML parser context
1905 namePush(xmlParserCtxtPtr ctxt, const xmlChar * value)
1907 if (ctxt == NULL) return (-1);
1909 if (ctxt->nameNr >= ctxt->nameMax) {
1911 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1912 ctxt->nameMax * 2 *
1913 sizeof(ctxt->nameTab[0]));
1917 ctxt->nameTab = tmp;
1918 ctxt->nameMax *= 2;
1920 ctxt->nameTab[ctxt->nameNr] = value;
1921 ctxt->name = value;
1922 return (ctxt->nameNr++);
1924 xmlErrMemory(ctxt, NULL);
1929 * @ctxt: an XML parser context
1936 namePop(xmlParserCtxtPtr ctxt)
1940 if ((ctxt == NULL) || (ctxt->nameNr <= 0))
1942 ctxt->nameNr--;
1943 if (ctxt->nameNr > 0)
1944 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1946 ctxt->name = NULL;
1947 ret = ctxt->nameTab[ctxt->nameNr];
1948 ctxt->nameTab[ctxt->nameNr] = NULL;
1952 static int spacePush(xmlParserCtxtPtr ctxt, int val) {
1953 if (ctxt->spaceNr >= ctxt->spaceMax) {
1956 ctxt->spaceMax *= 2;
1957 tmp = (int *) xmlRealloc(ctxt->spaceTab,
1958 ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
1960 xmlErrMemory(ctxt, NULL);
1961 ctxt->spaceMax /=2;
1964 ctxt->spaceTab = tmp;
1966 ctxt->spaceTab[ctxt->spaceNr] = val;
1967 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
1968 return(ctxt->spaceNr++);
1971 static int spacePop(xmlParserCtxtPtr ctxt) {
1973 if (ctxt->spaceNr <= 0) return(0);
1974 ctxt->spaceNr--;
1975 if (ctxt->spaceNr > 0)
1976 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
1978 ctxt->space = &ctxt->spaceTab[0];
1979 ret = ctxt->spaceTab[ctxt->spaceNr];
1980 ctxt->spaceTab[ctxt->spaceNr] = -1;
2019 #define RAW (*ctxt->input->cur)
2020 #define CUR (*ctxt->input->cur)
2021 #define NXT(val) ctxt->input->cur[(val)]
2022 #define CUR_PTR ctxt->input->cur
2023 #define BASE_PTR ctxt->input->base
2044 ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val); \
2045 if (*ctxt->input->cur == 0) \
2046 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); \
2052 if (*(ctxt->input->cur) == '\n') { \
2053 ctxt->input->line++; ctxt->input->col = 1; \
2054 } else ctxt->input->col++; \
2055 ctxt->nbChars++; \
2056 ctxt->input->cur++; \
2058 if (*ctxt->input->cur == 0) \
2059 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); \
2062 #define SHRINK if ((ctxt->progressive == 0) && \
2063 (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
2064 (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
2065 xmlSHRINK (ctxt);
2067 static void xmlSHRINK (xmlParserCtxtPtr ctxt) {
2068 xmlParserInputShrink(ctxt->input);
2069 if (*ctxt->input->cur == 0)
2070 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
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) &&
2084 (ctxt->input->buf->readcallback != xmlInputReadCallbackNop)) &&
2085 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
2086 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "Huge input lookup");
2087 xmlHaltParser(ctxt);
2090 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2091 if ((ctxt->input->cur > ctxt->input->end) ||
2092 (ctxt->input->cur < ctxt->input->base)) {
2093 xmlHaltParser(ctxt);
2094 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "cur index out of bound");
2097 if ((ctxt->input->cur != NULL) && (*ctxt->input->cur == 0))
2098 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
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; \
2120 #define CUR_CHAR(l) xmlCurrentChar(ctxt, &l)
2121 #define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
2129 * @ctxt: the XML parser context
2138 xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
2145 if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) {
2150 cur = ctxt->input->cur;
2153 ctxt->input->line++; ctxt->input->col = 1;
2155 ctxt->input->col++;
2160 ctxt->input->cur = cur;
2161 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2162 cur = ctxt->input->cur;
2165 ctxt->input->cur = cur;
2167 int expandPE = ((ctxt->external != 0) || (ctxt->inputNr != 1));
2178 xmlParsePEReference(ctxt);
2180 if (ctxt->inputNr <= 1)
2182 xmlPopInput(ctxt);
2208 * @ctxt: an XML parser context
2210 * xmlPopInput: the current input pointed by ctxt->input came to an end
2216 xmlPopInput(xmlParserCtxtPtr ctxt) {
2217 if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0);
2220 "Popping input %d\n", ctxt->inputNr);
2221 if ((ctxt->inputNr > 1) && (ctxt->inSubset == 0) &&
2222 (ctxt->instate != XML_PARSER_EOF))
2223 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
2225 xmlFreeInputStream(inputPop(ctxt));
2226 if (*ctxt->input->cur == 0)
2227 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2233 * @ctxt: an XML parser context
2241 ctxt, xmlParserInputPtr input) {
2246 if ((ctxt->input != NULL) && (ctxt->input->filename))
2248 "%s(%d): ", ctxt->input->filename,
2249 ctxt->input->line);
2251 "Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
2253 if (((ctxt->inputNr > 40) && ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
2254 (ctxt->inputNr > 1024)) {
2255 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
2256 while (ctxt->inputNr > 1)
2257 xmlFreeInputStream(inputPop(ctxt));
2260 ret = inputPush(ctxt, input);
2261 if (ctxt->instate == XML_PARSER_EOF)
2269 * @ctxt: an XML parser context
2283 xmlParseCharRef(xmlParserCtxtPtr ctxt) {
2299 if (ctxt->instate == XML_PARSER_EOF)
2309 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2321 ctxt->input->col++;
2322 ctxt->nbChars ++;
2323 ctxt->input->cur++;
2332 if (ctxt->instate == XML_PARSER_EOF)
2338 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2350 ctxt->input->col++;
2351 ctxt->nbChars ++;
2352 ctxt->input->cur++;
2355 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2366 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2375 * @ctxt: an XML parser context
2392 xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
2412 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2431 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2444 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2457 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2466 * @ctxt: the parser context
2497 xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
2498 switch(ctxt->instate) {
2508 xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
2513 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
2524 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
2543 if ((ctxt->external == 0) && (ctxt->inputNr == 1))
2552 xmlParsePEReference(ctxt);
2572 * @ctxt: the parser context
2590 xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2602 if ((ctxt == NULL) || (str == NULL) || (len < 0))
2606 if (((ctxt->depth > 40) &&
2607 ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
2608 (ctxt->depth > 1024)) {
2609 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
2633 int val = xmlParseStringCharRef(ctxt, &str);
2645 ent = xmlParseStringEntityRef(ctxt, &str);
2646 xmlParserEntityCheck(ctxt, 0, ent, 0);
2648 ctxt->nbentities += ent->checked / 2;
2657 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
2662 ctxt->depth++;
2663 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2665 ctxt->depth--;
2673 if (xmlParserEntityCheck(ctxt, nbchars, ent, 0))
2696 ent = xmlParseStringPEReference(ctxt, &str);
2697 xmlParserEntityCheck(ctxt, 0, ent, 0);
2699 ctxt->nbentities += ent->checked / 2;
2708 if (((ctxt->options & XML_PARSE_NOENT) != 0) ||
2709 ((ctxt->options & XML_PARSE_DTDVALID) != 0) ||
2710 (ctxt->validate != 0)) {
2711 xmlLoadEntityContent(ctxt, ent);
2713 xmlWarningMsg(ctxt, XML_ERR_ENTITY_PROCESSING,
2718 ctxt->depth++;
2719 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2721 ctxt->depth--;
2728 if (xmlParserEntityCheck(ctxt, nbchars, ent, 0))
2752 xmlErrMemory(ctxt, NULL);
2763 * @ctxt: the parser context
2780 xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
2782 if ((ctxt == NULL) || (str == NULL)) return(NULL);
2783 return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what,
2795 * @ctxt: an XML parser context
2805 static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2814 if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
2820 if ((ctxt->space == NULL) || (*(ctxt->space) == 1) ||
2821 (*(ctxt->space) == -2))
2835 if (ctxt->node == NULL) return(0);
2836 if (ctxt->myDoc != NULL) {
2837 ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
2846 if ((ctxt->node->children == NULL) &&
2849 lastChild = xmlGetLastChild(ctxt->node);
2851 if ((ctxt->node->type != XML_ELEMENT_NODE) &&
2852 (ctxt->node->content != NULL)) return(0);
2855 else if ((ctxt->node->children != NULL) &&
2856 (xmlNodeIsText(ctxt->node->children)))
2870 * @ctxt: an XML parser context
2887 xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix) {
2926 xmlErrMemory(ctxt, NULL);
2939 xmlErrMemory(ctxt, NULL);
2985 xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
3005 xmlErrMemory(ctxt, NULL);
3017 xmlErrMemory(ctxt, NULL);
3071 xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) {
3072 if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3102 xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) {
3103 if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3140 static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
3144 xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
3157 if (ctxt->instate == XML_PARSER_EOF)
3160 if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3210 if (ctxt->instate == XML_PARSER_EOF)
3236 if (ctxt->instate == XML_PARSER_EOF)
3245 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3246 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
3249 if (ctxt->input->cur - ctxt->input->base < len) {
3255 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
3259 if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
3260 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
3261 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
3266 * @ctxt: an XML parser context
3281 xmlParseName(xmlParserCtxtPtr ctxt) {
3295 in = ctxt->input->cur;
3307 count = in - ctxt->input->cur;
3309 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3310 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
3313 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3314 ctxt->input->cur = in;
3315 ctxt->nbChars += count;
3316 ctxt->input->col += count;
3318 xmlErrMemory(ctxt, NULL);
3323 return(xmlParseNameComplex(ctxt));
3327 xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
3344 (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) {
3349 (xmlIsNameChar(ctxt, c) && (c != ':'))) {
3352 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3353 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3358 if (ctxt->instate == XML_PARSER_EOF)
3371 ctxt->input->cur -= l;
3373 if (ctxt->instate == XML_PARSER_EOF)
3375 ctxt->input->cur += l;
3380 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3381 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3384 return(xmlDictLookup(ctxt->dict, (BASE_PTR + startPosition), len));
3389 * @ctxt: an XML parser context
3403 xmlParseNCName(xmlParserCtxtPtr ctxt) {
3415 in = ctxt->input->cur;
3416 e = ctxt->input->end;
3430 count = in - ctxt->input->cur;
3432 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3433 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3436 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3437 ctxt->input->cur = in;
3438 ctxt->nbChars += count;
3439 ctxt->input->col += count;
3441 xmlErrMemory(ctxt, NULL);
3447 return(xmlParseNCNameComplex(ctxt));
3452 * @ctxt: an XML parser context
3462 xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
3468 if (ctxt->instate == XML_PARSER_EOF)
3471 in = ctxt->input->cur;
3475 ctxt->input->col++;
3479 ctxt->input->cur = in;
3483 ret = xmlParseName (ctxt);
3493 * @ctxt: an XML parser context
3510 xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
3521 if (!xmlIsNameStartChar(ctxt, c)) {
3528 while (xmlIsNameChar(ctxt, c)) {
3542 xmlErrMemory(ctxt, NULL);
3546 while (xmlIsNameChar(ctxt, c)) {
3551 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3552 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3560 xmlErrMemory(ctxt, NULL);
3576 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3577 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3586 * @ctxt: an XML parser context
3598 xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
3609 if (ctxt->instate == XML_PARSER_EOF)
3613 while (xmlIsNameChar(ctxt, c)) {
3624 if (ctxt->instate == XML_PARSER_EOF)
3638 xmlErrMemory(ctxt, NULL);
3642 while (xmlIsNameChar(ctxt, c)) {
3646 if (ctxt->instate == XML_PARSER_EOF) {
3655 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3656 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
3664 xmlErrMemory(ctxt, NULL);
3681 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3682 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
3690 * @ctxt: an XML parser context
3702 xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
3715 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
3720 xmlErrMemory(ctxt, NULL);
3728 ctxt->instate = XML_PARSER_ENTITY_VALUE;
3729 input = ctxt->input;
3731 if (ctxt->instate == XML_PARSER_EOF)
3745 (ctxt->input != input))) && (ctxt->instate != XML_PARSER_EOF)) {
3752 xmlErrMemory(ctxt, NULL);
3768 if (ctxt->instate == XML_PARSER_EOF)
3771 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
3789 name = xmlParseStringName(ctxt, &cur);
3795 xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
3800 if ((tmp == '%') && (ctxt->inSubset == 1) &&
3801 (ctxt->inputNr == 1)) {
3802 xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
3819 ++ctxt->depth;
3820 ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
3822 --ctxt->depth;
3836 * @ctxt: an XML parser context
3847 xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) {
3858 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3863 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3866 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
3883 (ctxt->instate != XML_PARSER_EOF)) {
3889 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3890 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
3898 int val = xmlParseCharRef(ctxt);
3901 if (ctxt->replaceEntities) {
3927 ent = xmlParseEntityRef(ctxt);
3928 ctxt->nbentities++;
3930 ctxt->nbentities += ent->owner;
3936 if ((ctxt->replaceEntities == 0) &&
3947 (ctxt->replaceEntities != 0)) {
3949 ++ctxt->depth;
3950 rep = xmlStringDecodeEntities(ctxt, ent->content,
3953 --ctxt->depth;
3987 unsigned long oldnbent = ctxt->nbentities;
3989 ++ctxt->depth;
3990 rep = xmlStringDecodeEntities(ctxt, ent->content,
3992 --ctxt->depth;
3994 ent->checked = (ctxt->nbentities - oldnbent + 1) * 2;
4040 if (ctxt->instate == XML_PARSER_EOF)
4048 xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
4051 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
4054 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4065 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4074 xmlErrMemory(ctxt, NULL);
4085 * @ctxt: an XML parser context
4118 xmlParseAttValue(xmlParserCtxtPtr ctxt) {
4119 if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL);
4120 return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
4125 * @ctxt: an XML parser context
4135 xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
4141 int state = ctxt->instate;
4152 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4158 xmlErrMemory(ctxt, NULL);
4161 ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
4168 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4169 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "SystemLiteral");
4171 ctxt->instate = (xmlParserInputState) state;
4178 xmlErrMemory(ctxt, NULL);
4179 ctxt->instate = (xmlParserInputState) state;
4188 if (ctxt->instate == XML_PARSER_EOF) {
4203 ctxt->instate = (xmlParserInputState) state;
4205 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4214 * @ctxt: an XML parser context
4224 xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
4231 xmlParserInputState oldstate = ctxt->instate;
4241 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4246 xmlErrMemory(ctxt, NULL);
4249 ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
4256 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4257 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Public ID");
4264 xmlErrMemory(ctxt, NULL);
4275 if (ctxt->instate == XML_PARSER_EOF) {
4290 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4294 ctxt->instate = oldstate;
4298 static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
4340 * @ctxt: an XML parser context
4355 xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
4358 int line = ctxt->input->line;
4359 int col = ctxt->input->col;
4369 in = ctxt->input->cur;
4372 while (*in == 0x20) { in++; ctxt->input->col++; }
4375 ctxt->input->line++; ctxt->input->col = 1;
4381 nbchar = in - ctxt->input->cur;
4383 const xmlChar *tmp = ctxt->input->cur;
4384 ctxt->input->cur = in;
4386 if ((ctxt->sax != NULL) &&
4387 (ctxt->sax->ignorableWhitespace !=
4388 ctxt->sax->characters)) {
4389 if (areBlanks(ctxt, tmp, nbchar, 1)) {
4390 if (ctxt->sax->ignorableWhitespace != NULL)
4391 ctxt->sax->ignorableWhitespace(ctxt->userData,
4394 if (ctxt->sax->characters != NULL)
4395 ctxt->sax->characters(ctxt->userData,
4397 if (*ctxt->space == -1)
4398 *ctxt->space = -2;
4400 } else if ((ctxt->sax != NULL) &&
4401 (ctxt->sax->characters != NULL)) {
4402 ctxt->sax->characters(ctxt->userData,
4410 ccol = ctxt->input->col;
4415 ctxt->input->col = ccol;
4418 ctxt->input->line++; ctxt->input->col = 1;
4425 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4426 ctxt->input->cur = in + 1;
4430 ctxt->input->col++;
4433 nbchar = in - ctxt->input->cur;
4435 if ((ctxt->sax != NULL) &&
4436 (ctxt->sax->ignorableWhitespace !=
4437 ctxt->sax->characters) &&
4438 (IS_BLANK_CH(*ctxt->input->cur))) {
4439 const xmlChar *tmp = ctxt->input->cur;
4440 ctxt->input->cur = in;
4442 if (areBlanks(ctxt, tmp, nbchar, 0)) {
4443 if (ctxt->sax->ignorableWhitespace != NULL)
4444 ctxt->sax->ignorableWhitespace(ctxt->userData,
4447 if (ctxt->sax->characters != NULL)
4448 ctxt->sax->characters(ctxt->userData,
4450 if (*ctxt->space == -1)
4451 *ctxt->space = -2;
4453 line = ctxt->input->line;
4454 col = ctxt->input->col;
4455 } else if (ctxt->sax != NULL) {
4456 if (ctxt->sax->characters != NULL)
4457 ctxt->sax->characters(ctxt->userData,
4458 ctxt->input->cur, nbchar);
4459 line = ctxt->input->line;
4460 col = ctxt->input->col;
4463 if (ctxt->instate != XML_PARSER_CONTENT)
4466 ctxt->input->cur = in;
4470 ctxt->input->cur = in;
4472 ctxt->input->line++; ctxt->input->col = 1;
4485 if (ctxt->instate == XML_PARSER_EOF)
4487 in = ctxt->input->cur;
4491 ctxt->input->line = line;
4492 ctxt->input->col = col;
4493 xmlParseCharDataComplex(ctxt, cdata);
4498 * @ctxt: an XML parser context
4506 xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
4522 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4532 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4533 if (areBlanks(ctxt, buf, nbchar, 0)) {
4534 if (ctxt->sax->ignorableWhitespace != NULL)
4535 ctxt->sax->ignorableWhitespace(ctxt->userData,
4538 if (ctxt->sax->characters != NULL)
4539 ctxt->sax->characters(ctxt->userData, buf, nbchar);
4540 if ((ctxt->sax->characters !=
4541 ctxt->sax->ignorableWhitespace) &&
4542 (*ctxt->space == -1))
4543 *ctxt->space = -2;
4548 if (ctxt->instate != XML_PARSER_CONTENT)
4555 if (ctxt->instate == XML_PARSER_EOF)
4566 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4567 if (areBlanks(ctxt, buf, nbchar, 0)) {
4568 if (ctxt->sax->ignorableWhitespace != NULL)
4569 ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
4571 if (ctxt->sax->characters != NULL)
4572 ctxt->sax->characters(ctxt->userData, buf, nbchar);
4573 if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) &&
4574 (*ctxt->space == -1))
4575 *ctxt->space = -2;
4581 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4590 * @ctxt: an XML parser context
4611 xmlParseExternalID(xmlParserCtxtPtr ctxt
4620 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4623 URI = xmlParseSystemLiteral(ctxt);
4625 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4630 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4633 *publicID = xmlParsePubidLiteral(ctxt);
4635 xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
4642 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4655 URI = xmlParseSystemLiteral(ctxt);
4657 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4665 * @ctxt: an XML parser context
4678 xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf,
4686 inputid = ctxt->input->id;
4693 xmlErrMemory(ctxt, NULL);
4702 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4713 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4727 xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
4730 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4731 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4744 xmlErrMemory(ctxt, NULL);
4760 if (ctxt->instate == XML_PARSER_EOF) {
4775 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4778 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4782 if (inputid != ctxt->input->id) {
4783 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4788 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4789 (!ctxt->disableSAX))
4790 ctxt->sax->comment(ctxt->userData, buf);
4795 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4803 * @ctxt: an XML parser context
4812 xmlParseComment(xmlParserCtxtPtr ctxt) {
4827 state = ctxt->instate;
4828 ctxt->instate = XML_PARSER_COMMENT;
4829 inputid = ctxt->input->id;
4838 in = ctxt->input->cur;
4842 ctxt->input->line++; ctxt->input->col = 1;
4847 ccol = ctxt->input->col;
4854 ctxt->input->col = ccol;
4857 ctxt->input->line++; ctxt->input->col = 1;
4862 nbchar = in - ctxt->input->cur;
4867 if ((ctxt->sax != NULL) &&
4868 (ctxt->sax->comment != NULL)) {
4876 xmlErrMemory(ctxt, NULL);
4877 ctxt->instate = state;
4888 xmlErrMemory(ctxt, NULL);
4889 ctxt->instate = state;
4894 memcpy(&buf[len], ctxt->input->cur, nbchar);
4900 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4901 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4906 ctxt->input->cur = in;
4909 ctxt->input->line++; ctxt->input->col = 1;
4914 ctxt->input->cur = in;
4916 ctxt->input->line++; ctxt->input->col = 1;
4923 if (ctxt->instate == XML_PARSER_EOF) {
4927 in = ctxt->input->cur;
4931 if (ctxt->input->id != inputid) {
4932 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4937 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4938 (!ctxt->disableSAX)) {
4940 ctxt->sax->comment(ctxt->userData, buf);
4942 ctxt->sax->comment(ctxt->userData, BAD_CAST "");
4946 if (ctxt->instate != XML_PARSER_EOF)
4947 ctxt->instate = state;
4951 xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
4956 xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
4959 ctxt->input->col++;
4962 ctxt->input->col++;
4966 xmlParseCommentComplex(ctxt, buf, len, size);
4967 ctxt->instate = state;
4974 * @ctxt: an XML parser context
4984 xmlParsePITarget(xmlParserCtxtPtr ctxt) {
4987 name = xmlParseName(ctxt);
4995 xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
4999 xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
5007 xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
5012 xmlNsErr(ctxt, XML_NS_ERR_COLON,
5021 * @ctxt: an XML parser context
5035 xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
5066 ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
5072 xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
5082 * @ctxt: an XML parser context
5092 xmlParsePI(xmlParserCtxtPtr ctxt) {
5102 int inputid = ctxt->input->id;
5103 state = ctxt->instate;
5104 ctxt->instate = XML_PARSER_PI;
5115 target = xmlParsePITarget(ctxt);
5118 if (inputid != ctxt->input->id) {
5119 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5128 if ((ctxt->sax) && (!ctxt->disableSAX) &&
5129 (ctxt->sax->processingInstruction != NULL))
5130 ctxt->sax->processingInstruction(ctxt->userData,
5132 if (ctxt->instate != XML_PARSER_EOF)
5133 ctxt->instate = state;
5138 xmlErrMemory(ctxt, NULL);
5139 ctxt->instate = state;
5143 xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
5154 xmlErrMemory(ctxt, NULL);
5156 ctxt->instate = state;
5165 if (ctxt->instate == XML_PARSER_EOF) {
5171 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
5172 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5175 ctxt->instate = state;
5189 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
5190 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5193 ctxt->instate = state;
5198 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5201 if (inputid != ctxt->input->id) {
5202 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5215 xmlParseCatalogPI(ctxt, buf);
5223 if ((ctxt->sax) && (!ctxt->disableSAX) &&
5224 (ctxt->sax->processingInstruction != NULL))
5225 ctxtctxt->userData,
5230 xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
5232 if (ctxt->instate != XML_PARSER_EOF)
5233 ctxt->instate = state;
5239 * @ctxt: an XML parser context
5254 xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
5260 int inputid = ctxt->input->id;
5264 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5269 name = xmlParseName(ctxt);
5271 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5275 xmlNsErr(ctxt, XML_NS_ERR_COLON,
5280 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5288 Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
5292 if (inputid != ctxt->input->id) {
5293 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5298 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5299 (ctxt->sax->notationDecl != NULL))
5300 ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
5302 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5311 * @ctxt: an XML parser context
5332 xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
5342 int inputid = ctxt->input->id;
5346 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5353 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5359 name = xmlParseName(ctxt);
5361 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5366 xmlNsErr(ctxt, XML_NS_ERR_COLON,
5371 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5375 ctxt->instate = XML_PARSER_ENTITY_DECL;
5381 value = xmlParseEntityValue(ctxt, &orig);
5383 if ((ctxt->sax != NULL) &&
5384 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5385 ctxt->sax->entityDecl(ctxt->userData, name,
5390 URI = xmlParseExternalID(ctxt, &literal, 1);
5392 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5399 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5412 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5414 if ((ctxt->sax != NULL) &&
5415 (!ctxt->disableSAX) &&
5416 (ctxt->sax->entityDecl != NULL))
5417 ctxt->sax->entityDecl(ctxt->userData, name,
5427 value = xmlParseEntityValue(ctxt, &orig);
5428 if ((ctxt->sax != NULL) &&
5429 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5430 ctxt->sax->entityDecl(ctxt->userData, name,
5436 if ((ctxt->myDoc == NULL) ||
5437 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
5438 if (ctxt->myDoc == NULL) {
5439 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5440 if (ctxt->myDoc == NULL) {
5441 xmlErrMemory(ctxt, "New Doc failed");
5444 ctxt->myDoc->properties = XML_DOC_INTERNAL;
5446 if (ctxt->myDoc->intSubset == NULL)
5447 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5450 xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
5454 URI = xmlParseExternalID(ctxt, &literal, 1);
5456 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5463 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5476 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5482 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5488 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5491 ndata = xmlParseName(ctxt);
5492 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5493 (ctxt->sax->unparsedEntityDecl != NULL))
5494 ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
5497 if ((ctxt->sax != NULL) &&
5498 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5499 ctxt->sax->entityDecl(ctxt->userData, name,
5506 if ((ctxt->replaceEntities != 0) &&
5507 ((ctxt->myDoc == NULL) ||
5508 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
5509 if (ctxt->myDoc == NULL) {
5510 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5511 if (ctxt->myDoc == NULL) {
5512 xmlErrMemory(ctxt, "New Doc failed");
5515 ctxt->myDoc->properties = XML_DOC_INTERNAL;
5518 if (ctxt->myDoc->intSubset == NULL)
5519 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5521 xmlSAX2EntityDecl(ctxt, name,
5528 if (ctxt->instate == XML_PARSER_EOF)
5532 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
5534 xmlHaltParser(ctxt);
5536 if (inputid != ctxt->input->id) {
5537 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5550 if ((ctxt->sax != NULL) &&
5551 (ctxt->sax->getParameterEntity != NULL))
5552 cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
5554 if ((ctxt->sax != NULL) &&
5555 (ctxt->sax->getEntity != NULL))
5556 cur = ctxt->sax->getEntity(ctxt->userData, name);
5557 if ((cur == NULL) && (ctxt->userData==ctxt)) {
5558 cur = xmlSAX2GetEntity(ctxt, name);
5577 * @ctxt: an XML parser context
5605 xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
5623 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5627 ret = xmlParseAttValue(ctxt);
5628 ctxt->instate = XML_PARSER_DTD;
5630 xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
5639 * @ctxt: an XML parser context
5655 xmlParseNotationType(xmlParserCtxtPtr ctxt) {
5660 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5667 name = xmlParseName(ctxt);
5669 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5677 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5680 if (!xmlDictOwns(ctxt->dict, name))
5701 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5711 * @ctxt: an XML parser context
5725 xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
5730 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
5737 name = xmlParseNmtoken(ctxt);
5739 xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
5745 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5748 if (!xmlDictOwns(ctxt->dict, name))
5756 if (!xmlDictOwns(ctxt->dict, name))
5771 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
5780 * @ctxt: an XML parser context
5794 xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5798 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5802 *tree = xmlParseNotationType(ctxt);
5806 *tree = xmlParseEnumerationType(ctxt);
5813 * @ctxt: an XML parser context
5857 xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5884 return(xmlParseEnumeratedType(ctxt, tree));
5889 * @ctxt: an XML parser context
5899 xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
5905 int inputid = ctxt->input->id;
5909 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5912 elemName = xmlParseName(ctxt);
5914 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5920 while ((RAW != '>') && (ctxt->instate != XML_PARSER_EOF)) {
5927 attrName = xmlParseName(ctxt);
5929 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5935 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5940 type = xmlParseAttributeType(ctxt, &tree);
5947 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5954 def = xmlParseDefaultDecl(ctxt, &defaultValue);
5968 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5977 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5978 (ctxt->sax->attributeDecl != NULL))
5979 ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
5984 if ((ctxt->sax2) && (defaultValue != NULL) &&
5987 xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
5989 if (ctxt->sax2) {
5990 xmlAddSpecialAttr(ctxt, elemName, attrName, type);
5997 if (inputid != ctxt->input->id) {
5998 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6009 * @ctxt: an XML parser context
6027 xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6037 if (ctxt->input->id != inputchk) {
6038 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6043 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
6053 ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
6056 while ((RAW == '|') && (ctxt->instate != XML_PARSER_EOF)) {
6059 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6066 n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6068 n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6077 elem = xmlParseName(ctxt);
6079 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6081 xmlFreeDocElementContent(ctxt->myDoc, ret);
6089 cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
6096 if (ctxt->input->id != inputchk) {
6097 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6103 xmlFreeDocElementContent(ctxt->myDoc, ret);
6104 xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
6109 xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
6116 * @ctxt: an XML parser context
6147 xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk,
6153 if (((depth > 128) && ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
6155 xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED,
6163 int inputid = ctxt->input->id;
6168 cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6173 elem = xmlParseName(ctxt);
6175 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6178 cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6180 xmlErrMemory(ctxt, NULL);
6200 while ((RAW != ')') && (ctxt->instate != XML_PARSER_EOF)) {
6211 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6215 xmlFreeDocElementContent(ctxt->myDoc, last);
6217 xmlFreeDocElementContent(ctxt->myDoc, ret);
6222 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
6225 xmlFreeDocElementContent(ctxt->myDoc, last);
6226 xmlFreeDocElementContent(ctxt->myDoc, ret);
6251 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6255 xmlFreeDocElementContent(ctxt->myDoc, last);
6257 xmlFreeDocElementContent(ctxt->myDoc, ret);
6262 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6265 xmlFreeDocElementContent(ctxt->myDoc, last);
6267 xmlFreeDocElementContent(ctxt->myDoc, ret);
6286 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
6288 xmlFreeDocElementContent(ctxt->myDoc, last);
6290 xmlFreeDocElementContent(ctxt->myDoc, ret);
6297 int inputid = ctxt->input->id;
6301 last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6305 elem = xmlParseName(ctxt);
6307 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6309 xmlFreeDocElementContent(ctxt->myDoc, ret);
6312 last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6315 xmlFreeDocElementContent(ctxt->myDoc, ret);
6339 if (ctxt->input->id != inputchk) {
6340 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6414 * @ctxt: an XML parser context
6443 xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6445 return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1));
6450 * @ctxt: an XML parser context
6463 xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
6467 int inputid = ctxt->input->id;
6473 xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6479 if (ctxt->instate == XML_PARSER_EOF)
6483 tree = xmlParseElementMixedContentDecl(ctxt, inputid);
6486 tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1);
6496 * @ctxt: an XML parser context
6508 xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
6515 int inputid = ctxt->input->id;
6519 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6523 name = xmlParseName(ctxt);
6525 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6530 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6547 ret = xmlParseElementContentDecl(ctxt, name, &content);
6552 if ((RAW == '%') && (ctxt->external == 0) &&
6553 (ctxt->inputNr == 1)) {
6554 xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
6557 xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6566 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
6568 xmlFreeDocElementContent(ctxt->myDoc, content);
6571 if (inputid != ctxt->input->id) {
6572 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6578 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6579 (ctxt->sax->elementDecl != NULL)) {
6582 ctxt->sax->elementDecl(ctxt->userData, name, ret,
6591 xmlFreeDocElementContent(ctxt->myDoc, content);
6594 xmlFreeDocElementContent(ctxt->myDoc, content);
6603 * @ctxt: an XML parser context
6613 xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
6614 int id = ctxt->input->id;
6622 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6623 xmlHaltParser(ctxt);
6626 if (ctxt->input->id != id) {
6627 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6634 if ((ctxt->input != NULL) && (ctxt->input->filename))
6636 "%s(%d): ", ctxt->input->filename,
6637 ctxt->input->line);
6645 (NXT(2) != '>'))) && (ctxt->instate != XML_PARSER_EOF)) {
6647 unsigned int cons = ctxt->input->consumed;
6650 xmlParseConditionalSections(ctxt);
6652 xmlParseMarkupDecl(ctxt);
6657 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
6658 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6659 xmlHaltParser(ctxt);
6664 if ((ctxt->input != NULL) && (ctxt->input->filename))
6666 "%s(%d): ", ctxt->input->filename,
6667 ctxt->input->line);
6680 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6681 xmlHaltParser(ctxt);
6684 if (ctxt->input->id != id) {
6685 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6692 if ((ctxt->input != NULL) && (ctxt->input->filename))
6694 "%s(%d): ", ctxt->input->filename,
6695 ctxt->input->line);
6704 state = ctxt->disableSAX;
6705 instate = ctxt->instate;
6706 if (ctxt->recovery == 0) ctxt->disableSAX = 1;
6707 ctxt->instate = XML_PARSER_IGNORE;
6710 (ctxt->instate != XML_PARSER_EOF)) {
6724 ctxt->disableSAX = state;
6725 ctxt->instate = instate;
6728 if ((ctxt->input != NULL) && (ctxt->input->filename))
6730 "%s(%d): ", ctxt->input->filename,
6731 ctxt->input->line);
6737 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
6738 xmlHaltParser(ctxt);
6746 xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
6748 if (ctxt->input->id != id) {
6749 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6753 if ((ctxt-> instate != XML_PARSER_EOF) &&
6754 ((ctxt->input->cur + 3) <= ctxt->input->end))
6761 * @ctxt: an XML parser context
6782 xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
6789 xmlParseElementDecl(ctxt);
6791 xmlParseEntityDecl(ctxt);
6794 xmlParseAttributeListDecl(ctxt);
6797 xmlParseNotationDecl(ctxt);
6800 xmlParseComment(ctxt);
6807 xmlParsePI(ctxt);
6815 if (ctxt->instate == XML_PARSER_EOF)
6822 if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
6824 xmlParseConditionalSections(ctxt);
6828 ctxt->instate = XML_PARSER_DTD;
6833 * @ctxt: an XML parser context
6841 xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
6851 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
6856 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6863 version = xmlParseVersionInfo(ctxt);
6868 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6872 ctxt->input->version = version;
6877 encoding = xmlParseEncodingDecl(ctxt);
6878 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
6884 if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
6885 xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
6894 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
6897 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
6905 * @ctxt: an XML parser context
6916 xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
6918 xmlDetectSAX2(ctxt);
6921 if ((ctxt->encoding == NULL) &&
6922 (ctxt->input->end - ctxt->input->cur >= 4)) {
6932 xmlSwitchEncoding(ctxt, enc);
6936 xmlParseTextDecl(ctxt);
6937 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
6941 xmlHaltParser(ctxt);
6945 if (ctxt->myDoc == NULL) {
6946 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
6947 if (ctxt->myDoc == NULL) {
6948 xmlErrMemory(ctxt, "New Doc failed");
6951 ctxt->myDoc->properties = XML_DOC_INTERNAL;
6953 if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
6954 xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
6956 ctxt->instate = XML_PARSER_DTD;
6957 ctxt->external = 1;
6963 unsigned int cons = ctxt->input->consumed;
6967 xmlParseConditionalSections(ctxt);
6969 xmlParseMarkupDecl(ctxt);
6972 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
6973 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6979 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6986 * @ctxt: an XML parser context
6996 xmlParseReference(xmlParserCtxtPtr ctxt) {
7014 int value = xmlParseCharRef(ctxt);
7018 if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
7027 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7028 (!ctxt->disableSAX))
7029 ctxt->sax->characters(ctxt->userData, out, 1);
7035 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7036 (!ctxt->disableSAX))
7037 ctxt->sax->reference(ctxt->userData, out);
7045 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7046 (!ctxt->disableSAX))
7047 ctxt->sax->characters(ctxt->userData, out, i);
7055 ent = xmlParseEntityRef(ctxt);
7057 if (!ctxt->wellFormed)
7069 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7070 (!ctxt->disableSAX))
7071 ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
7086 ((ent->children == NULL) && (ctxt->options & XML_PARSE_NOENT))) &&
7088 (ctxt->options & (XML_PARSE_NOENT | XML_PARSE_DTDVALID)))) {
7089 unsigned long oldnbent = ctxt->nbentities;
7097 if (ctxt->userData == ctxt)
7100 user_data = ctxt->userData;
7109 ctxt->depth++;
7110 ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content,
7112 ctxt->depth--;
7115 ctxt->depth++;
7116 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax,
7117 user_data, ctxt->depth, ent->URI,
7119 ctxt->depth--;
7122 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
7130 ent->checked = (ctxt->nbentities - oldnbent + 1) * 2;
7134 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7138 if (xmlParserEntityCheck(ctxt, 0, ent, 0)) {
7148 if (ctxt->replaceEntities) {
7155 (ctxt->parseMode == XML_PARSE_READER)) {
7162 list->parent = (xmlNodePtr) ctxt->node;
7163 list->doc = ctxt->myDoc;
7190 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7194 xmlParserEntityCheck(ctxt, 0, ent, 0);
7205 ctxt->nbentities += ent->checked / 2;
7227 if (ctxt->userData == ctxt)
7230 user_data = ctxt->userData;
7233 ctxt->depth++;
7234 ret = xmlParseBalancedChunkMemoryInternal(ctxt,
7236 ctxt->depth--;
7239 ctxt->depth++;
7240 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
7241 ctxt->sax, user_data, ctxt->depth,
7243 ctxt->depth--;
7246 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
7250 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7254 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7255 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7260 ctxt->sax->reference(ctxt->userData, ent->name);
7268 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7269 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7273 ctxt->sax->reference(ctxt->userData, ent->name);
7277 if ((ctxt->replaceEntities) || (ent->children == NULL)) {
7291 if ((ctxt->node != NULL) && (ent->children != NULL)) {
7298 (ctxt->parseMode == XML_PARSE_READER)) {
7304 ctxt->sizeentcopy += ent->length + 5;
7305 if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
7311 if (ctxt->parseMode == XML_PARSE_READER)
7317 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7324 nw = xmlAddChild(ctxt->node, nw);
7331 if ((ctxt->parseMode == XML_PARSE_READER) &&
7345 } else if ((list == NULL) || (ctxt->inputNr > 0)) {
7352 ctxt->sizeentcopy += ent->length + 5;
7353 if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
7370 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7378 xmlAddChild(ctxt->node, cur);
7398 nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
7405 xmlAddChildList(ctxt->node, ent->children);
7412 ctxt->nodemem = 0;
7413 ctxt->nodelen = 0;
7421 * @ctxt: an XML parser context
7448 xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
7453 if (ctxt->instate == XML_PARSER_EOF)
7459 name = xmlParseName(ctxt);
7461 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7466 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7474 if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7483 ctxt->nbentities++;
7489 if (ctxt->sax != NULL) {
7490 if (ctxt->sax->getEntity != NULL)
7491 ent = ctxt->sax->getEntity(ctxt->userData, name);
7492 if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7493 (ctxt->options & XML_PARSE_OLDSAX))
7495 if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7496 (ctxt->userData==ctxt)) {
7497 ent = xmlSAX2GetEntity(ctxt, name);
7500 if (ctxt->instate == XML_PARSER_EOF)
7524 if ((ctxt->standalone == 1) ||
7525 ((ctxt->hasExternalSubset == 0) &&
7526 (ctxt->hasPErefs == 0))) {
7527 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7530 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7532 if ((ctxt->inSubset == 0) &&
7533 (ctxt->sax != NULL) &&
7534 (ctxt->sax->reference != NULL)) {
7535 ctxt->sax->reference(ctxt->userData, name);
7538 xmlParserEntityCheck(ctxt, 0, ent, 0);
7539 ctxt->valid = 0;
7548 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7557 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7559 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7568 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7573 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7585 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7605 * @ctxt: an XML parser context
7635 xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
7649 name = xmlParseStringName(ctxt, &ptr);
7651 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7657 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7668 if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7680 ctxt->nbentities++;
7686 if (ctxt->sax != NULL) {
7687 if (ctxt->sax->getEntity != NULL)
7688 ent = ctxt->sax->getEntity(ctxt->userData, name);
7689 if ((ent == NULL) && (ctxt->options & XML_PARSE_OLDSAX))
7691 if ((ent == NULL) && (ctxt->userData==ctxt)) {
7692 ent = xmlSAX2GetEntity(ctxt, name);
7695 if (ctxt->instate == XML_PARSER_EOF) {
7722 if ((ctxt->standalone == 1) ||
7723 ((ctxt->hasExternalSubset == 0) &&
7724 (ctxt->hasPErefs == 0))) {
7725 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7728 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7732 xmlParserEntityCheck(ctxt, 0, ent, 0);
7733 /* TODO ? check regressions ctxt->valid = 0; */
7742 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7751 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7753 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7762 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7766 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7778 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7801 * @ctxt: an XML parser context
7829 xmlParsePEReference(xmlParserCtxtPtr ctxt)
7838 name = xmlParseName(ctxt);
7840 xmlFatalErrMsg(ctxt, XML_ERR_PEREF_NO_NAME, "PEReference: no name\n");
7847 xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
7856 ctxt->nbentities++;
7861 if ((ctxt->sax != NULL) &&
7862 (ctxt->sax->getParameterEntity != NULL))
7863 entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
7864 if (ctxt->instate == XML_PARSER_EOF)
7875 if ((ctxt->standalone == 1) ||
7876 ((ctxt->hasExternalSubset == 0) &&
7877 (ctxt->hasPErefs == 0))) {
7878 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7889 if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
7890 xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
7894 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7897 ctxt->valid = 0;
7899 xmlParserEntityCheck(ctxt, 0, NULL, 0);
7906 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7914 ((ctxt->options & XML_PARSE_NOENT) == 0) &&
7915 ((ctxt->options & XML_PARSE_DTDVALID) == 0) &&
7916 ((ctxt->options & XML_PARSE_DTDLOAD) == 0) &&
7917 ((ctxt->options & XML_PARSE_DTDATTR) == 0) &&
7918 (ctxt->replaceEntities == 0) &&
7919 (ctxt->validate == 0))
7922 input = xmlNewEntityInputStream(ctxt, entity);
7923 if (xmlPushInput(ctxt, input) < 0) {
7939 if (ctxt->instate == XML_PARSER_EOF)
7941 if ((ctxt->input->end - ctxt->input->cur)>=4) {
7948 xmlSwitchEncoding(ctxt, enc);
7954 xmlParseTextDecl(ctxt);
7959 ctxt->hasPErefs = 1;
7964 * @ctxt: an XML parser context
7974 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
7980 if ((ctxt == NULL) || (entity == NULL) ||
7984 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7995 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8000 input = xmlNewEntityInputStream(ctxt, entity);
8002 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8012 if (xmlPushInput(ctxt, input) < 0) {
8019 while ((ctxt->input == input) && (ctxt->input->cur < ctxt
8021 xmlBufferAdd(buf, ctxt->input->cur, l);
8025 if (ctxt->instate == XML_PARSER_EOF) {
8035 if (ctxt->instate == XML_PARSER_EOF) {
8043 if ((ctxt->input == input) && (ctxt->input->cur >= ctxt->input->end)) {
8044 xmlPopInput(ctxt);
8046 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
8061 * @ctxt: an XML parser context
8091 xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
8103 name = xmlParseStringName(ctxt, &ptr);
8105 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8112 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
8122 ctxt->nbentities++;
8127 if ((ctxt->sax != NULL) &&
8128 (ctxt->sax->getParameterEntity != NULL))
8129 entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
8130 if (ctxt->instate == XML_PARSER_EOF) {
8144 if ((ctxt->standalone == 1) ||
8145 ((ctxt->hasExternalSubset == 0) && (ctxt->hasPErefs == 0))) {
8146 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
8156 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8159 ctxt->valid = 0;
8161 xmlParserEntityCheck(ctxt, 0, NULL, 0);
8168 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8173 ctxt->hasPErefs = 1;
8181 * @ctxt: an XML parser context
8194 xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
8209 name = xmlParseName(ctxt);
8211 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8214 ctxt->intSubName = name;
8221 URI = xmlParseExternalID(ctxt, &ExternalID, 1);
8224 ctxt->hasExternalSubset = 1;
8226 ctxt->extSubURI = URI;
8227 ctxt->extSubSystem = ExternalID;
8234 if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
8235 (!ctxt->disableSAX))
8236 ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
8237 if (ctxt->instate == XML_PARSER_EOF)
8251 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8258 * @ctxt: an XML parser context
8266 xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
8271 int baseInputNr = ctxt->inputNr;
8272 ctxt->instate = XML_PARSER_DTD;
8279 while (((RAW != ']') || (ctxt->inputNr > baseInputNr)) &&
8280 (ctxt->instate != XML_PARSER_EOF)) {
8282 unsigned int cons = ctxt->input->consumed;
8285 xmlParseMarkupDecl(ctxt);
8286 xmlParsePEReference(ctxt);
8288 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
8289 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8291 if (ctxt->inputNr > baseInputNr)
8292 xmlPopInput(ctxt);
8307 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8316 * @ctxt: an XML parser context
8348 xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
8354 name = xmlParseName(ctxt);
8356 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8368 val = xmlParseAttValue(ctxt);
8369 ctxt->instate = XML_PARSER_CONTENT;
8371 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8381 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
8383 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8394 *(ctxt->space) = 0;
8396 *(ctxt->space) = 1;
8398 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8410 * @ctxt: an XML parser context
8437 xmlParseStartTag(xmlParserCtxtPtr ctxt) {
8441 const xmlChar **atts = ctxt->atts;
8443 int maxatts = ctxt->maxatts;
8449 name = xmlParseName(ctxt);
8451 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8466 (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
8468 unsigned int cons = ctxt->input->consumed;
8470 attname = xmlParseAttribute(ctxt, &attvalue);
8479 xmlErrAttributeDup(ctxt, NULL, attname);
8492 xmlErrMemory(ctxt, NULL);
8497 ctxt->atts = atts;
8498 ctxt->maxatts = maxatts;
8506 xmlErrMemory(ctxt, NULL);
8512 ctxt->atts = atts;
8513 ctxt->maxatts = maxatts;
8530 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8533 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
8535 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
8546 if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
8547 (!ctxt->disableSAX)) {
8549 ctxt->sax->startElement(ctxt->userData, name, atts);
8551 ctxt->sax->startElement(ctxt->userData, name, NULL);
8565 * @ctxt: an XML parser context
8579 xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
8584 xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
8590 name = xmlParseNameAndCompare(ctxt,ctxt->name);
8598 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
8610 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
8612 ctxt->name, line, name);
8618 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
8619 (!ctxt->disableSAX))
8620 ctxt->sax->endElement(ctxt->userData, ctxt->name);
8622 namePop(ctxt);
8623 spacePop(ctxt);
8629 * @ctxt: an XML parser context
8641 xmlParseEndTag(xmlParserCtxtPtr ctxt) {
8642 xmlParseEndTag1(ctxt, 0);
8654 * @ctxt: an XML parser context
8658 * The prefix must come from the @ctxt->dict dictionary
8663 xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
8666 if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
8667 for (i = ctxt->nsNr - 2;i >= 0;i-=2)
8668 if (ctxt
8669 if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
8671 return(ctxt->nsTab[i + 1]);
8678 * @ctxt: an XML parser context
8691 xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
8696 l = xmlParseNCName(ctxt);
8699 l = xmlParseName(ctxt);
8701 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8712 l = xmlParseNCName(ctxt);
8716 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8718 l = xmlParseNmtoken(ctxt);
8725 p = xmlDictLookup(ctxt->dict, tmp, -1);
8733 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8736 tmp = (xmlChar *) xmlParseName(ctxt);
8739 l = xmlDictLookup(ctxt->dict, tmp, -1);
8745 l = xmlDictLookup(ctxt->dict, tmp, -1);
8758 * @ctxt: an XML parser context
8770 xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
8777 if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
8780 in = ctxt->input->cur;
8796 ctxt->input->cur = in;
8803 ret = xmlParseQName (ctxt, &prefix2);
8811 * @ctxt: an XML parser context
8844 xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len, int *alloc,
8854 line = ctxt->input->line;
8855 col = ctxt->input->col;
8857 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
8860 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
8869 end = ctxt->input->end;
8872 const xmlChar *oldbase = ctxt->input->base;
8874 if (oldbase != ctxt->input->base) {
8875 long delta = ctxt->input->base - oldbase;
8879 end = ctxt->input->end;
8896 const xmlChar *oldbase = ctxt->input->base;
8898 if (ctxt->instate == XML_PARSER_EOF)
8900 if (oldbase != ctxt->input->base) {
8901 long delta = ctxt->input->base - oldbase;
8905 end = ctxt->input->end;
8907 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
8908 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
8919 const xmlChar *oldbase = ctxt->input->base;
8921 if (ctxt->instate == XML_PARSER_EOF)
8923 if (oldbase != ctxt->input->base) {
8924 long delta = ctxt->input->base - oldbase;
8928 end = ctxt->input->end;
8930 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
8931 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
8952 const xmlChar *oldbase = ctxt->input->base;
8954 if (ctxt->instate == XML_PARSER_EOF)
8956 if (oldbase != ctxt->input->base) {
8957 long delta = ctxt->input->base - oldbase;
8962 end = ctxt->input->end;
8964 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
8965 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
8972 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
8973 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
8984 const xmlChar *oldbase = ctxt->input->base;
8986 if (ctxt->instate == XML_PARSER_EOF)
8988 if (oldbase != ctxt->input->base) {
8989 long delta = ctxt->input->base - oldbase;
8993 end = ctxt->input->end;
8995 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
8996 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9004 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9005 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9021 ctxt->input->line = line;
9022 ctxt->input->col = col;
9027 return xmlParseAttValueComplex(ctxt, len, normalize);
9032 * @ctxt: an XML parser context
9046 xmlParseAttribute2(xmlParserCtxtPtr ctxt,
9057 name = xmlParseQName(ctxt, prefix);
9059 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
9067 if (ctxt->attsSpecial != NULL) {
9070 type = (int) (ptrdiff_t) xmlHashQLookup2(ctxt->attsSpecial,
9083 val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
9094 val2 = xmlAttrNormalizeSpace2(ctxt, val, len);
9101 ctxt->instate = XML_PARSER_CONTENT;
9103 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
9109 if (*prefix == ctxt->str_xml) {
9115 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
9118 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
9130 *(ctxt->space) = 0;
9132 *(ctxt->space) = 1;
9134 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
9149 * @ctxt: an XML parser context
9177 xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
9185 const xmlChar **atts = ctxt->atts;
9186 int maxatts = ctxt->maxatts;
9190 int nsNr = ctxt->nsNr;
9203 cur = ctxt->input->cur - ctxt->input->base;
9204 inputid = ctxt->input->id;
9211 ctxt->nsNr = nsNr;
9213 localname = xmlParseQName(ctxt, &prefix);
9215 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
9219 *tlen = ctxt->input->cur - ctxt->input->base - cur;
9231 (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
9233 unsigned int cons = ctxt->input->consumed;
9236 attname = xmlParseAttribute2(ctxt, prefix, localname,
9242 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9243 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
9247 xmlErrMemory(ctxt, "dictionary allocation failure");
9255 xmlNsErr(ctxt, XML_WAR_NS_URI,
9260 xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9266 if (URL == ctxt->str_xml_ns) {
9267 if (attname != ctxt->str_xml) {
9268 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9277 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9287 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
9290 xmlErrAttributeDup(ctxt, NULL, attname);
9292 if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
9294 } else if (aprefix == ctxt->str_xmlns) {
9295 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
9298 if (attname == ctxt->str_xml) {
9299 if (URL != ctxt->str_xml_ns) {
9300 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9309 if (URL == ctxt->str_xml_ns) {
9310 if (attname != ctxt->str_xml) {
9311 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9317 if (attname == ctxt->str_xmlns) {
9318 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9326 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9332 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9339 xmlNsErr(ctxt, XML_WAR_NS_URI,
9343 if ((ctxt->pedantic) && (uri->scheme == NULL)) {
9344 xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9356 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9359 xmlErrAttributeDup(ctxt, aprefix, attname);
9361 if (nsPush(ctxt, attname, URL) > 0) nbNs++;
9368 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9371 maxatts = ctxt->maxatts;
9372 atts = ctxt->atts;
9374 ctxt->attallocs[nratts++] = alloc;
9386 atts[nbatts++] = ctxt->input->base;
9404 if (ctxt->instate == XML_PARSER_EOF)
9409 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9413 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
9415 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9422 if (ctxt->input->id != inputid) {
9423 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9436 ptrdiff_t offset = ctxt->input->base - atts[i+2];
9446 if (ctxt->attsDefault != NULL) {
9449 defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
9458 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9463 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
9467 nsname = xmlGetNamespace(ctxt, NULL);
9469 if (nsPush(ctxt, NULL,
9473 } else if (aprefix == ctxt->str_xmlns) {
9478 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9482 nsname = xmlGetNamespace(ctxt, attname);
9484 if (nsPush(ctxt, attname,
9499 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9502 maxatts = ctxt->maxatts;
9503 atts = ctxt->atts;
9510 atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
9513 if ((ctxt->standalone == 1) &&
9515 xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED,
9533 nsname = xmlGetNamespace(ctxt, atts[i + 1]);
9535 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9551 xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
9555 xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
9564 nsname = xmlGetNamespace(ctxt, prefix);
9566 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9576 if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
9577 (!ctxt->disableSAX)) {
9579 ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9580 nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
9583 ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9593 if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9602 * @ctxt: an XML parser context
9616 xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
9623 xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
9628 curLength = ctxt->input->end - ctxt->input->cur;
9630 (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
9632 (ctxt->input->cur[tlen] == '>')) {
9633 ctxt->input->cur += tlen + 1;
9634 ctxt->input->col += tlen + 1;
9637 ctxt->input->cur += tlen;
9638 ctxt->input->col += tlen;
9642 name = xmlParseNameAndCompare(ctxt, ctxt->name);
9644 name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
9651 if (ctxt->instate == XML_PARSER_EOF)
9655 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
9667 if ((line == 0) && (ctxt->node != NULL))
9668 line = ctxt->node->line;
9669 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
9671 ctxt->name, line, name);
9678 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
9679 (!ctxt->disableSAX))
9680 ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
9682 spacePop(ctxt);
9684 nsPop(ctxt, nsNr);
9690 * @ctxt: an XML parser context
9703 xmlParseCDSect(xmlParserCtxtPtr ctxt) {
9718 ctxt->instate = XML_PARSER_CDATA_SECTION;
9721 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9722 ctxt->instate = XML_PARSER_CONTENT;
9728 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9729 ctxt->instate = XML_PARSER_CONTENT;
9736 xmlErrMemory(ctxt, NULL);
9745 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9746 xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
9754 xmlErrMemory(ctxt, NULL);
9768 if (ctxt->instate == XML_PARSER_EOF) {
9778 ctxt->instate = XML_PARSER_CONTENT;
9780 xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
9790 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
9791 if (ctxt->sax->cdataBlock != NULL)
9792 ctxt->sax->cdataBlock(ctxt->userData, buf, len);
9793 else if (ctxt->sax->characters != NULL)
9794 ctxt->sax->characters(ctxt->userData, buf, len);
9801 * @ctxt: an XML parser context
9809 xmlParseContent(xmlParserCtxtPtr ctxt) {
9813 (ctxt->instate != XML_PARSER_EOF)) {
9815 unsigned int cons = ctxt->input->consumed;
9816 const xmlChar *cur = ctxt->input->cur;
9822 xmlParsePI(ctxt);
9830 xmlParseCDSect(ctxt);
9838 xmlParseComment(ctxt);
9839 ctxt->instate = XML_PARSER_CONTENT;
9846 xmlParseElement(ctxt);
9855 xmlParseReference(ctxt);
9862 xmlParseCharData(ctxt, 0);
9868 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
9869 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9871 xmlHaltParser(ctxt);
9879 * @ctxt: an XML parser context
9892 xmlParseElement(xmlParserCtxtPtr ctxt) {
9899 int nsNr = ctxt->nsNr;
9901 if (((unsigned int) ctxt->nameNr > xmlParserMaxDepth) &&
9902 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9903 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
9906 xmlHaltParser(ctxt);
9911 if (ctxt->record_info) {
9912 node_info.begin_pos = ctxt->input->consumed +
9913 (CUR_PTR - ctxt->input->base);
9914 node_info.begin_line = ctxt->input->line;
9917 if (ctxt->spaceNr == 0)
9918 spacePush(ctxt, -1);
9919 else if (*ctxt->space == -2)
9920 spacePush(ctxt, -1);
9922 spacePush(ctxt, *ctxt->space);
9924 line = ctxt->input->line;
9926 if (ctxt->sax2)
9928 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
9931 name = xmlParseStartTag(ctxt);
9933 if (ctxt->instate == XML_PARSER_EOF)
9936 spacePop(ctxt);
9939 namePush(ctxt, name);
9940 ret = ctxt->node;
9948 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
9949 ctxt->node && (ctxt->node == ctxt->myDoc->children))
9950 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
9958 if (ctxt->sax2) {
9959 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
9960 (!ctxt->disableSAX))
9961 ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
9964 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
9965 (!ctxt->disableSAX))
9966 ctxt->sax->endElement(ctxt->userData, name);
9969 namePop(ctxt);
9970 spacePop(ctxt);
9971 if (nsNr != ctxt->nsNr)
9972 nsPop(ctxt, ctxt->nsNr - nsNr);
9973 if ( ret != NULL && ctxt->record_info ) {
9974 node_info.end_pos = ctxt->input->consumed +
9975 (CUR_PTR - ctxt->input->base);
9976 node_info.end_line = ctxt->input->line;
9978 xmlParserAddNodeInfo(ctxt, &node_info);
9985 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
9992 nodePop(ctxt);
9993 namePop(ctxt);
9994 spacePop(ctxt);
9995 if (nsNr != ctxt->nsNr)
9996 nsPop(ctxt, ctxt->nsNr - nsNr);
10001 if ( ret != NULL && ctxt->record_info ) {
10002 node_info.end_pos = ctxt->input->consumed +
10003 (CUR_PTR - ctxt->input->base);
10004 node_info.end_line = ctxt->input->line;
10006 xmlParserAddNodeInfo(ctxt, &node_info);
10014 xmlParseContent(ctxt);
10015 if (ctxt->instate == XML_PARSER_EOF)
10018 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
10025 nodePop(ctxt);
10026 namePop(ctxt);
10027 spacePop(ctxt);
10028 if (nsNr != ctxt->nsNr)
10029 nsPop(ctxt, ctxt->nsNr - nsNr);
10036 if (ctxt->sax2) {
10037 xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
10038 namePop(ctxt);
10042 xmlParseEndTag1(ctxt, line);
10048 if ( ret != NULL && ctxt->record_info ) {
10049 node_info.end_pos = ctxt->input->consumed +
10050 (CUR_PTR - ctxt->input->base);
10051 node_info.end_line = ctxt->input->line;
10053 xmlParserAddNodeInfo(ctxt, &node_info);
10059 * @ctxt: an XML parser context
10070 xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
10078 xmlErrMemory(ctxt, NULL);
10104 xmlErrMemory(ctxt, NULL);
10119 * @ctxt: an XML parser context
10131 xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
10138 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10145 version = xmlParseVersionNum(ctxt);
10147 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10152 version = xmlParseVersionNum(ctxt);
10154 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10158 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10166 * @ctxt: an XML parser context
10175 xmlParseEncName(xmlParserCtxtPtr ctxt) {
10186 xmlErrMemory(ctxt, NULL);
10204 xmlErrMemory(ctxt, NULL);
10221 xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
10228 * @ctxt: an XML parser context
10240 xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
10248 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10255 encoding = xmlParseEncName(ctxt);
10257 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10264 encoding = xmlParseEncName(ctxt);
10266 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10272 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10278 if (ctxt->options & XML_PARSE_IGNORE_ENC) {
10296 if ((ctxt->encoding == NULL) &&
10297 (ctxt->input->buf != NULL) &&
10298 (ctxt->input->buf->encoder == NULL)) {
10299 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_ENCODING,
10302 if (ctxt->encoding != NULL)
10303 xmlFree((xmlChar *) ctxt->encoding);
10304 ctxt->encoding = encoding;
10312 if (ctxt->encoding != NULL)
10313 xmlFree((xmlChar *) ctxt->encoding);
10314 ctxt->encoding = encoding;
10319 if (ctxt->input->encoding != NULL)
10320 xmlFree((xmlChar *) ctxt->input->encoding);
10321 ctxt->input->encoding = encoding;
10325 if (xmlSwitchToEncoding(ctxt, handler) < 0) {
10327 ctxt->errNo = XML_ERR_UNSUPPORTED_ENCODING;
10331 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
10342 * @ctxt: an XML parser context
10372 xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
10380 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10395 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10398 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10411 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10414 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10418 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10426 * @ctxt: an XML parser context
10434 xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
10442 ctxt->input->standalone = -2;
10450 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
10458 version = xmlParseVersionInfo(ctxt);
10460 xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
10466 if (ctxt->options & XML_PARSE_OLD10) {
10467 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10472 xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
10476 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10482 if (ctxt->version != NULL)
10483 xmlFree((void *) ctxt->version);
10484 ctxt->version = version;
10495 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10497 xmlParseEncodingDecl(ctxt);
10498 if ((ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) ||
10499 (ctxt->instate == XML_PARSER_EOF)) {
10509 if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
10514 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10523 ctxt->input->standalone = xmlParseSDDecl(ctxt);
10530 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10533 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10541 * @ctxt: an XML parser context
10549 xmlParseMisc(xmlParserCtxtPtr ctxt) {
10550 while ((ctxt->instate != XML_PARSER_EOF) &&
10555 xmlParsePI(ctxt);
10559 xmlParseComment(ctxt);
10565 * @ctxt: an XML parser context
10579 xmlParseDocument(xmlParserCtxtPtr ctxt) {
10585 if ((ctxt == NULL) || (ctxt->input == NULL))
10593 xmlDetectSAX2(ctxt);
10598 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10599 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
10600 if (ctxt->instate == XML_PARSER_EOF)
10603 if ((ctxt->encoding == NULL) &&
10604 ((ctxt->input->end - ctxt->input->cur) >= 4)) {
10616 xmlSwitchEncoding(ctxt, enc);
10622 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10632 if ((ctxt->input->end - ctxt->input->cur) < 35) {
10640 xmlParseXMLDecl(ctxt);
10641 if ((ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) ||
10642 (ctxt->instate == XML_PARSER_EOF)) {
10648 ctxt->standalone = ctxt->input->standalone;
10651 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10653 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10654 ctxt->sax->startDocument(ctxt->userData);
10655 if (ctxt->instate == XML_PARSER_EOF)
10657 if ((ctxt->myDoc != NULL) && (ctxt->input != NULL) &&
10658 (ctxt->input->buf != NULL) && (ctxt->input->buf->compressed >= 0)) {
10659 ctxt->myDoc->compression = ctxt->input->buf->compressed;
10666 xmlParseMisc(ctxt);
10675 ctxt->inSubset = 1;
10676 xmlParseDocTypeDecl(ctxt);
10678 ctxt->instate = XML_PARSER_DTD;
10679 xmlParseInternalSubset(ctxt);
10680 if (ctxt->instate == XML_PARSER_EOF)
10687 ctxt->inSubset = 2;
10688 if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
10689 (!ctxt->disableSAX))
10690 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
10691 ctxt->extSubSystem, ctxt->extSubURI);
10692 if (ctxt->instate == XML_PARSER_EOF)
10694 ctxt->inSubset = 0;
10696 xmlCleanSpecialAttr(ctxt);
10698 ctxt->instate = XML_PARSER_PROLOG;
10699 xmlParseMisc(ctxt);
10707 xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
10710 ctxt->instate = XML_PARSER_CONTENT;
10711 xmlParseElement(ctxt);
10712 ctxt->instate = XML_PARSER_EPILOG;
10718 xmlParseMisc(ctxt);
10721 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10723 ctxt->instate = XML_PARSER_EOF;
10729 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10730 ctxt->sax->endDocument(ctxt->userData);
10735 if ((ctxt->myDoc != NULL) &&
10736 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
10737 xmlFreeDoc(ctxt->myDoc);
10738 ctxt->myDoc = NULL;
10741 if ((ctxt->wellFormed) && (ctxt->myDoc != NULL)) {
10742 ctxt->myDoc->properties |= XML_DOC_WELLFORMED;
10743 if (ctxt->valid)
10744 ctxt->myDoc->properties |= XML_DOC_DTDVALID;
10745 if (ctxt->nsWellFormed)
10746 ctxt->myDoc->properties |= XML_DOC_NSVALID;
10747 if (ctxt->options & XML_PARSE_OLD10)
10748 ctxt->myDoc->properties |= XML_DOC_OLD10;
10750 if (! ctxt->wellFormed) {
10751 ctxt->valid = 0;
10759 * @ctxt: an XML parser context
10772 xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
10776 if ((ctxt == NULL) || (ctxt->input == NULL))
10781 xmlDetectSAX2(ctxt);
10788 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10789 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
10796 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
10803 xmlSwitchEncoding(ctxt, enc);
10809 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10821 xmlParseXMLDecl(ctxt);
10822 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10830 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10832 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10833 ctxt->sax->startDocument(ctxt->userData);
10834 if (ctxt->instate == XML_PARSER_EOF)
10840 ctxt->instate = XML_PARSER_CONTENT;
10841 ctxt->validate = 0;
10842 ctxt->loadsubset = 0;
10843 ctxt->depth = 0;
10845 xmlParseContent(ctxt);
10846 if (ctxt->instate == XML_PARSER_EOF)
10850 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
10852 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
10858 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10859 ctxt->sax->endDocument(ctxt->userData);
10861 if (! ctxt->wellFormed) return(-1);
10874 * @ctxt: an XML parser context
10881 * This function has a side effect of (possibly) incrementing ctxt->checkIndex
10889 xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
10895 in = ctxt->input;
10899 if (ctxt->checkIndex > base)
10900 base = ctxt->checkIndex;
10919 ctxt->checkIndex = 0;
10937 ctxt->checkIndex = base;
10954 * @ctxt: an XML parser context
10961 xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
10965 if ((ctxt == NULL) || (lastlt == NULL) || (lastgt == NULL)) {
10970 if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) {
10971 tmp = ctxt->input->end;
10973 while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
10974 if (tmp < ctxt->input->base) {
10980 while ((tmp < ctxt->input->end) && (*tmp != '>')) {
10983 while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++;
10984 if (tmp < ctxt->input->end) tmp++;
10987 while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++;
10988 if (tmp < ctxt->input->end) tmp++;
10992 if (tmp < ctxt->input->end)
10997 while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
10998 if (tmp >= ctxt->input->base)
11079 * @ctxt: an XML parser context
11087 xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
11093 if (ctxt->input == NULL)
11097 switch (ctxt->instate) {
11149 if ((ctxt->input != NULL) &&
11150 (ctxt->input->cur - ctxt->input->base > 4096)) {
11151 xmlSHRINK(ctxt);
11152 ctxt->checkIndex = 0;
11154 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11156 while (ctxt->instate != XML_PARSER_EOF) {
11157 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
11160 if (ctxt->input == NULL) break;
11161 if (ctxt->input->buf == NULL)
11162 avail = ctxt->input->length -
11163 (ctxt->input->cur - ctxt->input->base);
11172 if ((ctxt->instate != XML_PARSER_START) &&
11173 (ctxt->input->buf->raw != NULL) &&
11174 (xmlBufIsEmpty(ctxt->input->buf->raw) == 0)) {
11175 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer,
11176 ctxt->input);
11177 size_t current = ctxt->input->cur - ctxt->input->base;
11179 xmlParserInputBufferPush(ctxt->input->buf, 0, "");
11180 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input,
11183 avail = xmlBufUse(ctxt->input->buf->buffer) -
11184 (ctxt->input->cur - ctxt->input->base);
11188 switch (ctxt->instate) {
11195 if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
11217 xmlSwitchEncoding(ctxt, enc);
11223 cur = ctxt->input->cur[0];
11224 next = ctxt->input->cur[1];
11226 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11227 ctxt->sax->setDocumentLocator(ctxt->userData,
11229 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11230 xmlHaltParser(ctxt);
11235 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11236 ctxt->sax->endDocument(ctxt->userData);
11243 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11245 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11246 ctxt->sax->setDocumentLocator(ctxt->userData,
11248 if ((ctxt->input->cur[2] == 'x') &&
11249 (ctxt->input->cur[3] == 'm') &&
11250 (ctxt->input->cur[4] == 'l') &&
11251 (IS_BLANK_CH(ctxt->input->cur[5]))) {
11257 xmlParseXMLDecl(ctxt);
11258 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
11263 xmlHaltParser(ctxt);
11266 ctxt->standalone = ctxt->input->standalone;
11267 if ((ctxt->encoding == NULL) &&
11268 (ctxt->input->encoding != NULL))
11269 ctxt->encoding = xmlStrdup(ctxt->input->encoding);
11270 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11271 (!ctxt->disableSAX))
11272 ctxt->sax->startDocument(ctxt->userData);
11273 ctxt->instate = XML_PARSER_MISC;
11279 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11280 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11281 (!ctxt->disableSAX))
11282 ctxt->sax->startDocument(ctxt->userData);
11283 ctxt->instate = XML_PARSER_MISC;
11290 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11291 ctxt->sax->setDocumentLocator(ctxt->userData,
11293 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11294 if (ctxt->version == NULL) {
11295 xmlErrMemory(ctxt, NULL);
11298 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11299 (!ctxt->disableSAX))
11300 ctxt->sax->startDocument(ctxt->userData);
11301 ctxt->instate = XML_PARSER_MISC;
11312 int nsNr = ctxt->nsNr;
11314 if ((avail < 2) && (ctxt->inputNr == 1))
11316 cur = ctxt->input->cur[0];
11318 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11319 xmlHaltParser(ctxt);
11320 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11321 ctxt->sax->endDocument(ctxt->userData);
11325 if (ctxt->progressive) {
11327 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
11329 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
11333 if (ctxt->spaceNr == 0)
11334 spacePush(ctxt, -1);
11335 else if (*ctxt->space == -2)
11336 spacePush(ctxt, -1);
11338 spacePush(ctxt, *ctxt->space);
11340 if (ctxt->sax2)
11342 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
11345 name = xmlParseStartTag(ctxt);
11347 if (ctxt->instate == XML_PARSER_EOF)
11350 spacePop(ctxt);
11351 xmlHaltParser(ctxt);
11352 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11353 ctxt->sax->endDocument(ctxt->userData);
11362 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
11363 ctxt->node && (ctxt->node == ctxt->myDoc->children))
11364 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
11373 if (ctxt->sax2) {
11374 if ((ctxt->sax != NULL) &&
11375 (ctxt->sax->endElementNs != NULL) &&
11376 (!ctxt->disableSAX))
11377 ctxt->sax->endElementNs(ctxt->userData, name,
11379 if (ctxt->nsNr - nsNr > 0)
11380 nsPop(ctxt, ctxt->nsNr - nsNr);
11383 if ((ctxt->sax != NULL) &&
11384 (ctxt->sax->endElement != NULL) &&
11385 (!ctxt->disableSAX))
11386 ctxt->sax->endElement(ctxt->userData, name);
11389 if (ctxt->instate == XML_PARSER_EOF)
11391 spacePop(ctxt);
11392 if (ctxt->nameNr == 0) {
11393 ctxt->instate = XML_PARSER_EPILOG;
11395 ctxt->instate = XML_PARSER_CONTENT;
11397 ctxt->progressive = 1;
11403 xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
11406 nodePop(ctxt);
11407 spacePop(ctxt);
11409 if (ctxt->sax2)
11410 nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
11413 namePush(ctxt, name);
11416 ctxt->instate = XML_PARSER_CONTENT;
11417 ctxt->progressive = 1;
11423 if ((avail < 2) && (ctxt->inputNr == 1))
11425 cur = ctxt->input->cur[0];
11426 next = ctxt->input->cur[1];
11429 cons = ctxt->input->consumed;
11431 ctxt->instate = XML_PARSER_END_TAG;
11435 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11436 ctxt->progressive = XML_PARSER_PI;
11439 xmlParsePI(ctxt);
11440 ctxt->instate = XML_PARSER_CONTENT;
11441 ctxt->progressive = 1;
11443 ctxt->instate = XML_PARSER_START_TAG;
11446 (ctxt->input->cur[2] == '-') &&
11447 (ctxt->input->cur[3] == '-')) {
11452 ctxt->input->cur += 4;
11453 term = xmlParseLookupSequence(ctxt, '-', '-', '>');
11454 ctxt->input->cur -= 4;
11456 ctxt->progressive = XML_PARSER_COMMENT;
11459 xmlParseComment(ctxt);
11460 ctxt->instate = XML_PARSER_CONTENT;
11461 ctxt->progressive = 1;
11462 } else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
11463 (ctxt->input->cur[2] == '[') &&
11464 (ctxt->input->cur[3] == 'C') &&
11465 (ctxt->input->cur[4] == 'D') &&
11466 (ctxt->input->cur[5] == 'A') &&
11467 (ctxt->input->cur[6] == 'T') &&
11468 (ctxt->input->cur[7] == 'A') &&
11469 (ctxt->input->cur[8] == '[')) {
11471 ctxt->instate = XML_PARSER_CDATA_SECTION;
11478 (xmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
11480 xmlParseReference(ctxt);
11494 if ((ctxt->inputNr == 1) &&
11497 if (ctxt->progressive) {
11499 (ctxt->input->cur > lastlt))
11501 } else if (xmlParseLookupSequence(ctxt,
11507 ctxt->checkIndex = 0;
11508 xmlParseCharData(ctxt, 0);
11510 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
11511 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
11513 xmlHaltParser(ctxt);
11522 if (ctxt->progressive) {
11524 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
11526 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
11530 if (ctxt->sax2) {
11531 xmlParseEndTag2(ctxt,
11532 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 3],
11533 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 2], 0,
11535 ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
11536 nameNsPop(ctxt);
11540 xmlParseEndTag1(ctxt, 0);
11542 if (ctxt->instate == XML_PARSER_EOF) {
11544 } else if (ctxt->nameNr == 0) {
11545 ctxt->instate = XML_PARSER_EPILOG;
11547 ctxt->instate = XML_PARSER_CONTENT;
11557 base = xmlParseLookupSequence(ctxt, ']', ']', '>');
11562 tmp = xmlCheckCdataPush(ctxt->input->cur,
11566 ctxt->input->cur += tmp;
11569 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
11570 if (ctxt->sax->cdataBlock != NULL)
11571 ctxt->sax->cdataBlock(ctxt->userData,
11572 ctxt->input->cur, tmp);
11573 else if (ctxt->sax->characters != NULL)
11574 ctxt->sax->characters(ctxt->userData,
11575 ctxt->input->cur, tmp);
11577 if (ctxt->instate == XML_PARSER_EOF)
11580 ctxt->checkIndex = 0;
11586 tmp = xmlCheckCdataPush(ctxt->input->cur, base, 1);
11589 ctxt->input->cur += tmp;
11592 if ((ctxt->sax != NULL) && (base == 0) &&
11593 (ctxt->sax->cdataBlock != NULL) &&
11594 (!ctxt->disableSAX)) {
11600 if ((ctxt->input->cur - ctxt->input->base >= 9) &&
11601 (!strncmp((const char *)&ctxt->input->cur[-9],
11603 ctxt->sax->cdataBlock(ctxt->userData,
11605 } else if ((ctxt->sax != NULL) && (base > 0) &&
11606 (!ctxt->disableSAX)) {
11607 if (ctxt->sax->cdataBlock != NULL)
11608 ctxt->sax->cdataBlock(ctxt->userData,
11609 ctxt->input->cur, base);
11610 else if (ctxt->sax->characters != NULL)
11611 ctxt->sax->characters(ctxt->userData,
11612 ctxt->input->cur, base);
11614 if (ctxt->instate == XML_PARSER_EOF)
11617 ctxt->checkIndex = 0;
11618 ctxt->instate = XML_PARSER_CONTENT;
11628 if (ctxt->input->buf == NULL)
11629 avail = ctxt->input->length -
11630 (ctxt->input->cur - ctxt->input->base);
11632 avail = xmlBufUse(ctxt->input->buf->buffer) -
11633 (ctxt->input->cur - ctxt->input->base);
11636 cur = ctxt->input->cur[0];
11637 next = ctxt->input->cur[1];
11640 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11641 ctxt->progressive = XML_PARSER_PI;
11648 xmlParsePI(ctxt);
11649 if (ctxt->instate == XML_PARSER_EOF)
11651 ctxt->instate = XML_PARSER_MISC;
11652 ctxt->progressive = 1;
11653 ctxt->checkIndex = 0;
11655 (ctxt->input->cur[2] == '-') &&
11656 (ctxt->input->cur[3] == '-')) {
11658 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
11659 ctxt->progressive = XML_PARSER_COMMENT;
11666 xmlParseComment(ctxt);
11667 if (ctxt->instate == XML_PARSER_EOF)
11669 ctxt->instate = XML_PARSER_MISC;
11670 ctxt->progressive = 1;
11671 ctxt->checkIndex = 0;
11673 (ctxt->input->cur[2] == 'D') &&
11674 (ctxt->input->cur[3] == 'O') &&
11675 (ctxt->input->cur[4] == 'C') &&
11676 (ctxt->input->cur[5] == 'T') &&
11677 (ctxt->input->cur[6] == 'Y') &&
11678 (ctxt->input->cur[7] == 'P') &&
11679 (ctxt->input->cur[8] == 'E')) {
11681 (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0)) {
11682 ctxt->progressive = XML_PARSER_DTD;
11689 ctxt->inSubset = 1;
11690 ctxt->progressive = 0;
11691 ctxt->checkIndex = 0;
11692 xmlParseDocTypeDecl(ctxt);
11693 if (ctxt->instate == XML_PARSER_EOF)
11696 ctxt->instate = XML_PARSER_DTD;
11705 ctxt->inSubset = 2;
11706 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11707 (ctxt->sax->externalSubset != NULL))
11708 ctxt->sax->externalSubset(ctxt->userData,
11709 ctxt->intSubName, ctxt->extSubSystem,
11710 ctxt->extSubURI);
11711 ctxt->inSubset = 0;
11712 xmlCleanSpecialAttr(ctxt);
11713 ctxt->instate = XML_PARSER_PROLOG;
11723 ctxt->instate = XML_PARSER_START_TAG;
11724 ctxt->progressive = XML_PARSER_START_TAG;
11725 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11734 if (ctxt->input->buf == NULL)
11735 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
11737 avail = xmlBufUse(ctxt->input->buf->buffer) -
11738 (ctxt->input->cur - ctxt->input->base);
11741 cur = ctxt->input->cur[0];
11742 next = ctxt->input->cur[1];
11745 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11746 ctxt->progressive = XML_PARSER_PI;
11753 xmlParsePI(ctxt);
11754 if (ctxt->instate == XML_PARSER_EOF)
11756 ctxt->instate = XML_PARSER_PROLOG;
11757 ctxt->progressive = 1;
11759 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
11761 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
11762 ctxt->progressive = XML_PARSER_COMMENT;
11769 xmlParseComment(ctxt);
11770 if (ctxt->instate == XML_PARSER_EOF)
11772 ctxt->instate = XML_PARSER_PROLOG;
11773 ctxt->progressive = 1;
11778 ctxt->instate = XML_PARSER_START_TAG;
11779 if (ctxt->progressive == 0)
11780 ctxt->progressive = XML_PARSER_START_TAG;
11781 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11790 if (ctxt->input->buf == NULL)
11791 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
11793 avail = xmlBufUse(ctxt->input->buf->buffer) -
11794 (ctxt->input->cur - ctxt->input->base);
11797 cur = ctxt->input->cur[0];
11798 next = ctxt->input->cur[1];
11801 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11802 ctxt->progressive = XML_PARSER_PI;
11809 xmlParsePI(ctxt);
11810 if (ctxt->instate == XML_PARSER_EOF)
11812 ctxt->instate = XML_PARSER_EPILOG;
11813 ctxt->progressive = 1;
11815 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
11817 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
11818 ctxt->progressive = XML_PARSER_COMMENT;
11825 xmlParseComment(ctxt);
11826 if (ctxt->instate == XML_PARSER_EOF)
11828 ctxt->instate = XML_PARSER_EPILOG;
11829 ctxt->progressive = 1;
11834 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
11835 xmlHaltParser(ctxt);
11840 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11841 ctxt->sax->endDocument(ctxt->userData);
11861 base = ctxt->input->cur - ctxt->input->base;
11863 if (ctxt->checkIndex > base)
11864 base = ctxt->checkIndex;
11865 buf = xmlBufContent(ctxt->input->buf->buffer);
11866 use = xmlBufUse(ctxt->input->buf->buffer);
11945 ctxt->checkIndex = base;
11947 ctxt->checkIndex = 0;
11956 ctxt->checkIndex = 0;
11957 xmlParseInternalSubset(ctxt);
11958 if (ctxt->instate == XML_PARSER_EOF)
11960 ctxt->inSubset = 2;
11961 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11962 (ctxt->sax->externalSubset != NULL))
11963 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
11964 ctxt->extSubSystem, ctxt->extSubURI);
11965 ctxt->inSubset = 0;
11966 xmlCleanSpecialAttr(ctxt);
11967 if (ctxt->instate == XML_PARSER_EOF)
11969 ctxt->instate = XML_PARSER_PROLOG;
11970 ctxt->checkIndex = 0;
11980 ctxt->instate = XML_PARSER_CONTENT;
11989 ctxt->instate = XML_PARSER_DTD;
11998 ctxt->instate = XML_PARSER_CONTENT;
12007 ctxt->instate = XML_PARSER_DTD;
12016 ctxt->instate = XML_PARSER_CONTENT;
12025 ctxt->instate = XML_PARSER_START_TAG;
12034 ctxt->instate = XML_PARSER_START_TAG;
12043 ctxt->instate = XML_PARSER_START_TAG;
12061 ctxt->input->cur[0], ctxt->input->cur[1],
12062 ctxt->input->cur[2], ctxt->input->cur[3]);
12063 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
12072 * @ctxt: an XML parser context
12082 xmlParseCheckTransition(xmlParserCtxtPtr ctxt, const char *chunk, int size) {
12083 if ((ctxt == NULL) || (chunk == NULL) || (size < 0))
12085 if (ctxt->instate == XML_PARSER_START_TAG) {
12090 if (ctxt->progressive == XML_PARSER_COMMENT) {
12095 if (ctxt->instate == XML_PARSER_CDATA_SECTION) {
12100 if (ctxt->progressive == XML_PARSER_PI) {
12105 if (ctxt->instate == XML_PARSER_END_TAG) {
12110 if ((ctxt->progressive == XML_PARSER_DTD) ||
12111 (ctxt->instate == XML_PARSER_DTD)) {
12121 * @ctxt: an XML parser context
12131 xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
12138 if (ctxt == NULL)
12140 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
12141 return(ctxt->errNo);
12142 if (ctxt->instate == XML_PARSER_EOF)
12144 if (ctxt->instate == XML_PARSER_START)
12145 xmlDetectSAX2(ctxt);
12154 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
12155 (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF)) {
12156 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
12157 size_t cur = ctxt->input->cur - ctxt->input->base;
12160 old_avail = xmlBufUse(ctxt->input->buf->buffer);
12166 if ((ctxt->instate == XML_PARSER_START) && (ctxt->input != NULL) &&
12167 (ctxt->input->buf != NULL) && (ctxt->input->buf->encoder != NULL)) {
12170 if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12172 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12175 else if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12177 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12181 if (ctxt->input->buf->rawconsumed < len)
12182 len -= ctxt->input->buf->rawconsumed;
12196 res = xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
12198 ctxt->errNo = XML_PARSER_EOF;
12199 xmlHaltParser(ctxt);
12202 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
12207 } else if (ctxt->instate != XML_PARSER_EOF) {
12208 if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
12209 xmlParserInputBufferPtr in = ctxt->input->buf;
12213 size_t base = xmlBufGetInputBase(in->buffer, ctxt->input);
12214 size_t current = ctxt->input->cur - ctxt->input->base;
12221 xmlHaltParser(ctxt);
12224 xmlBufSetInputBaseCur(in->buffer, ctxt->input, base, current);
12229 xmlParseTryOrFinish(ctxt, 0);
12231 if ((ctxt->input != NULL) && (ctxt->input->buf != NULL))
12232 avail = xmlBufUse(ctxt->input->buf->buffer);
12241 (xmlParseCheckTransition(ctxt,
12242 (const char *)&ctxt->input->base[old_avail],
12244 xmlParseTryOrFinish(ctxt, terminate);
12246 if (ctxt->instate == XML_PARSER_EOF)
12247 return(ctxt->errNo);
12249 if ((ctxt->input != NULL) &&
12250 (((ctxt->input->end - ctxt->input->cur) > XML_MAX_LOOKUP_LIMIT) ||
12251 ((ctxt->input->cur - ctxt->input->base) > XML_MAX_LOOKUP_LIMIT)) &&
12252 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
12253 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "Huge input lookup");
12254 xmlHaltParser(ctxt);
12256 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
12257 return(ctxt->errNo);
12265 if ((end_in_lf == 1) && (ctxt->input != NULL) &&
12266 (ctxt->input->buf != NULL)) {
12267 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer,
12268 ctxt->input);
12269 size_t current = ctxt->input->cur - ctxt->input->base;
12271 xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
12273 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input,
12282 if (ctxt->input != NULL) {
12283 if (ctxt->input->buf == NULL)
12284 cur_avail = ctxt->input->length -
12285 (ctxt->input->cur - ctxt->input->base);
12287 cur_avail = xmlBufUse(ctxt->input->buf->buffer) -
12288 (ctxt->input->cur - ctxt->input->base);
12291 if ((ctxt->instate != XML_PARSER_EOF) &&
12292 (ctxt->instate != XML_PARSER_EPILOG)) {
12293 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
12295 if ((ctxt->instate == XML_PARSER_EPILOG) && (cur_avail > 0)) {
12296 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
12298 if (ctxt->instate != XML_PARSER_EOF) {
12299 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
12300 ctxt->sax->endDocument(ctxt->userData);
12302 ctxt->instate = XML_PARSER_EOF;
12304 if (ctxt->wellFormed == 0)
12305 return((xmlParserErrors) ctxt->errNo);
12338 xmlParserCtxtPtr ctxt;
12352 ctxt = xmlNewParserCtxt();
12353 if (ctxt == NULL) {
12358 ctxt->dictNames = 1;
12359 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * sizeof(xmlChar *));
12360 if (ctxt->pushTab == NULL) {
12361 xmlErrMemory(ctxt, NULL);
12363 xmlFreeParserCtxt(ctxt);
12368 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12370 xmlFree(ctxt->sax);
12371 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
12372 if (ctxt->sax == NULL) {
12373 xmlErrMemory(ctxt, NULL);
12375 xmlFreeParserCtxt(ctxt);
12378 memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
12380 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
12382 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12384 ctxt->userData = user_data;
12387 ctxt->directory = NULL;
12389 ctxt->directory = xmlParserGetDirectory(filename);
12392 inputStream = xmlNewInputStream(ctxt);
12394 xmlFreeParserCtxt(ctxt);
12405 xmlFreeParserCtxt(ctxt);
12412 inputPush(ctxt, inputStream);
12420 ctxt->charset = XML_CHAR_ENCODING_NONE;
12421 } else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) {
12422 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
12423 size_t cur = ctxt->input->cur - ctxt->input->base;
12425 xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
12427 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
12434 xmlSwitchEncoding(ctxt, enc);
12437 return(ctxt);
12443 * @ctxt: an XML parser context
12449 xmlHaltParser(xmlParserCtxtPtr ctxt) {
12450 if (ctxt == NULL)
12452 ctxt->instate = XML_PARSER_EOF;
12453 ctxt->disableSAX = 1;
12454 while (ctxt->inputNr > 1)
12455 xmlFreeInputStream(inputPop(ctxt));
12456 if (ctxt->input != NULL) {
12461 if (ctxt->input->free != NULL) {
12462 ctxt->input->free((xmlChar *) ctxt->input->base);
12463 ctxt->input->free = NULL;
12465 ctxt->input->cur = BAD_CAST"";
12466 ctxt->input->base = ctxt->input->cur;
12467 ctxt->input->end = ctxt->input->cur;
12473 * @ctxt: an XML parser context
12478 xmlStopParser(xmlParserCtxtPtr ctxt) {
12479 if (ctxt == NULL)
12481 xmlHaltParser(ctxt);
12482 ctxt->errNo = XML_ERR_USER_STOP;
12503 xmlParserCtxtPtr ctxt;
12516 ctxt = xmlNewParserCtxt();
12517 if (ctxt == NULL) {
12523 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12525 xmlFree(ctxt->sax);
12526 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
12527 if (ctxt->sax == NULL) {
12528 xmlErrMemory(ctxt, NULL);
12529 xmlFreeParserCtxt(ctxt);
12532 memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
12534 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
12536 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12538 ctxt->userData = user_data;
12541 inputStream = xmlNewIOInputStream(ctxt, buf, enc);
12543 xmlFreeParserCtxt(ctxt);
12546 inputPush(ctxt, inputStream);
12548 return(ctxt);
12574 xmlParserCtxtPtr ctxt;
12581 ctxt = xmlNewParserCtxt();
12582 if (ctxt == NULL) {
12588 ctxt->options |= XML_PARSE_DTDLOAD;
12594 if (ctxt->sax != NULL)
12595 xmlFree(ctxt->sax);
12596 ctxt->sax = sax;
12597 ctxt->userData = ctxt;
12599 xmlDetectSAX2(ctxt);
12605 pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
12607 if (sax != NULL) ctxt->sax = NULL;
12609 xmlFreeParserCtxt(ctxt);
12616 if (xmlPushInput(ctxt, pinput) < 0) {
12617 if (sax != NULL) ctxt->sax = NULL;
12618 xmlFreeParserCtxt(ctxt);
12622 xmlSwitchEncoding(ctxt, enc);
12628 pinput->base = ctxt->input->cur;
12629 pinput->cur = ctxt->input->cur;
12635 ctxt->inSubset = 2;
12636 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
12637 if (ctxt->myDoc == NULL) {
12638 xmlErrMemory(ctxt, "New Doc failed");
12641 ctxt->myDoc->properties = XML_DOC_INTERNAL;
12642 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
12646 ((ctxt->input->end - ctxt->input->cur) >= 4)) {
12658 xmlSwitchEncoding(ctxt, enc);
12662 xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
12664 if (ctxt->myDoc != NULL) {
12665 if (ctxt->wellFormed) {
12666 ret = ctxt->myDoc->extSubset;
12667 ctxt->myDoc->extSubset = NULL;
12681 xmlFreeDoc(ctxt->myDoc);
12682 ctxt->myDoc = NULL;
12684 if (sax != NULL) ctxt->sax = NULL;
12685 xmlFreeParserCtxt(ctxt);
12705 xmlParserCtxtPtr ctxt;
12712 ctxt = xmlNewParserCtxt();
12713 if (ctxt == NULL) {
12718 ctxt->options |= XML_PARSE_DTDLOAD;
12724 if (ctxt->sax != NULL)
12725 xmlFree(ctxt->sax);
12726 ctxt->sax = sax;
12727 ctxt->userData = ctxt;
12735 xmlFreeParserCtxt(ctxt);
12743 if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
12744 input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
12747 if (sax != NULL) ctxt->sax = NULL;
12748 xmlFreeParserCtxt(ctxt);
12757 if (xmlPushInput(ctxt, input) < 0) {
12758 if (sax != NULL) ctxt->sax = NULL;
12759 xmlFreeParserCtxt(ctxt);
12764 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
12765 enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
12766 xmlSwitchEncoding(ctxt, enc);
12775 input->base = ctxt->input->cur;
12776 input->cur = ctxt->input->cur;
12782 ctxt->inSubset = 2;
12783 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
12784 if (ctxt->myDoc == NULL) {
12785 xmlErrMemory(ctxt, "New Doc failed");
12786 if (sax != NULL) ctxt->sax = NULL;
12787 xmlFreeParserCtxt(ctxt);
12790 ctxt->myDoc->properties = XML_DOC_INTERNAL;
12791 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
12793 xmlParseExternalSubset(ctxt, ExternalID, SystemID);
12795 if (ctxt->myDoc != NULL) {
12796 if (ctxt->wellFormed) {
12797 ret = ctxt->myDoc->extSubset;
12798 ctxt->myDoc->extSubset = NULL;
12812 xmlFreeDoc(ctxt->myDoc);
12813 ctxt->myDoc = NULL;
12815 if (sax != NULL) ctxt->sax = NULL;
12816 xmlFreeParserCtxt(ctxt);
12864 xmlParserCtxtPtr ctxt;
12886 ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, ctx);
12887 if (ctxt == NULL) {
12891 oldsax = ctxt->sax;
12892 ctxt->sax = ctx->sax;
12893 xmlDetectSAX2(ctxt);
12896 xmlFreeParserCtxt(ctxt);
12913 ctxt->sax = oldsax;
12914 xmlFreeParserCtxt(ctxt);
12921 nodePush(ctxt, newDoc->children);
12923 ctxt->myDoc = newDoc;
12925 ctxt->myDoc = ctx->myDoc;
12935 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
12942 xmlSwitchEncoding(ctxt, enc);
12950 xmlParseTextDecl(ctxt);
12955 (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) {
12956 xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH,
12964 * DOM builder is to have userData == ctxt
12967 ctxt->userData = ctxt;
12969 ctxt->userData = ctx->userData;
12974 ctxt->instate = XML_PARSER_CONTENT;
12975 ctxt->validate = ctx->validate;
12976 ctxt->valid = ctx->valid;
12977 ctxt->loadsubset = ctx->loadsubset;
12978 ctxt->depth = ctx->depth + 1;
12979 ctxt->replaceEntities = ctx->replaceEntities;
12980 if (ctxt->validate) {
12981 ctxt->vctxt.error = ctx->vctxt.error;
12982 ctxt->vctxt.warning = ctx->vctxt.warning;
12984 ctxt->vctxt.error = NULL;
12985 ctxt->vctxt.warning = NULL;
12987 ctxt->vctxt.nodeTab = NULL;
12988 ctxt->vctxt.nodeNr = 0;
12989 ctxt->vctxt.nodeMax = 0;
12990 ctxt->vctxt.node = NULL;
12991 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
12992 ctxt->dict = ctx->dict;
12993 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
12994 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
12995 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
12996 ctxt->dictNames = ctx->dictNames;
12997 ctxt->attsDefault = ctx->attsDefault;
12998 ctxt->attsSpecial = ctx->attsSpecial;
12999 ctxt->linenumbers = ctx->linenumbers;
13001 xmlParseContent(ctxt);
13003 ctx->validate = ctxt->validate;
13004 ctx->valid = ctxt->valid;
13006 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13008 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13010 if (ctxt->node != newDoc->children) {
13011 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13014 if (!ctxt->wellFormed) {
13015 if (ctxt->errNo == 0)
13018 ret = ctxt->errNo;
13037 ctxt->sax = oldsax;
13038 ctxt->dict = NULL;
13039 ctxt->attsDefault = NULL;
13040 ctxt->attsSpecial = NULL;
13041 xmlFreeParserCtxt(ctxt);
13071 xmlParserCtxtPtr ctxt;
13093 ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, oldctxt);
13094 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
13095 ctxt->userData = ctxt;
13097 ctxt->_private = oldctxt->_private;
13098 ctxt->loadsubset = oldctxt->loadsubset;
13099 ctxt->validate = oldctxt->validate;
13100 ctxt->external = oldctxt->external;
13101 ctxt->record_info = oldctxt->record_info;
13102 ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
13103 ctxt->node_seq.length = oldctxt->node_seq.length;
13104 ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
13110 ctxt->_private = NULL;
13111 ctxt->validate = 0;
13112 ctxt->external = 2;
13113 ctxt->loadsubset = 0;
13116 oldsax = ctxt->sax;
13117 ctxt->sax = sax;
13119 ctxt->userData = user_data;
13121 xmlDetectSAX2(ctxt);
13124 ctxt->node_seq.maximum = 0;
13125 ctxt->node_seq.length = 0;
13126 ctxt->node_seq.buffer = NULL;
13127 xmlFreeParserCtxt(ctxt);
13142 ctxt->sax = oldsax;
13143 ctxt->node_seq.maximum = 0;
13144 ctxt->node_seq.length = 0;
13145 ctxt->node_seq.buffer = NULL;
13146 xmlFreeParserCtxt(ctxt);
13153 nodePush(ctxt, newDoc->children);
13154 ctxt->myDoc = doc;
13163 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
13170 xmlSwitchEncoding(ctxt, enc);
13178 xmlParseTextDecl(ctxt);
13181 ctxt->instate = XML_PARSER_CONTENT;
13182 ctxt->depth = depth;
13184 xmlParseContent(ctxt);
13187 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13189 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13191 if (ctxt->node != newDoc->children) {
13192 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13195 if (!ctxt->wellFormed) {
13196 if (ctxt->errNo == 0)
13199 ret = (xmlParserErrors)ctxt->errNo;
13224 oldctxt->nbentities += ctxt->nbentities;
13229 if (ctxt->input != NULL && oldctxt != NULL) {
13230 oldctxt->sizeentities += ctxt->input->consumed;
13231 oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base);
13236 if ((oldctxt != NULL) && (ctxt->lastError.code != XML_ERR_OK))
13237 xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
13240 ctxt->sax = oldsax;
13242 oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
13243 oldctxt->node_seq.length = ctxt->node_seq.length;
13244 oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
13246 ctxt->node_seq.maximum = 0;
13247 ctxt->node_seq.length = 0;
13248 ctxt->node_seq.buffer = NULL;
13249 xmlFreeParserCtxt(ctxt);
13337 xmlParserCtxtPtr ctxt;
13362 ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
13363 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
13365 ctxt->userData = user_data;
13367 ctxt->userData = ctxt;
13368 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
13369 ctxt->dict = oldctxt->dict;
13370 ctxt->input_id = oldctxt->input_id + 1;
13371 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
13372 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
13373 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
13378 nsPush(ctxt, oldctxt->nsTab[i], oldctxt->nsTab[i+1]);
13382 oldsax = ctxt->sax;
13383 ctxt->sax = oldctxt->sax;
13384 xmlDetectSAX2(ctxt);
13385 ctxt->replaceEntities = oldctxt->replaceEntities;
13386 ctxt->options = oldctxt->options;
13388 ctxt->_private = oldctxt->_private;
13392 ctxt->sax = oldsax;
13393 ctxt->dict = NULL;
13394 xmlFreeParserCtxt(ctxt);
13398 newDoc->dict = ctxt->dict;
13400 ctxt->myDoc = newDoc;
13402 ctxt->myDoc = oldctxt->myDoc;
13403 content = ctxt->myDoc->children;
13404 last = ctxt->myDoc->last;
13406 newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
13408 ctxt->sax = oldsax;
13409 ctxt->dict = NULL;
13410 xmlFreeParserCtxt(ctxt);
13416 ctxt->myDoc->children = NULL;
13417 ctxt->myDoc->last = NULL;
13418 xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
13419 nodePush(ctxt, ctxt->myDoc->children);
13420 ctxt->instate = XML_PARSER_CONTENT;
13421 ctxt->depth = oldctxt->depth + 1;
13423 ctxt->validate = 0;
13424 ctxt->loadsubset = oldctxt->loadsubset;
13429 ctxt->loadsubset |= XML_SKIP_IDS;
13431 ctxt->dictNames = oldctxt->dictNames;
13432 ctxt->attsDefault = oldctxt->attsDefault;
13433 ctxt->attsSpecial = oldctxt->attsSpecial;
13435 xmlParseContent(ctxt);
13437 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13439 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13441 if (ctxt->node != ctxt->myDoc->children) {
13442 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13445 if (!ctxt->wellFormed) {
13446 if (ctxt->errNo == 0)
13449 ret = (xmlParserErrors)ctxt->errNo;
13461 cur = ctxt->myDoc->children->children;
13475 ctxt->myDoc->children->children = NULL;
13477 if (ctxt->myDoc != NULL) {
13478 xmlFreeNode(ctxt->myDoc->children);
13479 ctxt->myDoc->children = content;
13480 ctxt->myDoc->last = last;
13488 oldctxt->nbentities += ctxt->nbentities;
13493 if (ctxt->lastError.code != XML_ERR_OK)
13494 xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
13496 ctxt->sax = oldsax;
13497 ctxt->dict = NULL;
13498 ctxt->attsDefault = NULL;
13499 ctxt->attsSpecial = NULL;
13500 xmlFreeParserCtxt(ctxt);
13531 xmlParserCtxtPtr ctxt;
13576 ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
13579 ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
13590 if (ctxt == NULL)
13599 if (ctxt->dict != NULL)
13600 xmlDictFree(ctxt->dict);
13601 ctxt->dict = doc->dict;
13608 if (ctxt->encoding != NULL)
13609 xmlFree((xmlChar *) ctxt->encoding);
13610 ctxt->encoding = xmlStrdup((const xmlChar *) doc->encoding);
13614 xmlSwitchToEncoding(ctxt, hdlr);
13620 xmlCtxtUseOptionsInternal(ctxt, options, NULL);
13621 xmlDetectSAX2(ctxt);
13622 ctxt->myDoc = doc;
13624 ctxt->input_id = 2;
13625 ctxt->instate = XML_PARSER_CONTENT;
13629 xmlFreeParserCtxt(ctxt);
13635 nodePush(ctxt, node);
13645 if (ctxt->dict) {
13646 iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
13647 ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
13653 if (xmlGetNamespace(ctxt, iprefix) == NULL) {
13654 nsPush(ctxt, iprefix, ihref);
13663 if ((ctxt->validate) || (ctxt->replaceEntities != 0)) {
13667 ctxt->loadsubset |= XML_SKIP_IDS;
13672 __htmlParseContent(ctxt);
13675 xmlParseContent(ctxt);
13677 nsPop(ctxt, nsnr);
13679 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13681 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13683 if ((ctxt->node != NULL) && (ctxt->node != node)) {
13684 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13685 ctxt->wellFormed = 0;
13688 if (!ctxt->wellFormed) {
13689 if (ctxt->errNo == 0)
13692 ret = (xmlParserErrors)ctxt->errNo;
13727 ctxt->dict = NULL;
13728 xmlFreeParserCtxt(ctxt);
13766 xmlParserCtxtPtr ctxt;
13785 ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
13786 if (ctxt == NULL) return(-1);
13787 ctxt->userData = ctxt;
13789 oldsax = ctxt->sax;
13790 ctxt->sax = sax;
13792 ctxt->userData = user_data;
13796 xmlFreeParserCtxt(ctxt);
13801 xmlDictFree(ctxt->dict);
13802 ctxt->dict = doc->dict;
13803 xmlDictReference(ctxt->dict);
13804 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
13805 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
13806 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
13807 ctxt->dictNames = 1;
13809 xmlCtxtUseOptionsInternal(ctxt, XML_PARSE_NODICT, NULL);
13818 ctxt->sax = oldsax;
13819 xmlFreeParserCtxt(ctxt);
13826 nodePush(ctxt, newRoot);
13828 ctxt->myDoc = newDoc;
13830 ctxt->myDoc = newDoc;
13836 ctxt->instate = XML_PARSER_CONTENT;
13837 ctxt->input_id = 2;
13838 ctxt->depth = depth;
13843 ctxt->validate = 0;
13844 ctxt->loadsubset = 0;
13845 xmlDetectSAX2(ctxt);
13850 xmlParseContent(ctxt);
13854 xmlParseContent(ctxt);
13857 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13859 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13861 if (ctxt->node != newDoc->children) {
13862 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13865 if (!ctxt->wellFormed) {
13866 if (ctxt->errNo == 0)
13869 ret = ctxt->errNo;
13892 ctxt->sax = oldsax;
13893 xmlFreeParserCtxt(ctxt);
13921 xmlParserCtxtPtr ctxt;
13923 ctxt = xmlCreateFileParserCtxt(filename);
13924 if (ctxt == NULL) {
13928 if (ctxt->sax != NULL)
13929 xmlFree(ctxt->sax);
13930 ctxt->sax = sax;
13931 ctxt->userData = NULL;
13934 xmlParseExtParsedEnt(ctxt);
13936 if (ctxt->wellFormed)
13937 ret = ctxt->myDoc;
13940 xmlFreeDoc(ctxt->myDoc);
13941 ctxt->myDoc = NULL;
13944 ctxt->sax = NULL;
13945 xmlFreeParserCtxt(ctxt);
13985 xmlParserCtxtPtr ctxt;
13990 ctxt = xmlNewParserCtxt();
13991 if (ctxt == NULL) {
13996 ctxt->options = pctx->options;
13997 ctxt->_private = pctx->_private;
14002 ctxt->input_id = pctx->input_id + 1;
14008 inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
14010 xmlFreeParserCtxt(ctxt);
14014 inputPush(ctxt, inputStream);
14016 if ((ctxt->directory == NULL) && (directory == NULL))
14018 if ((ctxt->directory == NULL) && (directory != NULL))
14019 ctxt->directory = directory;
14021 inputStream = xmlLoadExternalEntity((char *)uri, (char *)ID, ctxt);
14024 xmlFreeParserCtxt(ctxt);
14028 inputPush(ctxt, inputStream);
14030 if ((ctxt->directory == NULL) && (directory == NULL))
14032 if ((ctxt->directory == NULL) && (directory != NULL))
14033 ctxt->directory = directory;
14036 return(ctxt);
14078 xmlParserCtxtPtr ctxt;
14082 ctxt = xmlNewParserCtxt();
14083 if (ctxt == NULL) {
14089 xmlCtxtUseOptionsInternal(ctxt, options, NULL);
14090 ctxt->linenumbers = 1;
14092 inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
14094 xmlFreeParserCtxt(ctxt);
14098 inputPush(ctxt, inputStream);
14099 if ((ctxt->directory == NULL) && (directory == NULL))
14101 if ((ctxt->directory == NULL) && (directory != NULL))
14102 ctxt->directory = directory;
14104 return(ctxt);
14147 xmlParserCtxtPtr ctxt;
14151 ctxt = xmlCreateFileParserCtxt(filename);
14152 if (ctxt == NULL) {
14156 if (ctxt->sax != NULL)
14157 xmlFree(ctxt->sax);
14158 ctxt->sax = sax;
14160 xmlDetectSAX2(ctxt);
14162 ctxt->_private = data;
14165 if (ctxt->directory == NULL)
14166 ctxt->directory = xmlParserGetDirectory(filename);
14168 ctxt->recovery = recovery;
14170 xmlParseDocument(ctxt);
14172 if ((ctxt->wellFormed) || recovery) {
14173 ret = ctxt->myDoc;
14175 if (ctxt->input->buf->compressed > 0)
14178 ret->compression = ctxt->input->buf->compressed;
14183 xmlFreeDoc(ctxt->myDoc);
14184 ctxt->myDoc = NULL;
14187 ctxt->sax = NULL;
14188 xmlFreeParserCtxt(ctxt);
14266 * @ctxt: an XML parser context
14275 xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
14280 if ((ctxt == NULL) || (buffer == NULL))
14283 input = xmlNewInputStream(ctxt);
14286 xmlClearParserCtxt(ctxt);
14290 xmlClearParserCtxt(ctxt);
14296 inputPush(ctxt, input);
14314 xmlParserCtxtPtr ctxt;
14316 ctxt = xmlCreateFileParserCtxt(filename);
14317 if (ctxt == NULL) return -1;
14318 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
14319 xmlFree(ctxt->sax);
14320 ctxt->sax = sax;
14321 xmlDetectSAX2(ctxt);
14324 ctxt->userData = user_data;
14326 xmlParseDocument(ctxt);
14328 if (ctxt->wellFormed)
14331 if (ctxt->errNo != 0)
14332 ret = ctxt->errNo;
14337 ctxt->sax = NULL;
14338 if (ctxt->myDoc != NULL) {
14339 xmlFreeDoc(ctxt->myDoc);
14340 ctxt->myDoc = NULL;
14342 xmlFreeParserCtxt(ctxt);
14365 xmlParserCtxtPtr ctxt;
14374 ctxt = xmlNewParserCtxt();
14375 if (ctxt == NULL)
14381 xmlFreeParserCtxt(ctxt);
14385 input = xmlNewInputStream(ctxt);
14388 xmlFreeParserCtxt(ctxt);
14396 inputPush(ctxt, input);
14397 return(ctxt);
14424 xmlParserCtxtPtr ctxt;
14428 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
14429 if (ctxt == NULL) return(NULL);
14431 if (ctxt->sax != NULL)
14432 xmlFree(ctxt->sax);
14433 ctxt->sax = sax;
14435 xmlDetectSAX2(ctxt);
14437 ctxt->_private=data;
14440 ctxt->recovery = recovery;
14442 xmlParseDocument(ctxt);
14444 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
14447 xmlFreeDoc(ctxt->myDoc);
14448 ctxt->myDoc = NULL;
14451 ctxt->sax = NULL;
14452 xmlFreeParserCtxt(ctxt);
14522 xmlParserCtxtPtr ctxt;
14526 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
14527 if (ctxt == NULL) return -1;
14528 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
14529 xmlFree(ctxt->sax);
14530 ctxt->sax = sax;
14531 xmlDetectSAX2(ctxt);
14534 ctxt->userData = user_data;
14536 xmlParseDocument(ctxt);
14538 if (ctxt->wellFormed)
14541 if (ctxt->errNo != 0)
14542 ret = ctxt->errNo;
14547 ctxt->sax = NULL;
14548 if (ctxt->myDoc != NULL) {
14549 xmlFreeDoc(ctxt->myDoc);
14550 ctxt->myDoc = NULL;
14552 xmlFreeParserCtxt(ctxt);
14594 xmlParserCtxtPtr ctxt;
14600 ctxt = xmlCreateDocParserCtxt(cur);
14601 if (ctxt == NULL) return(NULL);
14603 oldsax = ctxt->sax;
14604 ctxt->sax = sax;
14605 ctxt->userData = NULL;
14607 xmlDetectSAX2(ctxt);
14609 xmlParseDocument(ctxt);
14610 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
14613 xmlFreeDoc(ctxt->myDoc);
14614 ctxt->myDoc = NULL;
14617 ctxt->sax = oldsax;
14618 xmlFreeParserCtxt(ctxt);
14803 * @ctxt: an XML parser context
14808 xmlCtxtReset(xmlParserCtxtPtr ctxt)
14813 if (ctxt == NULL)
14816 dict = ctxt->dict;
14818 while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
14821 ctxt->inputNr = 0;
14822 ctxt->input = NULL;
14824 ctxt->spaceNr = 0;
14825 if (ctxt->spaceTab != NULL) {
14826 ctxt->spaceTab[0] = -1;
14827 ctxt->space = &ctxt->spaceTab[0];
14829 ctxt->space = NULL;
14833 ctxt->nodeNr = 0;
14834 ctxt->node = NULL;
14836 ctxt->nameNr = 0;
14837 ctxt->name = NULL;
14839 DICT_FREE(ctxt->version);
14840 ctxt->version = NULL;
14841 DICT_FREE(ctxt->encoding);
14842 ctxt->encoding = NULL;
14843 DICT_FREE(ctxt->directory);
14844 ctxt->directory = NULL;
14845 DICT_FREE(ctxt->extSubURI);
14846 ctxt->extSubURI = NULL;
14847 DICT_FREE(ctxt->extSubSystem);
14848 ctxt->extSubSystem = NULL;
14849 if (ctxt->myDoc != NULL)
14850 xmlFreeDoc(ctxt->myDoc);
14851 ctxt->myDoc = NULL;
14853 ctxt->standalone = -1;
14854 ctxt->hasExternalSubset = 0;
14855 ctxt->hasPErefs = 0;
14856 ctxt->html = 0;
14857 ctxt->external = 0;
14858 ctxt->instate = XML_PARSER_START;
14859 ctxt->token = 0;
14861 ctxt->wellFormed = 1;
14862 ctxt->nsWellFormed = 1;
14863 ctxt->disableSAX = 0;
14864 ctxt->valid = 1;
14866 ctxt->vctxt.userData = ctxt;
14867 ctxt->vctxt.error = xmlParserValidityError;
14868 ctxt->vctxt.warning = xmlParserValidityWarning;
14870 ctxt->record_info = 0;
14871 ctxt->nbChars = 0;
14872 ctxt->checkIndex = 0;
14873 ctxt->inSubset = 0;
14874 ctxt->errNo = XML_ERR_OK;
14875 ctxt->depth = 0;
14876 ctxt->charset = XML_CHAR_ENCODING_UTF8;
14877 ctxt->catalogs = NULL;
14878 ctxt->nbentities = 0;
14879 ctxt->sizeentities = 0;
14880 ctxt->sizeentcopy = 0;
14881 xmlInitNodeInfoSeq(&ctxt->node_seq);
14883 if (ctxt->attsDefault != NULL) {
14884 xmlHashFree(ctxt->attsDefault, xmlHashDefaultDeallocator);
14885 ctxt->attsDefault = NULL;
14887 if (ctxt->attsSpecial != NULL) {
14888 xmlHashFree(ctxt->attsSpecial, NULL);
14889 ctxt->attsSpecial = NULL;
14893 if (ctxt->catalogs != NULL)
14894 xmlCatalogFreeLocal(ctxt->catalogs);
14896 if (ctxt->lastError.code != XML_ERR_OK)
14897 xmlResetError(&ctxt->lastError);
14902 * @ctxt: an XML parser context
14913 xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
14920 if (ctxt == NULL)
14930 if (ctxt == NULL) {
14935 xmlCtxtReset(ctxt);
14937 if (ctxt->pushTab == NULL) {
14938 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 *
14940 if (ctxt->pushTab == NULL) {
14941 xmlErrMemory(ctxt, NULL);
14948 ctxt->directory = NULL;
14950 ctxt->directory = xmlParserGetDirectory(filename);
14953 inputStream = xmlNewInputStream(ctxt);
14967 inputPush(ctxt, inputStream);
14969 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
14970 (ctxt->input->buf != NULL)) {
14971 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
14972 size_t cur = ctxt->input->cur - ctxt->input->base;
14974 xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
14976 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
14985 if (ctxt->encoding != NULL)
14986 xmlFree((xmlChar *) ctxt->encoding);
14987 ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
14991 xmlSwitchToEncoding(ctxt, hdlr);
14993 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
14997 xmlSwitchEncoding(ctxt, enc);
15006 * @ctxt: an XML parser context
15016 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, const char *encoding)
15018 if (ctxt == NULL)
15021 if (ctxt->encoding != NULL)
15022 xmlFree((xmlChar *) ctxt->encoding);
15023 ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
15026 ctxt->recovery = 1;
15028 ctxt->options |= XML_PARSE_RECOVER;
15030 ctxt->recovery = 0;
15032 ctxt->loadsubset = XML_DETECT_IDS;
15034 ctxt->options |= XML_PARSE_DTDLOAD;
15036 ctxt->loadsubset = 0;
15038 ctxt->loadsubset |= XML_COMPLETE_ATTRS;
15040 ctxt->options |= XML_PARSE_DTDATTR;
15043 ctxt->replaceEntities = 1;
15044 /* ctxt->loadsubset |= XML_DETECT_IDS; */
15046 ctxt->options |= XML_PARSE_NOENT;
15048 ctxt->replaceEntities = 0;
15050 ctxt->pedantic = 1;
15052 ctxt->options |= XML_PARSE_PEDANTIC;
15054 ctxt->pedantic = 0;
15056 ctxt->keepBlanks = 0;
15057 ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
15059 ctxt->options |= XML_PARSE_NOBLANKS;
15061 ctxt->keepBlanks = 1;
15063 ctxt->validate = 1;
15065 ctxt->vctxt.warning = NULL;
15067 ctxt->vctxt.error = NULL;
15069 ctxt->options |= XML_PARSE_DTDVALID;
15071 ctxt->validate = 0;
15073 ctxt->sax->warning = NULL;
15077 ctxt->sax->error = NULL;
15078 ctxt->sax->fatalError = NULL;
15083 ctxt->sax->startElement = xmlSAX2StartElement;
15084 ctxt->sax->endElement = xmlSAX2EndElement;
15085 ctxt->sax->startElementNs = NULL;
15086 ctxt->sax->endElementNs = NULL;
15087 ctxt->sax->initialized = 1;
15089 ctxt->options |= XML_PARSE_SAX1;
15093 ctxt->dictNames = 0;
15095 ctxt->options |= XML_PARSE_NODICT;
15097 ctxt->dictNames = 1;
15100 ctxt->sax->cdataBlock = NULL;
15102 ctxt->options |= XML_PARSE_NOCDATA;
15105 ctxt->options |= XML_PARSE_NSCLEAN;
15109 ctxt->options |= XML_PARSE_NONET;
15113 ctxt->options |= XML_PARSE_COMPACT;
15117 ctxt->options |= XML_PARSE_OLD10;
15121 ctxt
15125 ctxt->options |= XML_PARSE_HUGE;
15127 if (ctxt->dict != NULL)
15128 xmlDictSetLimit(ctxt->dict, 0);
15131 ctxt->options |= XML_PARSE_OLDSAX;
15135 ctxt->options |= XML_PARSE_IGNORE_ENC;
15139 ctxt->options |= XML_PARSE_BIG_LINES;
15142 ctxt->linenumbers = 1;
15148 * @ctxt: an XML parser context
15157 xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
15159 return(xmlCtxtUseOptionsInternal(ctxt, options, NULL));
15164 * @ctxt: an XML parser context
15175 xmlDoRead(xmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
15180 xmlCtxtUseOptionsInternal(ctxt, options, encoding);
15186 xmlSwitchToEncoding(ctxt, hdlr);
15188 if ((URL != NULL) && (ctxt->input != NULL) &&
15189 (ctxt->input->filename == NULL))
15190 ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
15191 xmlParseDocument(ctxt);
15192 if ((ctxt->wellFormed) || ctxt->recovery)
15193 ret = ctxt->myDoc;
15196 if (ctxt->myDoc != NULL) {
15197 xmlFreeDoc(ctxt->myDoc);
15200 ctxt->myDoc = NULL;
15202 xmlFreeParserCtxt(ctxt);
15222 xmlParserCtxtPtr ctxt;
15228 ctxt = xmlCreateDocParserCtxt(cur);
15229 if (ctxt == NULL)
15231 return (xmlDoRead(ctxt, URL, encoding, options, 0));
15247 xmlParserCtxtPtr ctxt;
15250 ctxt = xmlCreateURLParserCtxt(filename, options);
15251 if (ctxt == NULL)
15253 return (xmlDoRead(ctxt, NULL, encoding, options, 0));
15271 xmlParserCtxtPtr ctxt;
15274 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
15275 if (ctxt == NULL)
15277 return (xmlDoRead(ctxt, URL, encoding, options, 0));
15296 xmlParserCtxtPtr ctxt;
15308 ctxt = xmlNewParserCtxt();
15309 if (ctxt == NULL) {
15313 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15316 xmlFreeParserCtxt(ctxt);
15319 inputPush(ctxt, stream);
15320 return (xmlDoRead(ctxt, URL, encoding, options, 0));
15340 xmlParserCtxtPtr ctxt;
15355 ctxt = xmlNewParserCtxt();
15356 if (ctxt == NULL) {
15360 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15363 xmlFreeParserCtxt(ctxt);
15366 inputPush(ctxt, stream);
15367 return (xmlDoRead(ctxt, URL, encoding, options, 0));
15372 * @ctxt: an XML parser context
15379 * This reuses the existing @ctxt parser context
15384 xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
15391 if (ctxt == NULL)
15395 xmlCtxtReset(ctxt);
15397 stream = xmlNewStringInputStream(ctxt, cur);
15401 inputPush(ctxt, stream);
15402 return (xmlDoRead(ctxt, URL, encoding, options, 1));
15407 * @ctxt: an XML parser context
15413 * This reuses the existing @ctxt parser context
15418 xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
15425 if (ctxt == NULL)
15429 xmlCtxtReset(ctxt);
15431 stream = xmlLoadExternalEntity(filename, NULL, ctxt);
15435 inputPush(ctxt, stream);
15436 return (xmlDoRead(ctxt, NULL, encoding, options, 1));
15441 * @ctxt: an XML parser context
15449 * This reuses the existing @ctxt parser context
15454 xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
15460 if (ctxt == NULL)
15466 xmlCtxtReset(ctxt);
15473 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15479 inputPush(ctxt, stream);
15480 return (xmlDoRead(ctxt, URL, encoding, options, 1));
15485 * @ctxt: an XML parser context
15492 * This reuses the existing @ctxt parser context
15499 xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
15507 if (ctxt == NULL)
15511 xmlCtxtReset(ctxt);
15518 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15523 inputPush(ctxt, stream);
15524 return (xmlDoRead(ctxt, URL, encoding, options, 1));
15529 * @ctxt: an XML parser context
15538 * This reuses the existing @ctxt parser context
15543 xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
15553 if (ctxt == NULL)
15557 xmlCtxtReset(ctxt);
15566 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15571 inputPush(ctxt, stream);
15572 return (xmlDoRead(ctxt, URL, encoding, options, 1));
