Lines Matching refs:ctxt
87 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info);
120 xmlParserEntityCheck(xmlParserCtxtPtr ctxt, unsigned long size,
125 if ((ctxt == NULL) || (ctxt->options & XML_PARSE_HUGE))
127 if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
139 if (ctxt->input != NULL) {
140 consumed = ctxt->input->consumed +
141 (ctxt->input->cur - ctxt->input->base);
143 consumed += ctxt->sizeentities;
146 (ctxt->nbentities * 3 < XML_PARSER_NON_LINEAR * consumed))
157 if (ctxt->input != NULL) {
158 consumed = ctxt->input->consumed +
159 (ctxt->input->cur - ctxt->input->base);
161 consumed += ctxt->sizeentities;
176 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
208 /* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
209 static xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
219 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options,
232 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity);
242 * @ctxt: an XML parser context
249 xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
252 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
253 (ctxt->instate == XML_PARSER_EOF))
255 if (ctxt != NULL)
256 ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
259 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
264 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
269 if (ctxt != NULL) {
270 ctxt->wellFormed = 0;
271 if (ctxt->recovery == 0)
272 ctxt->disableSAX = 1;
278 * @ctxt: an XML parser context
285 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)
289 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
290 (ctxt->instate == XML_PARSER_EOF))
471 if (ctxt != NULL)
472 ctxt->errNo = error;
473 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
476 if (ctxt != NULL) {
477 ctxt->wellFormed = 0;
478 if (ctxt->recovery == 0)
479 ctxt->disableSAX = 1;
485 * @ctxt: an XML parser context
492 xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
495 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
496 (ctxt->instate == XML_PARSER_EOF))
498 if (ctxt != NULL)
499 ctxt->errNo = error;
500 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
502 if (ctxt != NULL) {
503 ctxt->wellFormed = 0;
504 if (ctxt->recovery == 0)
505 ctxt->disableSAX = 1;
511 * @ctxt: an XML parser context
520 xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
525 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
526 (ctxt->instate == XML_PARSER_EOF))
528 if ((ctxt != NULL) && (ctxt->sax != NULL) &&
529 (ctxt->sax->initialized == XML_SAX2_MAGIC))
530 schannel = ctxt->sax->serror;
531 if (ctxt != NULL) {
533 (ctxt->sax) ? ctxt->sax->warning : NULL,
534 ctxt->userData,
535 ctxt, NULL, XML_FROM_PARSER, error,
541 ctxt, NULL, XML_FROM_PARSER, error,
550 * @ctxt: an XML parser context
558 xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
563 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
564 (ctxt->instate == XML_PARSER_EOF))
566 if (ctxt != NULL) {
567 ctxt->errNo = error;
568 if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
569 schannel = ctxt->sax->serror;
571 if (ctxt != NULL) {
573 ctxt->vctxt.error, ctxt->vctxt.userData,
574 ctxt, NULL, XML_FROM_DTD, error,
578 ctxt->valid = 0;
581 ctxt, NULL, XML_FROM_DTD, error,
590 * @ctxt: an XML parser context
598 xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
601 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
602 (ctxt->instate == XML_PARSER_EOF))
604 if (ctxt != NULL)
605 ctxt->errNo = error;
607 ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
609 if (ctxt != NULL) {
610 ctxt->wellFormed = 0;
611 if (ctxt->recovery == 0)
612 ctxt->disableSAX = 1;
618 * @ctxt: an XML parser context
628 xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
632 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
633 (ctxt->instate == XML_PARSER_EOF))
635 if (ctxt != NULL)
636 ctxt->errNo = error;
638 ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
641 if (ctxt != NULL) {
642 ctxt->wellFormed = 0;
643 if (ctxt->recovery == 0)
644 ctxt->disableSAX = 1;
650 * @ctxt: an XML parser context
658 xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
661 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
662 (ctxt->instate == XML_PARSER_EOF))
664 if (ctxt != NULL)
665 ctxt->errNo = error;
666 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
670 if (ctxt != NULL) {
671 ctxt->wellFormed = 0;
672 if (ctxt->recovery == 0)
673 ctxt->disableSAX = 1;
679 * @ctxt: an XML parser context
687 xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
690 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
691 (ctxt->instate == XML_PARSER_EOF))
693 if (ctxt != NULL)
694 ctxt->errNo = error;
695 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
703 * @ctxt: an XML parser context
712 xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
717 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
718 (ctxt->instate == XML_PARSER_EOF))
720 if (ctxt != NULL)
721 ctxt->errNo = error;
722 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
726 if (ctxt != NULL)
727 ctxt->nsWellFormed = 0;
732 * @ctxt: an XML parser context
741 xmlNsWarn(xmlParserCtxtPtr ctxt, xmlParserErrors error,
746 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
747 (ctxt->instate == XML_PARSER_EOF))
749 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
987 * @ctxt: an XML parser context
992 xmlDetectSAX2(xmlParserCtxtPtr ctxt) {
993 if (ctxt == NULL) return;
995 if ((ctxt->sax) && (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
996 ((ctxt->sax->startElementNs != NULL) ||
997 (ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1;
999 ctxt->sax2 = 1;
1002 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
1003 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
1004 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
1005 if ((ctxt->str_xml==NULL) || (ctxt->str_xmlns==NULL) ||
1006 (ctxt->str_xml_ns == NULL)) {
1007 xmlErrMemory(ctxt, NULL);
1070 xmlAttrNormalizeSpace2(xmlParserCtxtPtr ctxt, xmlChar *src, int *len)
1077 if ((ctxt == NULL) || (src == NULL) || (len == NULL))
1103 xmlErrMemory(ctxt, NULL);
1119 * @ctxt: an XML parser context
1127 xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
1139 if (ctxt->attsSpecial != NULL) {
1140 if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1144 if (ctxt->attsDefault == NULL) {
1145 ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
1146 if (ctxt->attsDefault == NULL)
1156 name = xmlDictLookup(ctxt->dict, fullname, -1);
1159 name = xmlDictLookup(ctxt->dict, name, -1);
1160 prefix = xmlDictLookup(ctxt->dict, fullname, len);
1166 defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
1174 if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1188 if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1201 name = xmlDictLookup(ctxt->dict, fullattr, -1);
1204 name = xmlDictLookup(ctxt->dict, name, -1);
1205 prefix = xmlDictLookup(ctxt->dict, fullattr, len);
1212 value = xmlDictLookup(ctxt->dict, value, len);
1215 if (ctxt->external)
1224 xmlErrMemory(ctxt, NULL);
1230 * @ctxt: an XML parser context
1238 xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
1243 if (ctxt->attsSpecial == NULL) {
1244 ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
1245 if (ctxt->attsSpecial == NULL)
1249 if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1252 xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
1257 xmlErrMemory(ctxt, NULL);
1270 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data;
1273 xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL);
1279 * @ctxt: an XML parser context
1286 xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt)
1288 if (ctxt->attsSpecial == NULL)
1291 xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt);
1293 if (xmlHashSize(ctxt->attsSpecial) == 0) {
1294 xmlHashFree(ctxt->attsSpecial, NULL);
1295 ctxt->attsSpecial = NULL;
1500 static xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
1506 * @ctxt: an XML parser context
1516 nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL)
1518 if (ctxt->options & XML_PARSE_NSCLEAN) {
1520 for (i = 0;i < ctxt->nsNr;i += 2) {
1521 if (ctxt->nsTab[i] == prefix) {
1523 if (ctxt->nsTab[i + 1] == URL)
1530 if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) {
1531 ctxt->nsMax = 10;
1532 ctxt->nsNr = 0;
1533 ctxt->nsTab = (const xmlChar **)
1534 xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
1535 if (ctxt->nsTab == NULL) {
1536 xmlErrMemory(ctxt, NULL);
1537 ctxt->nsMax = 0;
1540 } else if (ctxt->nsNr >= ctxt->nsMax) {
1542 ctxt->nsMax *= 2;
1543 tmp = (const xmlChar **) xmlRealloc((char *) ctxt->nsTab,
1544 ctxt->nsMax * sizeof(ctxt->nsTab[0]));
1546 xmlErrMemory(ctxt, NULL);
1547 ctxt->nsMax /= 2;
1550 ctxt->nsTab = tmp;
1552 ctxt->nsTab[ctxt->nsNr++] = prefix;
1553 ctxt->nsTab[ctxt->nsNr++] = URL;
1554 return (ctxt->nsNr);
1558 * @ctxt: an XML parser context
1566 nsPop(xmlParserCtxtPtr ctxt, int nr)
1570 if (ctxt->nsTab == NULL) return(0);
1571 if (ctxt->nsNr < nr) {
1573 nr = ctxt->nsNr;
1575 if (ctxt->nsNr <= 0)
1579 ctxt->nsNr--;
1580 ctxt->nsTab[ctxt->nsNr] = NULL;
1587 xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
1592 if (ctxt->atts == NULL) {
1597 ctxt->atts = atts;
1600 ctxt->attallocs = attallocs;
1601 ctxt->maxatts = maxatts;
1602 } else if (nr + 5 > ctxt->maxatts) {
1604 atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts,
1607 ctxt->atts = atts;
1608 attallocs = (int *) xmlRealloc((void *) ctxt->attallocs,
1611 ctxt->attallocs = attallocs;
1612 ctxt->maxatts = maxatts;
1614 return(ctxt->maxatts);
1616 xmlErrMemory(ctxt, NULL);
1622 * @ctxt: an XML parser context
1630 inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
1632 if ((ctxt == NULL) || (value == NULL))
1634 if (ctxt->inputNr >= ctxt->inputMax) {
1635 ctxt->inputMax *= 2;
1636 ctxt->inputTab =
1637 (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
1638 ctxt->inputMax *
1639 sizeof(ctxt->inputTab[0]));
1640 if (ctxt->inputTab == NULL) {
1641 xmlErrMemory(ctxt, NULL);
1643 ctxt->inputMax /= 2;
1648 ctxt->inputTab[ctxt->inputNr] = value;
1649 ctxt->input = value;
1650 return (ctxt->inputNr++);
1654 * @ctxt: an XML parser context
1661 inputPop(xmlParserCtxtPtr ctxt)
1665 if (ctxt == NULL)
1667 if (ctxt->inputNr <= 0)
1669 ctxt->inputNr--;
1670 if (ctxt->inputNr > 0)
1671 ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
1673 ctxt->input = NULL;
1674 ret = ctxt->inputTab[ctxt->inputNr];
1675 ctxt->inputTab[ctxt->inputNr] = NULL;
1680 * @ctxt: an XML parser context
1688 nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
1690 if (ctxt == NULL) return(0);
1691 if (ctxt->nodeNr >= ctxt->nodeMax) {
1694 tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
1695 ctxt->nodeMax * 2 *
1696 sizeof(ctxt->nodeTab[0]));
1698 xmlErrMemory(ctxt, NULL);
1701 ctxt->nodeTab = tmp;
1702 ctxt->nodeMax *= 2;
1704 if ((((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) &&
1705 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
1706 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
1709 ctxt->instate = XML_PARSER_EOF;
1712 ctxt->nodeTab[ctxt->nodeNr] = value;
1713 ctxt->node = value;
1714 return (ctxt->nodeNr++);
1719 * @ctxt
1726 nodePop(xmlParserCtxtPtr ctxt)
1730 if (ctxt == NULL) return(NULL);
1731 if (ctxt->nodeNr <= 0)
1733 ctxt->nodeNr--;
1734 if (ctxt->nodeNr > 0)
1735 ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
1737 ctxt->node = NULL;
1738 ret = ctxt->nodeTab[ctxt->nodeNr];
1739 ctxt->nodeTab[ctxt->nodeNr] = NULL;
1746 * @ctxt: an XML parser context
1756 nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
1759 if (ctxt->nameNr >= ctxt->nameMax) {
1762 ctxt->nameMax *= 2;
1763 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1764 ctxt->nameMax *
1765 sizeof(ctxt->nameTab[0]));
1767 ctxt->nameMax /= 2;
1770 ctxt->nameTab = tmp;
1771 tmp2 = (void **) xmlRealloc((void * *)ctxt->pushTab,
1772 ctxt->nameMax * 3 *
1773 sizeof(ctxt->pushTab[0]));
1775 ctxt->nameMax /= 2;
1778 ctxt->pushTab = tmp2;
1780 ctxt->nameTab[ctxt->nameNr] = value;
1781 ctxt->name = value;
1782 ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix;
1783 ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI;
1784 ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr;
1785 return (ctxt->nameNr++);
1787 xmlErrMemory(ctxt, NULL);
1792 * @ctxt: an XML parser context
1799 nameNsPop(xmlParserCtxtPtr ctxt)
1803 if (ctxt->nameNr <= 0)
1805 ctxt->nameNr--;
1806 if (ctxt->nameNr > 0)
1807 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1809 ctxt->name = NULL;
1810 ret = ctxt->nameTab[ctxt->nameNr];
1811 ctxt->nameTab[ctxt->nameNr] = NULL;
1818 * @ctxt: an XML parser context
1826 namePush(xmlParserCtxtPtr ctxt, const xmlChar * value)
1828 if (ctxt == NULL) return (-1);
1830 if (ctxt->nameNr >= ctxt->nameMax) {
1832 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1833 ctxt->nameMax * 2 *
1834 sizeof(ctxt->nameTab[0]));
1838 ctxt->nameTab = tmp;
1839 ctxt->nameMax *= 2;
1841 ctxt->nameTab[ctxt->nameNr] = value;
1842 ctxt->name = value;
1843 return (ctxt->nameNr++);
1845 xmlErrMemory(ctxt, NULL);
1850 * @ctxt: an XML parser context
1857 namePop(xmlParserCtxtPtr ctxt)
1861 if ((ctxt == NULL) || (ctxt->nameNr <= 0))
1863 ctxt->nameNr--;
1864 if (ctxt->nameNr > 0)
1865 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1867 ctxt->name = NULL;
1868 ret = ctxt->nameTab[ctxt->nameNr];
1869 ctxt->nameTab[ctxt->nameNr] = NULL;
1873 static int spacePush(xmlParserCtxtPtr ctxt, int val) {
1874 if (ctxt->spaceNr >= ctxt->spaceMax) {
1877 ctxt->spaceMax *= 2;
1878 tmp = (int *) xmlRealloc(ctxt->spaceTab,
1879 ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
1881 xmlErrMemory(ctxt, NULL);
1882 ctxt->spaceMax /=2;
1885 ctxt->spaceTab = tmp;
1887 ctxt->spaceTab[ctxt->spaceNr] = val;
1888 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
1889 return(ctxt->spaceNr++);
1892 static int spacePop(xmlParserCtxtPtr ctxt) {
1894 if (ctxt->spaceNr <= 0) return(0);
1895 ctxt->spaceNr--;
1896 if (ctxt->spaceNr > 0)
1897 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
1899 ctxt->space = &ctxt->spaceTab[0];
1900 ret = ctxt->spaceTab[ctxt->spaceNr];
1901 ctxt->spaceTab[ctxt->spaceNr] = -1;
1940 #define RAW (*ctxt->input->cur)
1941 #define CUR (*ctxt->input->cur)
1942 #define NXT(val) ctxt->input->cur[(val)]
1943 #define CUR_PTR ctxt->input->cur
1964 ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val); \
1965 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1966 if ((*ctxt->input->cur == 0) && \
1967 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
1968 xmlPopInput(ctxt); \
1974 if (*(ctxt->input->cur) == '\n') { \
1975 ctxt->input->line++; ctxt->input->col = 1; \
1976 } else ctxt->input->col++; \
1977 ctxt->nbChars++; \
1978 ctxt->input->cur++; \
1980 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1981 if ((*ctxt->input->cur == 0) && \
1982 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
1983 xmlPopInput(ctxt); \
1986 #define SHRINK if ((ctxt->progressive == 0) && \
1987 (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
1988 (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
1989 xmlSHRINK (ctxt);
1991 static void xmlSHRINK (xmlParserCtxtPtr ctxt) {
1992 xmlParserInputShrink(ctxt->input);
1993 if ((*ctxt->input->cur == 0) &&
1994 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1995 xmlPopInput(ctxt);
1998 #define GROW if ((ctxt->progressive == 0) && \
1999 (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \
2000 xmlGROW (ctxt);
2002 static void xmlGROW (xmlParserCtxtPtr ctxt) {
2003 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2004 if ((ctxt->input->cur != NULL) && (*ctxt->input->cur == 0) &&
2005 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2006 xmlPopInput(ctxt);
2009 #define SKIP_BLANKS xmlSkipBlankChars(ctxt)
2011 #define NEXT xmlNextChar(ctxt)
2014 ctxt->input->col++; \
2015 ctxt->input->cur++; \
2016 ctxt->nbChars++; \
2017 if (*ctxt->input->cur == 0) \
2018 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); \
2022 if (*(ctxt->input->cur) == '\n') { \
2023 ctxt->input->line++; ctxt->input->col = 1; \
2024 } else ctxt->input->col++; \
2025 ctxt->input->cur += l; \
2026 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
2029 #define CUR_CHAR(l) xmlCurrentChar(ctxt, &l)
2030 #define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
2038 * @ctxt: the XML parser context
2047 xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
2054 if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) {
2059 cur = ctxt->input->cur;
2062 ctxt->input->line++; ctxt->input->col = 1;
2067 ctxt->input->cur = cur;
2068 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2069 cur = ctxt->input->cur;
2072 ctxt->input->cur = cur;
2082 while ((cur == 0) && (ctxt->inputNr > 1) &&
2083 (ctxt->instate != XML_PARSER_COMMENT)) {
2084 xmlPopInput(ctxt);
2090 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);
2104 * @ctxt: an XML parser context
2106 * xmlPopInput: the current input pointed by ctxt->input came to an end
2112 xmlPopInput(xmlParserCtxtPtr ctxt) {
2113 if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0);
2116 "Popping input %d\n", ctxt->inputNr);
2117 xmlFreeInputStream(inputPop(ctxt));
2118 if ((*ctxt->input->cur == 0) &&
2119 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2120 return(xmlPopInput(ctxt));
2126 * @ctxt: an XML parser context
2134 xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
2139 if ((ctxt->input != NULL) && (ctxt->input->filename))
2141 "%s(%d): ", ctxt->input->filename,
2142 ctxt->input->line);
2144 "Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
2146 ret = inputPush(ctxt, input);
2153 * @ctxt: an XML parser context
2167 xmlParseCharRef(xmlParserCtxtPtr ctxt) {
2191 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2203 ctxt->input->col++;
2204 ctxt->nbChars ++;
2205 ctxt->input->cur++;
2218 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2230 ctxt->input->col++;
2231 ctxt->nbChars ++;
2232 ctxt->input->cur++;
2235 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2246 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2255 * @ctxt: an XML parser context
2272 xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
2292 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2311 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2324 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2337 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2346 * @ctxt: an XML parser context
2358 xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
2363 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
2370 input = xmlNewInputStream(ctxt);
2377 xmlErrMemory(ctxt, NULL);
2397 * @ctxt: the parser context
2428 xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
2434 switch(ctxt->instate) {
2444 xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
2449 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
2460 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
2479 if ((ctxt->external == 0) && (ctxt->inputNr == 1))
2489 name = xmlParseName(ctxt);
2494 xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL);
2498 if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL))
2499 entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
2510 if ((ctxt->standalone == 1) ||
2511 ((ctxt->hasExternalSubset == 0) &&
2512 (ctxt->hasPErefs == 0))) {
2513 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
2523 if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
2524 xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
2528 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
2531 ctxt->valid = 0;
2533 } else if (ctxt->input->free != deallocblankswrapper) {
2534 input = xmlNewBlanksWrapperInputStream(ctxt, entity);
2535 if (xmlPushInput(ctxt, input) < 0)
2548 input = xmlNewEntityInputStream(ctxt, entity);
2549 if (xmlPushInput(ctxt, input) < 0)
2562 if ((ctxt->input->end - ctxt->input->cur)>=4) {
2569 xmlSwitchEncoding(ctxt, enc);
2576 xmlParseTextDecl(ctxt);
2579 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
2585 xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
2605 * @ctxt: the parser context
2623 xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2635 if ((ctxt == NULL) || (str == NULL) || (len < 0))
2639 if (((ctxt->depth > 40) &&
2640 ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
2641 (ctxt->depth > 1024)) {
2642 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
2666 int val = xmlParseStringCharRef(ctxt, &str);
2678 ent = xmlParseStringEntityRef(ctxt, &str);
2679 if ((ctxt->lastError.code == XML_ERR_ENTITY_LOOP) ||
2680 (ctxt->lastError.code == XML_ERR_INTERNAL_ERROR))
2683 ctxt->nbentities += ent->checked;
2692 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
2696 ctxt->depth++;
2697 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2699 ctxt->depth--;
2707 if (xmlParserEntityCheck(ctxt, nbchars, ent))
2731 ent = xmlParseStringPEReference(ctxt, &str);
2732 if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
2735 ctxt->nbentities += ent->checked;
2738 xmlLoadEntityContent(ctxt, ent);
2740 ctxt->depth++;
2741 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2743 ctxt->depth--;
2750 if (xmlParserEntityCheck(ctxt, nbchars, ent))
2775 xmlErrMemory(ctxt, NULL);
2786 * @ctxt: the parser context
2803 xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
2805 if ((ctxt == NULL) || (str == NULL)) return(NULL);
2806 return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what,
2818 * @ctxt: an XML parser context
2828 static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2837 if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
2843 if ((ctxt->space == NULL) || (*(ctxt->space) == 1) ||
2844 (*(ctxt->space) == -2))
2858 if (ctxt->node == NULL) return(0);
2859 if (ctxt->myDoc != NULL) {
2860 ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
2869 if ((ctxt->node->children == NULL) &&
2872 lastChild = xmlGetLastChild(ctxt->node);
2874 if ((ctxt->node->type != XML_ELEMENT_NODE) &&
2875 (ctxt->node->content != NULL)) return(0);
2878 else if ((ctxt->node->children != NULL) &&
2879 (xmlNodeIsText(ctxt->node->children)))
2893 * @ctxt: an XML parser context
2910 xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix) {
2949 xmlErrMemory(ctxt, NULL);
2962 xmlErrMemory(ctxt, NULL);
3008 xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
3028 xmlErrMemory(ctxt, NULL);
3040 xmlErrMemory(ctxt, NULL);
3094 xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) {
3095 if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3125 xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) {
3126 if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3163 static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
3167 xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
3181 if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3261 if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
3262 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
3263 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
3268 * @ctxt: an XML parser context
3283 xmlParseName(xmlParserCtxtPtr ctxt) {
3297 in = ctxt->input->cur;
3309 count = in - ctxt->input->cur;
3310 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3311 ctxt->input->cur = in;
3312 ctxt->nbChars += count;
3313 ctxt->input->col += count;
3315 xmlErrMemory(ctxt, NULL);
3320 return(xmlParseNameComplex(ctxt));
3324 xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
3339 (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) {
3344 (xmlIsNameChar(ctxt, c) && (c != ':'))) {
3353 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
3358 * @ctxt: an XML parser context
3372 xmlParseNCName(xmlParserCtxtPtr ctxt) {
3384 in = ctxt->input->cur;
3396 count = in - ctxt->input->cur;
3397 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3398 ctxt->input->cur = in;
3399 ctxt->nbChars += count;
3400 ctxt->input->col += count;
3402 xmlErrMemory(ctxt, NULL);
3407 return(xmlParseNCNameComplex(ctxt));
3412 * @ctxt: an XML parser context
3422 xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
3429 in = ctxt->input->cur;
3433 ctxt->input->col++;
3437 ctxt->input->cur = in;
3441 ret = xmlParseName (ctxt);
3451 * @ctxt: an XML parser context
3468 xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
3479 if (!xmlIsNameStartChar(ctxt, c)) {
3486 while (xmlIsNameChar(ctxt, c)) {
3500 xmlErrMemory(ctxt, NULL);
3504 while (xmlIsNameChar(ctxt, c)) {
3511 xmlErrMemory(ctxt, NULL);
3532 * @ctxt: an XML parser context
3544 xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
3557 while (xmlIsNameChar(ctxt, c)) {
3575 xmlErrMemory(ctxt, NULL);
3579 while (xmlIsNameChar(ctxt, c)) {
3591 xmlErrMemory(ctxt, NULL);
3612 * @ctxt: an XML parser context
3624 xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
3637 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
3642 xmlErrMemory(ctxt, NULL);
3650 ctxt->instate = XML_PARSER_ENTITY_VALUE;
3651 input = ctxt->input;
3665 (ctxt->input != input))) {
3672 xmlErrMemory(ctxt, NULL);
3683 while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */
3684 xmlPopInput(ctxt);
3707 name = xmlParseStringName(ctxt, &cur);
3709 xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
3713 if ((tmp == '%') && (ctxt->inSubset == 1) &&
3714 (ctxt->inputNr == 1)) {
3715 xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
3729 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
3739 ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
3752 * @ctxt: an XML parser context
3763 xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) {
3774 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3779 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3782 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
3803 int val = xmlParseCharRef(ctxt);
3806 if (ctxt->replaceEntities) {
3832 ent = xmlParseEntityRef(ctxt);
3833 ctxt->nbentities++;
3835 ctxt->nbentities += ent->owner;
3841 if ((ctxt->replaceEntities == 0) &&
3852 (ctxt->replaceEntities != 0)) {
3854 rep = xmlStringDecodeEntities(ctxt, ent->content,
3890 rep = xmlStringDecodeEntities(ctxt, ent->content,
3938 xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
3941 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
3944 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
3953 xmlErrMemory(ctxt, NULL);
3963 * @ctxt: an XML parser context
3996 xmlParseAttValue(xmlParserCtxtPtr ctxt) {
3997 if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL);
3998 return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
4003 * @ctxt: an XML parser context
4013 xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
4019 int state = ctxt->instate;
4030 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4036 xmlErrMemory(ctxt, NULL);
4039 ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
4049 xmlErrMemory(ctxt, NULL);
4050 ctxt->instate = (xmlParserInputState) state;
4070 ctxt->instate = (xmlParserInputState) state;
4072 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4081 * @ctxt: an XML parser context
4091 xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
4098 xmlParserInputState oldstate = ctxt->instate;
4108 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4113 xmlErrMemory(ctxt, NULL);
4116 ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
4125 xmlErrMemory(ctxt, NULL);
4147 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4151 ctxt->instate = oldstate;
4155 static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
4197 * @ctxt: an XML parser context
4212 xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
4215 int line = ctxt->input->line;
4216 int col = ctxt->input->col;
4226 in = ctxt->input->cur;
4229 while (*in == 0x20) { in++; ctxt->input->col++; }
4232 ctxt->input->line++; ctxt->input->col = 1;
4238 nbchar = in - ctxt->input->cur;
4240 const xmlChar *tmp = ctxt->input->cur;
4241 ctxt->input->cur = in;
4243 if ((ctxt->sax != NULL) &&
4244 (ctxt->sax->ignorableWhitespace !=
4245 ctxt->sax->characters)) {
4246 if (areBlanks(ctxt, tmp, nbchar, 1)) {
4247 if (ctxt->sax->ignorableWhitespace != NULL)
4248 ctxt->sax->ignorableWhitespace(ctxt->userData,
4251 if (ctxt->sax->characters != NULL)
4252 ctxt->sax->characters(ctxt->userData,
4254 if (*ctxt->space == -1)
4255 *ctxt->space = -2;
4257 } else if ((ctxt->sax != NULL) &&
4258 (ctxt->sax->characters != NULL)) {
4259 ctxt->sax->characters(ctxt->userData,
4267 ccol = ctxt->input->col;
4272 ctxt->input->col = ccol;
4275 ctxt->input->line++; ctxt->input->col = 1;
4282 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4283 ctxt->input->cur = in;
4287 ctxt->input->col++;
4290 nbchar = in - ctxt->input->cur;
4292 if ((ctxt->sax != NULL) &&
4293 (ctxt->sax->ignorableWhitespace !=
4294 ctxt->sax->characters) &&
4295 (IS_BLANK_CH(*ctxt->input->cur))) {
4296 const xmlChar *tmp = ctxt->input->cur;
4297 ctxt->input->cur = in;
4299 if (areBlanks(ctxt, tmp, nbchar, 0)) {
4300 if (ctxt->sax->ignorableWhitespace != NULL)
4301 ctxt->sax->ignorableWhitespace(ctxt->userData,
4304 if (ctxt->sax->characters != NULL)
4305 ctxt->sax->characters(ctxt->userData,
4307 if (*ctxt->space == -1)
4308 *ctxt->space = -2;
4310 line = ctxt->input->line;
4311 col = ctxt->input->col;
4312 } else if (ctxt->sax != NULL) {
4313 if (ctxt->sax->characters != NULL)
4314 ctxt->sax->characters(ctxt->userData,
4315 ctxt->input->cur, nbchar);
4316 line = ctxt->input->line;
4317 col = ctxt->input->col;
4320 if (ctxt->instate != XML_PARSER_CONTENT)
4323 ctxt->input->cur = in;
4327 ctxt->input->cur = in;
4329 ctxt->input->line++; ctxt->input->col = 1;
4342 in = ctxt->input->cur;
4346 ctxt->input->line = line;
4347 ctxt->input->col = col;
4348 xmlParseCharDataComplex(ctxt, cdata);
4353 * @ctxt: an XML parser context
4361 xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
4377 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4387 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4388 if (areBlanks(ctxt, buf, nbchar, 0)) {
4389 if (ctxt->sax->ignorableWhitespace != NULL)
4390 ctxt->sax->ignorableWhitespace(ctxt->userData,
4393 if (ctxt->sax->characters != NULL)
4394 ctxt->sax->characters(ctxt->userData, buf, nbchar);
4395 if ((ctxt->sax->characters !=
4396 ctxt->sax->ignorableWhitespace) &&
4397 (*ctxt->space == -1))
4398 *ctxt->space = -2;
4403 if (ctxt->instate != XML_PARSER_CONTENT)
4419 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4420 if (areBlanks(ctxt, buf, nbchar, 0)) {
4421 if (ctxt->sax->ignorableWhitespace != NULL)
4422 ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
4424 if (ctxt->sax->characters != NULL)
4425 ctxt->sax->characters(ctxt->userData, buf, nbchar);
4426 if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) &&
4427 (*ctxt->space == -1))
4428 *ctxt->space = -2;
4434 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4443 * @ctxt: an XML parser context
4464 xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
4473 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4477 URI = xmlParseSystemLiteral(ctxt);
4479 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4484 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4488 *publicID = xmlParsePubidLiteral(ctxt);
4490 xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
4497 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4516 URI = xmlParseSystemLiteral(ctxt);
4518 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4526 * @ctxt: an XML parser context
4539 xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf, int len, int size) {
4546 inputid = ctxt->input->id;
4553 xmlErrMemory(ctxt, NULL);
4562 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4573 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4587 xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
4595 xmlErrMemory(ctxt, NULL);
4621 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4624 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4628 if (inputid != ctxt->input->id) {
4629 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4633 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4634 (!ctxt->disableSAX))
4635 ctxt->sax->comment(ctxt->userData, buf);
4640 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4648 * @ctxt: an XML parser context
4657 xmlParseComment(xmlParserCtxtPtr ctxt) {
4671 state = ctxt->instate;
4672 ctxt->instate = XML_PARSER_COMMENT;
4673 inputid = ctxt->input->id;
4682 in = ctxt->input->cur;
4686 ctxt->input->line++; ctxt->input->col = 1;
4691 ccol = ctxt->input->col;
4698 ctxt->input->col = ccol;
4701 ctxt->input->line++; ctxt->input->col = 1;
4706 nbchar = in - ctxt->input->cur;
4711 if ((ctxt->sax != NULL) &&
4712 (ctxt->sax->comment != NULL)) {
4720 xmlErrMemory(ctxt
4721 ctxt->instate = state;
4732 xmlErrMemory(ctxt, NULL);
4733 ctxt->instate = state;
4738 memcpy(&buf[len], ctxt->input->cur, nbchar);
4743 ctxt->input->cur = in;
4746 ctxt->input->line++; ctxt->input->col = 1;
4751 ctxt->input->cur = in;
4753 ctxt->input->line++; ctxt->input->col = 1;
4760 in = ctxt->input->cur;
4764 if (ctxt->input->id != inputid) {
4765 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4769 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4770 (!ctxt->disableSAX)) {
4772 ctxt->sax->comment(ctxt->userData, buf);
4774 ctxt->sax->comment(ctxt->userData, BAD_CAST "");
4778 ctxt->instate = state;
4782 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4786 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4789 ctxt->input->col++;
4792 ctxt->input->col++;
4796 xmlParseCommentComplex(ctxt, buf, len, size);
4797 ctxt->instate = state;
4804 * @ctxt: an XML parser context
4814 xmlParsePITarget(xmlParserCtxtPtr ctxt) {
4817 name = xmlParseName(ctxt);
4825 xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
4829 xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
4837 xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
4842 xmlNsErr(ctxt, XML_NS_ERR_COLON,
4851 * @ctxt: an XML parser context
4865 xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
4896 ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
4902 xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
4912 * @ctxt: an XML parser context
4922 xmlParsePI(xmlParserCtxtPtr ctxt) {
4932 xmlParserInputPtr input = ctxt->input;
4933 state = ctxt->instate;
4934 ctxt->instate = XML_PARSER_PI;
4945 target = xmlParsePITarget(ctxt);
4948 if (input != ctxt->input) {
4949 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4957 if ((ctxt->sax) && (!ctxt->disableSAX) &&
4958 (ctxt->sax->processingInstruction != NULL))
4959 ctxt->sax->processingInstruction(ctxt->userData,
4961 if (ctxt->instate != XML_PARSER_EOF)
4962 ctxt->instate = state;
4967 xmlErrMemory(ctxt, NULL);
4968 ctxt->instate = state;
4973 xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
4986 xmlErrMemory(ctxt, NULL);
4988 ctxt->instate = state;
5009 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5012 if (input != ctxt->input) {
5013 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5025 xmlParseCatalogPI(ctxt, buf);
5033 if ((ctxt->sax) && (!ctxt->disableSAX) &&
5034 (ctxt->sax->processingInstruction != NULL))
5035 ctxt->sax->processingInstruction(ctxt->userData,
5040 xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
5042 if (ctxt->instate != XML_PARSER_EOF)
5043 ctxt->instate = state;
5049 * @ctxt: an XML parser context
5064 xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
5070 xmlParserInputPtr input = ctxt->input;
5074 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5080 name = xmlParseName(ctxt);
5082 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5086 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5091 xmlNsErr(ctxt, XML_NS_ERR_COLON,
5100 Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
5104 if (input != ctxt->input) {
5105 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5109 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5110 (ctxt->sax->notationDecl != NULL))
5111 ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
5113 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5122 * @ctxt: an XML parser context
5143 xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
5154 xmlParserInputPtr input = ctxt->input;
5159 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5167 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5173 name = xmlParseName(ctxt);
5175 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5180 xmlNsErr(ctxt, XML_NS_ERR_COLON,
5186 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5190 ctxt->instate = XML_PARSER_ENTITY_DECL;
5196 value = xmlParseEntityValue(ctxt, &orig);
5198 if ((ctxt->sax != NULL) &&
5199 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5200 ctxt->sax->entityDecl(ctxt->userData, name,
5205 URI = xmlParseExternalID(ctxt, &literal, 1);
5207 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5214 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5227 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5229 if ((ctxt->sax != NULL) &&
5230 (!ctxt->disableSAX) &&
5231 (ctxt->sax->entityDecl != NULL))
5232 ctxt->sax->entityDecl(ctxt->userData, name,
5242 value = xmlParseEntityValue(ctxt, &orig);
5243 if ((ctxt->sax != NULL) &&
5244 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5245 ctxt->sax->entityDecl(ctxt->userData, name,
5251 if ((ctxt->myDoc == NULL) ||
5252 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
5253 if (ctxt->myDoc == NULL) {
5254 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5255 if (ctxt->myDoc == NULL) {
5256 xmlErrMemory(ctxt, "New Doc failed");
5259 ctxt->myDoc->properties = XML_DOC_INTERNAL;
5261 if (ctxt->myDoc->intSubset == NULL)
5262 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5265 xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
5269 URI = xmlParseExternalID(ctxt, &literal, 1);
5271 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5278 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5291 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5297 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5304 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5308 ndata = xmlParseName(ctxt);
5309 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5310 (ctxt->sax->unparsedEntityDecl != NULL))
5311 ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
5314 if ((ctxt->sax != NULL) &&
5315 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5316 ctxt->sax->entityDecl(ctxt->userData, name,
5323 if ((ctxt->replaceEntities != 0) &&
5324 ((ctxt->myDoc == NULL) ||
5325 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
5326 if (ctxt->myDoc == NULL) {
5327 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5328 if (ctxt->myDoc == NULL) {
5329 xmlErrMemory(ctxt, "New Doc failed");
5332 ctxt->myDoc->properties = XML_DOC_INTERNAL;
5335 if (ctxt->myDoc->intSubset == NULL)
5336 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5338 xmlSAX2EntityDecl(ctxt, name,
5347 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
5350 if (input != ctxt->input) {
5351 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5363 if ((ctxt->sax != NULL) &&
5364 (ctxt->sax->getParameterEntity != NULL))
5365 cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
5367 if ((ctxt->sax != NULL) &&
5368 (ctxt->sax->getEntity != NULL))
5369 cur = ctxt->sax->getEntity(ctxt->userData, name);
5370 if ((cur == NULL) && (ctxt->userData==ctxt)) {
5371 cur = xmlSAX2GetEntity(ctxt, name);
5390 * @ctxt: an XML parser context
5418 xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
5436 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5441 ret = xmlParseAttValue(ctxt);
5442 ctxt->instate = XML_PARSER_DTD;
5444 xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
5453 * @ctxt: an XML parser context
5469 xmlParseNotationType(xmlParserCtxtPtr ctxt) {
5474 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5481 name = xmlParseName(ctxt);
5483 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5491 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5494 if (!xmlDictOwns(ctxt->dict, name))
5515 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5525 * @ctxt: an XML parser context
5539 xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
5544 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
5551 name = xmlParseNmtoken(ctxt);
5553 xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
5559 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5562 if (!xmlDictOwns(ctxt->dict, name))
5570 if (!xmlDictOwns(ctxt->dict, name))
5585 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
5594 * @ctxt: an XML parser context
5608 xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5612 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5617 *tree = xmlParseNotationType(ctxt);
5621 *tree = xmlParseEnumerationType(ctxt);
5628 * @ctxt: an XML parser context
5672 xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5699 return(xmlParseEnumeratedType(ctxt, tree));
5704 * @ctxt: an XML parser context
5714 xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
5720 xmlParserInputPtr input = ctxt->input;
5724 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5728 elemName = xmlParseName(ctxt);
5730 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5744 attrName = xmlParseName(ctxt);
5746 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5752 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5758 type = xmlParseAttributeType(ctxt, &tree);
5765 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5773 def = xmlParseDefaultDecl(ctxt, &defaultValue);
5787 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5798 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
5806 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5807 (ctxt->sax->attributeDecl != NULL))
5808 ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
5813 if ((ctxt->sax2) && (defaultValue != NULL) &&
5816 xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
5818 if (ctxt->sax2) {
5819 xmlAddSpecialAttr(ctxt, elemName, attrName, type);
5826 if (input != ctxt->input) {
5827 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5838 * @ctxt: an XML parser context
5856 xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
5866 if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5867 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5872 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5882 ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5888 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5895 n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5897 n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5906 elem = xmlParseName(ctxt);
5908 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5910 xmlFreeDocElementContent(ctxt->myDoc, cur);
5918 cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
5925 if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5926 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5932 xmlFreeDocElementContent(ctxt->myDoc, ret);
5933 xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
5938 xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
5945 * @ctxt: an XML parser context
5976 xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk,
5982 if (((depth > 128) && ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
5984 xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED,
5992 int inputid = ctxt->input->id;
5997 cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6002 elem = xmlParseName(ctxt);
6004 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6007 cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6009 xmlErrMemory(ctxt, NULL);
6040 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6044 xmlFreeDocElementContent(ctxt->myDoc, last);
6046 xmlFreeDocElementContent(ctxt->myDoc, ret);
6051 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
6054 xmlFreeDocElementContent(ctxt->myDoc, last);
6055 xmlFreeDocElementContent(ctxt->myDoc, ret);
6080 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6084 xmlFreeDocElementContent(ctxt->myDoc, last);
6086 xmlFreeDocElementContent(ctxt->myDoc, ret);
6091 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6094 xmlFreeDocElementContent(ctxt->myDoc, last);
6096 xmlFreeDocElementContent(ctxt->myDoc, ret);
6115 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
6117 xmlFreeDocElementContent(ctxt->myDoc, last);
6119 xmlFreeDocElementContent(ctxt->myDoc, ret);
6126 int inputid = ctxt->input->id;
6130 last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6134 elem = xmlParseName(ctxt);
6136 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6138 xmlFreeDocElementContent(ctxt->myDoc, ret);
6141 last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6144 xmlFreeDocElementContent(ctxt->myDoc, ret);
6168 if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6169 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6243 * @ctxt: an XML parser context
6272 xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6274 return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1));
6279 * @ctxt: an XML parser context
6292 xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
6296 int inputid = ctxt->input->id;
6302 xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6310 tree = xmlParseElementMixedContentDecl(ctxt, inputid);
6313 tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1);
6323 * @ctxt: an XML parser context
6335 xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
6342 xmlParserInputPtr input = ctxt->input;
6346 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6350 name = xmlParseName(ctxt);
6352 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6356 while ((RAW == 0) && (ctxt->inputNr > 1))
6357 xmlPopInput(ctxt);
6359 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6377 ret = xmlParseElementContentDecl(ctxt, name, &content);
6382 if ((RAW == '%') && (ctxt->external == 0) &&
6383 (ctxt->inputNr == 1)) {
6384 xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
6387 xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6397 while ((RAW == 0) && (ctxt->inputNr > 1))
6398 xmlPopInput(ctxt);
6402 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
6404 xmlFreeDocElementContent(ctxt->myDoc, content);
6407 if (input != ctxt->input) {
6408 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6413 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6414 (ctxt->sax->elementDecl != NULL)) {
6417 ctxt->sax->elementDecl(ctxt->userData, name, ret,
6426 xmlFreeDocElementContent(ctxt->myDoc, content);
6429 xmlFreeDocElementContent(ctxt->myDoc, content);
6438 * @ctxt: an XML parser context
6448 xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
6449 int id = ctxt->input->id;
6457 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6459 if (ctxt->input->id != id) {
6460 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6467 if ((ctxt->input != NULL) && (ctxt->input->filename))
6469 "%s(%d): ", ctxt->input->filename,
6470 ctxt->input->line);
6478 unsigned int cons = ctxt->input->consumed;
6481 xmlParseConditionalSections(ctxt);
6485 xmlParsePEReference(ctxt);
6487 xmlParseMarkupDecl(ctxt);
6492 while ((RAW == 0) && (ctxt->inputNr > 1))
6493 xmlPopInput(ctxt);
6495 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
6496 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6501 if ((ctxt->input != NULL) && (ctxt->input->filename))
6503 "%s(%d): ", ctxt->input->filename,
6504 ctxt->input->line);
6517 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6519 if (ctxt->input->id != id) {
6520 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6527 if ((ctxt->input != NULL) && (ctxt->input->filename))
6529 "%s(%d): ", ctxt->input->filename,
6530 ctxt->input->line);
6539 state = ctxt->disableSAX;
6540 instate = ctxt->instate;
6541 if (ctxt->recovery == 0) ctxt->disableSAX = 1;
6542 ctxt->instate = XML_PARSER_IGNORE;
6558 ctxt->disableSAX = state;
6559 ctxt->instate = instate;
6562 if ((ctxt->input != NULL) && (ctxt->input->filename))
6564 "%s(%d): ", ctxt->input->filename,
6565 ctxt->input->line);
6571 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
6578 xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
6580 if (ctxt->input->id != id) {
6581 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6591 * @ctxt: an XML parser context
6612 xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
6619 xmlParseElementDecl(ctxt);
6621 xmlParseEntityDecl(ctxt);
6624 xmlParseAttributeListDecl(ctxt);
6627 xmlParseNotationDecl(ctxt);
6630 xmlParseComment(ctxt);
6637 xmlParsePI(ctxt);
6644 if ((ctxt->external == 0) && (ctxt->inputNr == 1))
6645 xmlParsePEReference(ctxt);
6651 if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
6653 xmlParseConditionalSections(ctxt);
6657 ctxt->instate = XML_PARSER_DTD;
6662 * @ctxt: an XML parser context
6670 xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
6680 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
6685 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6693 version = xmlParseVersionInfo(ctxt);
6698 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6702 ctxt->input->version = version;
6707 encoding = xmlParseEncodingDecl(ctxt);
6708 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
6714 if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
6715 xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
6724 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
6727 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
6735 * @ctxt: an XML parser context
6746 xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
6748 xmlDetectSAX2(ctxt);
6751 if ((ctxt->encoding == NULL) &&
6752 (ctxt->input->end - ctxt->input->cur >= 4)) {
6762 xmlSwitchEncoding(ctxt, enc);
6766 xmlParseTextDecl(ctxt);
6767 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
6771 ctxt->instate = XML_PARSER_EOF;
6775 if (ctxt->myDoc == NULL) {
6776 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
6777 if (ctxt->myDoc == NULL) {
6778 xmlErrMemory(ctxt, "New Doc failed");
6781 ctxt->myDoc->properties = XML_DOC_INTERNAL;
6783 if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
6784 xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
6786 ctxt->instate = XML_PARSER_DTD;
6787 ctxt->external = 1;
6792 unsigned int cons = ctxt->input->consumed;
6796 xmlParseConditionalSections(ctxt);
6800 xmlParsePEReference(ctxt);
6802 xmlParseMarkupDecl(ctxt);
6807 while ((RAW == 0) && (ctxt->inputNr > 1))
6808 xmlPopInput(ctxt);
6810 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
6811 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6817 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6824 * @ctxt: an XML parser context
6834 xmlParseReference(xmlParserCtxtPtr ctxt) {
6852 int value = xmlParseCharRef(ctxt);
6856 if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
6865 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6866 (!ctxt->disableSAX))
6867 ctxt->sax->characters(ctxt->userData, out, 1);
6873 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
6874 (!ctxt->disableSAX))
6875 ctxt->sax->reference(ctxt->userData, out);
6883 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6884 (!ctxt->disableSAX))
6885 ctxt->sax->characters(ctxt->userData, out, i);
6893 ent = xmlParseEntityRef(ctxt);
6895 if (!ctxt->wellFormed)
6907 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6908 (!ctxt->disableSAX))
6909 ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
6919 unsigned long oldnbent = ctxt->nbentities;
6927 if (ctxt->userData == ctxt)
6930 user_data = ctxt->userData;
6939 ctxt->depth++;
6940 ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content,
6942 ctxt->depth--;
6945 ctxt->depth++;
6946 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax,
6947 user_data, ctxt->depth, ent->URI,
6949 ctxt->depth--;
6952 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
6960 ent->checked = ctxt->nbentities - oldnbent;
6962 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6966 if (xmlParserEntityCheck(ctxt, 0, ent)) {
6976 if (ctxt->replaceEntities) {
6983 (ctxt->parseMode == XML_PARSE_READER)) {
6990 list->parent = (xmlNodePtr) ctxt->node;
6991 list->doc = ctxt->myDoc;
7018 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7027 ctxt->nbentities += ent->checked;
7049 if (ctxt->userData == ctxt)
7052 user_data = ctxt->userData;
7055 ctxt->depth++;
7056 ret = xmlParseBalancedChunkMemoryInternal(ctxt,
7058 ctxt->depth--;
7061 ctxt->depth++;
7062 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
7063 ctxt->sax, user_data, ctxt->depth,
7065 ctxt->depth--;
7068 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
7072 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7076 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7077 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7082 ctxt->sax->reference(ctxt->userData, ent->name);
7090 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7091 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7095 ctxt->sax->reference(ctxt->userData, ent->name);
7099 if ((ctxt
7113 if ((ctxt->node != NULL) && (ent->children != NULL)) {
7122 (ctxt->parseMode == XML_PARSE_READER)) {
7128 if (ctxt->parseMode == XML_PARSE_READER)
7134 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7141 nw = xmlAddChild(ctxt->node, nw);
7148 if ((ctxt->parseMode == XML_PARSE_READER) &&
7179 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7187 xmlAddChild(ctxt->node, cur);
7207 nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
7214 xmlAddChildList(ctxt->node, ent->children);
7221 ctxt->nodemem = 0;
7222 ctxt->nodelen = 0;
7230 * @ctxt: an XML parser context
7257 xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
7266 name = xmlParseName(ctxt);
7268 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7273 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7281 if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7290 ctxt->nbentities++;
7296 if (ctxt->sax != NULL) {
7297 if (ctxt->sax->getEntity != NULL)
7298 ent = ctxt->sax->getEntity(ctxt->userData, name);
7299 if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7300 (ctxt->options & XML_PARSE_OLDSAX))
7302 if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7303 (ctxt->userData==ctxt)) {
7304 ent = xmlSAX2GetEntity(ctxt, name);
7329 if ((ctxt->standalone == 1) ||
7330 ((ctxt->hasExternalSubset == 0) &&
7331 (ctxt->hasPErefs == 0))) {
7332 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7335 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7337 if ((ctxt->inSubset == 0) &&
7338 (ctxt->sax != NULL) &&
7339 (ctxt->sax->reference != NULL)) {
7340 ctxt->sax->reference(ctxt->userData, name);
7343 ctxt->valid = 0;
7352 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7361 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7363 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7372 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7376 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7387 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7407 * @ctxt: an XML parser context
7437 xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
7451 name = xmlParseStringName(ctxt, &ptr);
7453 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7459 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7470 if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7482 ctxt->nbentities++;
7488 if (ctxt->sax != NULL) {
7489 if (ctxt->sax->getEntity != NULL)
7490 ent = ctxt->sax->getEntity(ctxt->userData, name);
7491 if ((ent == NULL) && (ctxt->options & XML_PARSE_OLDSAX))
7493 if ((ent == NULL) && (ctxt->userData==ctxt)) {
7494 ent = xmlSAX2GetEntity(ctxt, name);
7520 if ((ctxt->standalone == 1) ||
7521 ((ctxt->hasExternalSubset == 0) &&
7522 (ctxt->hasPErefs == 0))) {
7523 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7526 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7530 /* TODO ? check regressions ctxt->valid = 0; */
7539 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7548 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7550 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7559 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7563 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7575 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7598 * @ctxt: an XML parser context
7626 xmlParsePEReference(xmlParserCtxtPtr ctxt)
7635 name = xmlParseName(ctxt);
7637 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7642 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7651 ctxt->nbentities++;
7656 if ((ctxt->sax != NULL) &&
7657 (ctxt->sax->getParameterEntity != NULL))
7658 entity = ctxt->sax->getParameterEntity(ctxt->userData,
7669 if ((ctxt->standalone == 1) ||
7670 ((ctxt->hasExternalSubset == 0) &&
7671 (ctxt->hasPErefs == 0))) {
7672 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7683 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7686 ctxt->valid = 0;
7694 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7697 } else if (ctxt->input->free != deallocblankswrapper) {
7698 input = xmlNewBlanksWrapperInputStream(ctxt, entity);
7699 if (xmlPushInput(ctxt, input) < 0)
7707 input = xmlNewEntityInputStream(ctxt, entity);
7708 if (xmlPushInput(ctxt, input) < 0)
7713 xmlParseTextDecl(ctxt);
7714 if (ctxt->errNo ==
7720 ctxt->instate = XML_PARSER_EOF;
7726 ctxt->hasPErefs = 1;
7731 * @ctxt: an XML parser context
7741 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
7747 if ((ctxt == NULL) || (entity == NULL) ||
7751 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7762 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7767 input = xmlNewEntityInputStream(ctxt, entity);
7769 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7779 if (xmlPushInput(ctxt, input) < 0) {
7786 while ((ctxt->input == input) && (ctxt->input->cur < ctxt->input->end) &&
7788 xmlBufferAdd(buf, ctxt->input->cur, l);
7797 if ((ctxt->input == input) && (ctxt->input->cur >= ctxt->input->end)) {
7798 xmlPopInput(ctxt);
7800 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
7815 * @ctxt: an XML parser context
7845 xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
7857 name = xmlParseStringName(ctxt, &ptr);
7859 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7866 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7876 ctxt->nbentities++;
7881 if ((ctxt->sax != NULL) &&
7882 (ctxt->sax->getParameterEntity != NULL))
7883 entity = ctxt->sax->getParameterEntity(ctxt->userData,
7894 if ((ctxt->standalone == 1) ||
7895 ((ctxt->hasExternalSubset == 0) && (ctxt->hasPErefs == 0))) {
7896 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7906 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7909 ctxt->valid = 0;
7917 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7922 ctxt->hasPErefs = 1;
7930 * @ctxt: an XML parser context
7943 xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
7958 name = xmlParseName(ctxt);
7960 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7963 ctxt->intSubName = name;
7970 URI = xmlParseExternalID(ctxt, &ExternalID, 1);
7973 ctxt->hasExternalSubset = 1;
7975 ctxt->extSubURI = URI;
7976 ctxt->extSubSystem = ExternalID;
7983 if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
7984 (!ctxt->disableSAX))
7985 ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
7998 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8005 * @ctxt: an XML parser context
8013 xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
8018 ctxt->instate = XML_PARSER_DTD;
8027 unsigned int cons = ctxt->input->consumed;
8030 xmlParseMarkupDecl(ctxt);
8031 xmlParsePEReference(ctxt);
8036 while ((RAW == 0) && (ctxt->inputNr > 1))
8037 xmlPopInput(ctxt);
8039 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
8040 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8055 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8063 * @ctxt: an XML parser context
8095 xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
8101 name = xmlParseName(ctxt);
8103 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8115 val = xmlParseAttValue(ctxt);
8116 ctxt->instate = XML_PARSER_CONTENT;
8118 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8128 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
8130 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8141 *(ctxt->space) = 0;
8143 *(ctxt->space) = 1;
8145 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8157 * @ctxt: an XML parser context
8184 xmlParseStartTag(xmlParserCtxtPtr ctxt) {
8188 const xmlChar **atts = ctxt->atts;
8190 int maxatts = ctxt->maxatts;
8196 name = xmlParseName(ctxt);
8198 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8215 unsigned int cons = ctxt->input->consumed;
8217 attname = xmlParseAttribute(ctxt, &attvalue);
8226 xmlErrAttributeDup(ctxt, NULL, attname);
8239 xmlErrMemory(ctxt, NULL);
8244 ctxt->atts = atts;
8245 ctxt->maxatts = maxatts;
8253 xmlErrMemory(ctxt, NULL);
8259 ctxt->atts = atts;
8260 ctxt->maxatts = maxatts;
8277 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8281 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
8283 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
8294 if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
8295 (!ctxt->disableSAX)) {
8297 ctxt->sax->startElement(ctxt->userData, name, atts);
8299 ctxt->sax->startElement(ctxt->userData, name, NULL);
8313 * @ctxt: an XML parser context
8327 xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
8332 xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
8338 name = xmlParseNameAndCompare(ctxt,ctxt->name);
8346 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
8358 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
8360 ctxt->name, line, name);
8366 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
8367 (!ctxt->disableSAX))
8368 ctxt->sax->endElement(ctxt->userData, ctxt->name);
8370 namePop(ctxt);
8371 spacePop(ctxt);
8377 * @ctxt: an XML parser context
8389 xmlParseEndTag(xmlParserCtxtPtr ctxt) {
8390 xmlParseEndTag1(ctxt, 0);
8402 * @ctxt: an XML parser context
8406 * The prefix must come from the @ctxt->dict dictionnary
8411 xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
8414 if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
8415 for (i = ctxt->nsNr - 2;i >= 0;i-=2)
8416 if (ctxt->nsTab[i] == prefix) {
8417 if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
8419 return(ctxt->nsTab[i + 1]);
8426 * @ctxt: an XML parser context
8439 xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
8444 l = xmlParseNCName(ctxt);
8447 l = xmlParseName(ctxt);
8449 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8460 l = xmlParseNCName(ctxt);
8464 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8466 l = xmlParseNmtoken(ctxt);
8473 p = xmlDictLookup(ctxt->dict, tmp, -1);
8481 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8484 tmp = (xmlChar *) xmlParseName(ctxt);
8487 l = xmlDictLookup(ctxt->dict, tmp, -1);
8493 l = xmlDictLookup(ctxt->dict, tmp, -1);
8506 * @ctxt: an XML parser context
8518 xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
8525 if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
8528 in = ctxt->input->cur;
8544 ctxt->input->cur = in;
8551 ret = xmlParseQName (ctxt, &prefix2);
8559 * @ctxt: an XML parser context
8592 xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len, int *alloc,
8602 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
8605 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
8613 end = ctxt->input->end;
8616 const xmlChar *oldbase = ctxt->input->base;
8618 if (oldbase != ctxt->input->base) {
8619 long delta = ctxt->input->base - oldbase;
8623 end = ctxt->input->end;
8635 const xmlChar *oldbase = ctxt->input->base;
8637 if (oldbase != ctxt->input->base) {
8638 long delta = ctxt->input->base - oldbase;
8642 end = ctxt->input->end;
8649 const xmlChar *oldbase = ctxt->input->base;
8651 if (oldbase != ctxt->input->base) {
8652 long delta = ctxt->input->base - oldbase;
8656 end = ctxt->input->end;
8669 const xmlChar *oldbase = ctxt->input->base;
8671 if (oldbase != ctxt->input->base) {
8672 long delta = ctxt->input->base - oldbase;
8677 end = ctxt->input->end;
8686 const xmlChar *oldbase = ctxt->input->base;
8688 if (oldbase != ctxt->input->base) {
8689 long delta = ctxt->input->base - oldbase;
8693 end = ctxt->input->end;
8712 return xmlParseAttValueComplex(ctxt, len, normalize);
8717 * @ctxt: an XML parser context
8731 xmlParseAttribute2(xmlParserCtxtPtr ctxt,
8742 name = xmlParseQName(ctxt, prefix);
8744 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8752 if (ctxt->attsSpecial != NULL) {
8755 type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial,
8768 val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
8779 val2 = xmlAttrNormalizeSpace2(ctxt, val, len);
8786 ctxt->instate = XML_PARSER_CONTENT;
8788 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8794 if (*prefix == ctxt->str_xml) {
8800 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
8803 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8815 *(ctxt->space) = 0;
8817 *(ctxt->space) = 1;
8819 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8834 * @ctxt
8862 xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
8870 const xmlChar **atts = ctxt->atts;
8871 int maxatts = ctxt->maxatts;
8876 int nsNr = ctxt->nsNr;
8890 base = ctxt->input->base;
8891 cur = ctxt->input->cur - ctxt->input->base;
8892 oldline = ctxt->input->line;
8893 oldcol = ctxt->input->col;
8900 ctxt->nsNr = nsNr;
8902 localname = xmlParseQName(ctxt, &prefix);
8904 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8908 *tlen = ctxt->input->cur - ctxt->input->base - cur;
8917 if (ctxt->input->base != base) goto base_changed;
8923 unsigned int cons = ctxt->input->consumed;
8926 attname = xmlParseAttribute2(ctxt, prefix, localname,
8928 if (ctxt->input->base != base) {
8936 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
8937 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
8943 xmlNsErr(ctxt, XML_WAR_NS_URI,
8948 xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
8954 if (URL == ctxt->str_xml_ns) {
8955 if (attname != ctxt->str_xml) {
8956 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8965 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8975 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
8978 xmlErrAttributeDup(ctxt, NULL, attname);
8980 if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
8986 if (aprefix == ctxt->str_xmlns) {
8987 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
8990 if (attname == ctxt->str_xml) {
8991 if (URL != ctxt->str_xml_ns) {
8992 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9001 if (URL == ctxt->str_xml_ns) {
9002 if (attname != ctxt->str_xml) {
9003 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9009 if (attname == ctxt->str_xmlns) {
9010 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9018 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9024 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9031 xmlNsErr(ctxt, XML_WAR_NS_URI,
9035 if ((ctxt->pedantic) && (uri->scheme == NULL)) {
9036 xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9048 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9051 xmlErrAttributeDup(ctxt, aprefix, attname);
9053 if (nsPush(ctxt, attname, URL) > 0) nbNs++;
9057 if (ctxt->input->base != base) goto base_changed;
9065 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9070 maxatts = ctxt->maxatts;
9071 atts = ctxt->atts;
9073 ctxt->attallocs[nratts++] = alloc;
9092 if (ctxt->input->base != base) goto base_changed;
9096 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9101 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
9103 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9108 if (ctxt->input->base != base) goto base_changed;
9114 if (ctxt->attsDefault != NULL) {
9117 defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
9126 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9131 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
9135 nsname = xmlGetNamespace(ctxt, NULL);
9137 if (nsPush(ctxt, NULL,
9141 } else if (aprefix == ctxt->str_xmlns) {
9146 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9150 nsname = xmlGetNamespace(ctxt, attname);
9152 if (nsPush(ctxt, attname,
9167 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9170 maxatts = ctxt->maxatts;
9171 atts = ctxt->atts;
9178 atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
9181 if ((ctxt->standalone == 1) &&
9183 xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED,
9201 nsname = xmlGetNamespace(ctxt, atts[i + 1]);
9203 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9219 xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
9223 xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
9232 nsname = xmlGetNamespace(ctxt, prefix);
9234 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9244 if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
9245 (!ctxt->disableSAX)) {
9247 ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9248 nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
9251 ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9260 if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9272 if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9275 ctxt->input->cur = ctxt->input->base + cur;
9276 ctxt->input->line = oldline;
9277 ctxt->input->col = oldcol;
9278 if (ctxt->wellFormed == 1) {
9286 * @ctxt: an XML parser context
9300 xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
9306 xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
9311 if ((tlen > 0) && (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
9312 if (ctxt->input->cur[tlen] == '>') {
9313 ctxt->input->cur += tlen + 1;
9316 ctxt->input->cur += tlen;
9320 name = xmlParseNameAndCompare(ctxt, ctxt->name);
9322 name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
9331 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
9343 if ((line == 0) && (ctxt->node != NULL))
9344 line = ctxt->node->line;
9345 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
9347 ctxt->name, line, name);
9354 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
9355 (!ctxt->disableSAX))
9356 ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
9358 spacePop(ctxt);
9360 nsPop(ctxt, nsNr);
9366 * @ctxt: an XML parser context
9379 xmlParseCDSect(xmlParserCtxtPtr ctxt) {
9394 ctxt->instate = XML_PARSER_CDATA_SECTION;
9397 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9398 ctxt->instate = XML_PARSER_CONTENT;
9404 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9405 ctxt->instate = XML_PARSER_CONTENT;
9412 xmlErrMemory(ctxt, NULL);
9424 xmlErrMemory(ctxt, NULL);
9443 ctxt->instate = XML_PARSER_CONTENT;
9445 xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
9455 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
9456 if (ctxt->sax->cdataBlock != NULL)
9457 ctxt->sax->cdataBlock(ctxt->userData, buf, len);
9458 else if (ctxt->sax->characters != NULL)
9459 ctxt->sax->characters(ctxt->userData, buf, len);
9466 * @ctxt: an XML parser context
9474 xmlParseContent(xmlParserCtxtPtr ctxt) {
9478 (ctxt->instate != XML_PARSER_EOF)) {
9480 unsigned int cons = ctxt->input->consumed;
9481 const xmlChar *cur = ctxt->input->cur;
9487 xmlParsePI(ctxt);
9495 xmlParseCDSect(ctxt);
9503 xmlParseComment(ctxt);
9504 ctxt->instate = XML_PARSER_CONTENT;
9511 xmlParseElement(ctxt);
9520 xmlParseReference(ctxt);
9527 xmlParseCharData(ctxt, 0);
9534 while ((RAW == 0) && (ctxt->inputNr > 1))
9535 xmlPopInput(ctxt);
9538 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
9539 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9541 ctxt->instate = XML_PARSER_EOF;
9549 * @ctxt: an XML parser context
9562 xmlParseElement(xmlParserCtxtPtr ctxt) {
9569 int nsNr = ctxt->nsNr;
9571 if (((unsigned int) ctxt->nameNr > xmlParserMaxDepth) &&
9572 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9573 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
9576 ctxt->instate = XML_PARSER_EOF;
9581 if (ctxt->record_info) {
9582 node_info.begin_pos = ctxt->input->consumed +
9583 (CUR_PTR - ctxt->input->base);
9584 node_info.begin_line = ctxt->input->line;
9587 if (ctxt->spaceNr == 0)
9588 spacePush(ctxt, -1);
9589 else if (*ctxt->space == -2)
9590 spacePush(ctxt, -1);
9592 spacePush(ctxt, *ctxt->space);
9594 line = ctxt->input->line;
9596 if (ctxt->sax2)
9598 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
9601 name = xmlParseStartTag(ctxt);
9603 if (ctxt->instate == XML_PARSER_EOF)
9606 spacePop(ctxt);
9609 namePush(ctxt, name);
9610 ret = ctxt->node;
9618 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
9619 ctxt->node && (ctxt->node == ctxt->myDoc->children))
9620 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
9628 if (ctxt->sax2) {
9629 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
9630 (!ctxt->disableSAX))
9631 ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
9634 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
9635 (!ctxt->disableSAX))
9636 ctxt->sax->endElement(ctxt->userData, name);
9639 namePop(ctxt);
9640 spacePop(ctxt);
9641 if (nsNr != ctxt->nsNr)
9642 nsPop(ctxt, ctxt->nsNr - nsNr);
9643 if ( ret != NULL && ctxt->record_info ) {
9644 node_info.end_pos = ctxt->input->consumed +
9645 (CUR_PTR - ctxt->input->base);
9646 node_info.end_line = ctxt->input->line;
9648 xmlParserAddNodeInfo(ctxt, &node_info);
9655 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
9662 nodePop(ctxt);
9663 namePop(ctxt);
9664 spacePop(ctxt);
9665 if (nsNr != ctxt->nsNr)
9666 nsPop(ctxt, ctxt->nsNr - nsNr);
9671 if ( ret != NULL && ctxt->record_info ) {
9672 node_info.end_pos = ctxt->input->consumed +
9673 (CUR_PTR - ctxt->input->base);
9674 node_info.end_line = ctxt->input->line;
9676 xmlParserAddNodeInfo(ctxt, &node_info);
9684 xmlParseContent(ctxt);
9686 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
9693 nodePop(ctxt);
9694 namePop(ctxt);
9695 spacePop(ctxt);
9696 if (nsNr != ctxt->nsNr)
9697 nsPop(ctxt, ctxt->nsNr - nsNr);
9704 if (ctxt->sax2) {
9705 xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
9706 namePop(ctxt);
9710 xmlParseEndTag1(ctxt, line);
9716 if ( ret != NULL && ctxt->record_info ) {
9717 node_info.end_pos = ctxt->input->consumed +
9718 (CUR_PTR - ctxt->input->base);
9719 node_info.end_line = ctxt->input->line;
9721 xmlParserAddNodeInfo(ctxt, &node_info);
9727 * @ctxt: an XML parser context
9738 xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
9746 xmlErrMemory(ctxt, NULL);
9772 xmlErrMemory(ctxt, NULL);
9787 * @ctxt: an XML parser context
9799 xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
9806 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
9813 version = xmlParseVersionNum(ctxt);
9815 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9820 version = xmlParseVersionNum(ctxt);
9822 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9826 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
9834 * @ctxt: an XML parser context
9843 xmlParseEncName(xmlParserCtxtPtr ctxt) {
9854 xmlErrMemory(ctxt, NULL);
9872 xmlErrMemory(ctxt, NULL);
9889 xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
9896 * @ctxt: an XML parser context
9908 xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
9916 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
9923 encoding = xmlParseEncName(ctxt);
9925 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9930 encoding = xmlParseEncName(ctxt);
9932 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9936 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
9942 if (ctxt->options & XML_PARSE_IGNORE_ENC)
9958 if ((ctxt->encoding == NULL) &&
9959 (ctxt->input->buf != NULL) &&
9960 (ctxt->input->buf->encoder == NULL)) {
9961 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_ENCODING,
9964 if (ctxt->encoding != NULL)
9965 xmlFree((xmlChar *) ctxt->encoding);
9966 ctxt->encoding = encoding;
9974 if (ctxt->encoding != NULL)
9975 xmlFree((xmlChar *) ctxt->encoding);
9976 ctxt->encoding = encoding;
9981 if (ctxt->input->encoding != NULL)
9982 xmlFree((xmlChar *) ctxt->input->encoding);
9983 ctxt->input->encoding = encoding;
9987 xmlSwitchToEncoding(ctxt, handler);
9989 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
10000 * @ctxt: an XML parser context
10030 xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
10038 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10053 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10056 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10069 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10072 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10076 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10084 * @ctxt: an XML parser context
10092 xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
10100 ctxt->input->standalone = -2;
10108 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
10116 version = xmlParseVersionInfo(ctxt);
10118 xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
10124 if (ctxt->options & XML_PARSE_OLD10) {
10125 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10130 xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
10134 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10140 if (ctxt->version != NULL)
10141 xmlFree((void *) ctxt->version);
10142 ctxt->version = version;
10153 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10155 xmlParseEncodingDecl(ctxt);
10156 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10166 if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
10171 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10180 ctxt->input->standalone = xmlParseSDDecl(ctxt);
10187 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10190 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10198 * @ctxt: an XML parser context
10206 xmlParseMisc(xmlParserCtxtPtr ctxt) {
10211 xmlParsePI(ctxt);
10215 xmlParseComment(ctxt);
10221 * @ctxt: an XML parser context
10235 xmlParseDocument(xmlParserCtxtPtr ctxt) {
10241 if ((ctxt == NULL) || (ctxt->input == NULL))
10249 xmlDetectSAX2(ctxt);
10254 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10255 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
10257 if ((ctxt->encoding == NULL) &&
10258 ((ctxt->input->end - ctxt->input->cur) >= 4)) {
10270 xmlSwitchEncoding(ctxt, enc);
10276 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10285 if ((ctxt->input->end - ctxt->input->cur) < 35) {
10293 xmlParseXMLDecl(ctxt);
10294 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10300 ctxt->standalone = ctxt->input->standalone;
10303 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10305 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10306 ctxt->sax->startDocument(ctxt->userData);
10312 xmlParseMisc(ctxt);
10321 ctxt->inSubset = 1;
10322 xmlParseDocTypeDecl(ctxt);
10324 ctxt->instate = XML_PARSER_DTD;
10325 xmlParseInternalSubset(ctxt);
10331 ctxt->inSubset = 2;
10332 if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
10333 (!ctxt->disableSAX))
10334 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
10335 ctxt->extSubSystem, ctxt->extSubURI);
10336 ctxt->inSubset = 0;
10338 xmlCleanSpecialAttr(ctxt);
10340 ctxt->instate = XML_PARSER_PROLOG;
10341 xmlParseMisc(ctxt);
10349 xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
10352 ctxt->instate = XML_PARSER_CONTENT;
10353 xmlParseElement(ctxt);
10354 ctxt->instate = XML_PARSER_EPILOG;
10360 xmlParseMisc(ctxt);
10363 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10365 ctxt->instate = XML_PARSER_EOF;
10371 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10372 ctxt->sax->endDocument(ctxt->userData);
10377 if ((ctxt->myDoc != NULL) &&
10378 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
10379 xmlFreeDoc(ctxt->myDoc);
10380 ctxt->myDoc = NULL;
10383 if ((ctxt->wellFormed) && (ctxt->myDoc != NULL)) {
10384 ctxt->myDoc->properties |= XML_DOC_WELLFORMED;
10385 if (ctxt->valid)
10386 ctxt->myDoc->properties |= XML_DOC_DTDVALID;
10387 if (ctxt->nsWellFormed)
10388 ctxt->myDoc->properties |= XML_DOC_NSVALID;
10389 if (ctxt->options & XML_PARSE_OLD10)
10390 ctxt->myDoc->properties |= XML_DOC_OLD10;
10392 if (! ctxt->wellFormed) {
10393 ctxt->valid = 0;
10401 * @ctxt: an XML parser context
10414 xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
10418 if ((ctxt == NULL) || (ctxt->input == NULL))
10423 xmlDetectSAX2(ctxt);
10430 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10431 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
10438 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
10445 xmlSwitchEncoding(ctxt, enc);
10451 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10463 xmlParseXMLDecl(ctxt);
10464 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10472 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10474 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10475 ctxt->sax->startDocument(ctxt->userData);
10480 ctxt->instate = XML_PARSER_CONTENT;
10481 ctxt->validate = 0;
10482 ctxt->loadsubset = 0;
10483 ctxt->depth = 0;
10485 xmlParseContent(ctxt);
10488 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
10490 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
10496 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10497 ctxt->sax->endDocument(ctxt->userData);
10499 if (! ctxt->wellFormed) return(-1);
10512 * @ctxt: an XML parser context
10519 * This function has a side effect of (possibly) incrementing ctxt->checkIndex
10527 xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
10533 in = ctxt->input;
10537 if (ctxt->checkIndex > base)
10538 base = ctxt->checkIndex;
10557 ctxt->checkIndex = 0;
10575 ctxt->checkIndex = base;
10592 * @ctxt: an XML parser context
10599 xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
10603 if ((ctxt == NULL) || (lastlt == NULL) || (lastgt == NULL)) {
10608 if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) {
10609 tmp = ctxt->input->end;
10611 while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
10612 if (tmp < ctxt->input->base) {
10618 while ((tmp < ctxt->input->end) && (*tmp != '>')) {
10621 while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++;
10622 if (tmp < ctxt->input->end) tmp++;
10625 while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++;
10626 if (tmp < ctxt->input->end) tmp++;
10630 if (tmp < ctxt->input->end)
10635 while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
10636 if (tmp >= ctxt->input->base)
10716 * @ctxt: an XML parser context
10724 xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
10730 if (ctxt->input == NULL)
10734 switch (ctxt->instate) {
10786 if ((ctxt->input != NULL) &&
10787 (ctxt->input->cur - ctxt->input->base > 4096)) {
10788 xmlSHRINK(ctxt);
10789 ctxt->checkIndex = 0;
10791 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
10794 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
10801 while ((RAW == 0) && (ctxt->inputNr > 1))
10802 xmlPopInput(ctxt);
10804 if (ctxt->input == NULL) break;
10805 if (ctxt->input->buf == NULL)
10806 avail = ctxt->input->length -
10807 (ctxt->input->cur - ctxt->input->base);
10814 if ((ctxt->input->buf->raw != NULL) &&
10815 (ctxt->input->buf->raw->use > 0)) {
10816 int base = ctxt->input->base -
10817 ctxt->input->buf->buffer->content;
10818 int current = ctxt->input->cur - ctxt->input->base;
10820 xmlParserInputBufferPush(ctxt->input->buf, 0, "");
10821 ctxt->input->base = ctxt->input->buf->buffer->content + base;
10822 ctxt->input->cur = ctxt->input->base + current;
10823 ctxt->input->end =
10824 &ctxt->input->buf->buffer->content[
10825 ctxt->input->buf->buffer->use];
10827 avail = ctxt->input->buf->buffer->use -
10828 (ctxt->input->cur - ctxt->input->base);
10832 switch (ctxt->instate) {
10839 if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
10861 xmlSwitchEncoding(ctxt, enc);
10867 cur = ctxt->input->cur[0];
10868 next = ctxt->input->cur[1];
10870 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10871 ctxt->sax->setDocumentLocator(ctxt->userData,
10873 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10874 ctxt->instate = XML_PARSER_EOF;
10879 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10880 ctxt->sax->endDocument(ctxt->userData);
10887 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10889 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10890 ctxt->sax->setDocumentLocator(ctxt->userData,
10892 if ((ctxt->input->cur[2] == 'x') &&
10893 (ctxt->input->cur[3] == 'm') &&
10894 (ctxt->input->cur[4] == 'l') &&
10895 (IS_BLANK_CH(ctxt->input->cur[5]))) {
10901 xmlParseXMLDecl(ctxt);
10902 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10907 ctxt->instate = XML_PARSER_EOF;
10910 ctxt->standalone = ctxt->input->standalone;
10911 if ((ctxt->encoding == NULL) &&
10912 (ctxt->input->encoding != NULL))
10913 ctxt->encoding = xmlStrdup(ctxt->input->encoding);
10914 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
10915 (!ctxt->disableSAX))
10916 ctxt->sax->startDocument(ctxt->userData);
10917 ctxt->instate = XML_PARSER_MISC;
10923 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10924 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
10925 (!ctxt->disableSAX))
10926 ctxt->sax->startDocument(ctxt->userData);
10927 ctxt->instate = XML_PARSER_MISC;
10934 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10935 ctxt->sax->setDocumentLocator(ctxt->userData,
10937 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10938 if (ctxt->version == NULL) {
10939 xmlErrMemory(ctxt, NULL);
10942 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
10943 (!ctxt->disableSAX))
10944 ctxt->sax->startDocument(ctxt->userData);
10945 ctxt->instate = XML_PARSER_MISC;
10956 int nsNr = ctxt->nsNr;
10958 if ((avail < 2) && (ctxt->inputNr == 1))
10960 cur = ctxt->input->cur[0];
10962 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10963 ctxt->instate = XML_PARSER_EOF;
10964 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10965 ctxt->sax->endDocument(ctxt->userData);
10969 if (ctxt->progressive) {
10971 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
10973 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
10977 if (ctxt->spaceNr == 0)
10978 spacePush(ctxt, -1);
10979 else if (*ctxt->space == -2)
10980 spacePush(ctxt, -1);
10982 spacePush(ctxt, *ctxt->space);
10984 if (ctxt->sax2)
10986 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
10989 name = xmlParseStartTag(ctxt);
10991 if (ctxt->instate == XML_PARSER_EOF)
10994 spacePop(ctxt);
10995 ctxt->instate = XML_PARSER_EOF;
10996 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10997 ctxt->sax->endDocument(ctxt->userData);
11006 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
11007 ctxt->node && (ctxt->node == ctxt->myDoc->children))
11008 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
11017 if (ctxt->sax2) {
11018 if ((ctxt->sax != NULL) &&
11019 (ctxt->sax->endElementNs != NULL) &&
11020 (!ctxt->disableSAX))
11021 ctxt->sax->endElementNs(ctxt->userData, name,
11023 if (ctxt->nsNr - nsNr > 0)
11024 nsPop(ctxt, ctxt->nsNr - nsNr);
11027 if ((ctxt->sax != NULL) &&
11028 (ctxt->sax->endElement != NULL) &&
11029 (!ctxt->disableSAX))
11030 ctxt->sax->endElement(ctxt->userData, name);
11033 spacePop(ctxt);
11034 if (ctxt->nameNr == 0) {
11035 ctxt->instate = XML_PARSER_EPILOG;
11037 ctxt->instate = XML_PARSER_CONTENT;
11044 xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
11047 nodePop(ctxt);
11048 spacePop(ctxt);
11050 if (ctxt->sax2)
11051 nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
11054 namePush(ctxt, name);
11057 ctxt->instate = XML_PARSER_CONTENT;
11063 if ((avail < 2) && (ctxt->inputNr == 1))
11065 cur = ctxt->input->cur[0];
11066 next = ctxt->input->cur[1];
11069 cons = ctxt->input->consumed;
11071 ctxt->instate = XML_PARSER_END_TAG;
11075 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11077 xmlParsePI(ctxt);
11079 ctxt->instate = XML_PARSER_START_TAG;
11082 (ctxt->input->cur[2] == '-') &&
11083 (ctxt->input->cur[3] == '-')) {
11088 ctxt->input->cur += 4;
11089 term = xmlParseLookupSequence(ctxt, '-', '-', '>');
11090 ctxt->input->cur -= 4;
11093 xmlParseComment(ctxt);
11094 ctxt->instate = XML_PARSER_CONTENT;
11095 } else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
11096 (ctxt->input->cur[2] == '[') &&
11097 (ctxt->input->cur[3] == 'C') &&
11098 (ctxt->input->cur[4] == 'D') &&
11099 (ctxt->input->cur[5] == 'A') &&
11100 (ctxt->input->cur[6] == 'T') &&
11101 (ctxt->input->cur[7] == 'A') &&
11102 (ctxt->input->cur[8] == '[')) {
11104 ctxt->instate = XML_PARSER_CDATA_SECTION;
11111 (xmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
11113 xmlParseReference(ctxt);
11127 if ((ctxt->inputNr == 1) &&
11130 if (ctxt->progressive) {
11132 (ctxt->input->cur > lastlt))
11134 } else if (xmlParseLookupSequence(ctxt,
11140 ctxt->checkIndex = 0;
11141 xmlParseCharData(ctxt, 0);
11146 while ((RAW == 0) && (ctxt->inputNr > 1))
11147 xmlPopInput(ctxt);
11148 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
11149 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
11151 ctxt->instate = XML_PARSER_EOF;
11160 if (ctxt->progressive) {
11162 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
11164 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
11168 if (ctxt->sax2) {
11169 xmlParseEndTag2(ctxt,
11170 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 3],
11171 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 2], 0,
11172 (int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
11173 nameNsPop(ctxt);
11177 xmlParseEndTag1(ctxt, 0);
11179 if (ctxt->instate == XML_PARSER_EOF) {
11181 } else if (ctxt->nameNr == 0) {
11182 ctxt->instate = XML_PARSER_EPILOG;
11184 ctxt->instate = XML_PARSER_CONTENT;
11194 base = xmlParseLookupSequence(ctxt, ']', ']', '>');
11199 tmp = xmlCheckCdataPush(ctxt->input->cur,
11203 ctxt->input->cur += tmp;
11206 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
11207 if (ctxt->sax->cdataBlock != NULL)
11208 ctxt->sax->cdataBlock(ctxt->userData,
11209 ctxt->input->cur, tmp);
11210 else if (ctxt->sax->characters != NULL)
11211 ctxt->sax->characters(ctxt->userData,
11212 ctxt->input->cur, tmp);
11215 ctxt->checkIndex = 0;
11221 tmp = xmlCheckCdataPush(ctxt->input->cur, base);
11224 ctxt->input->cur += tmp;
11227 if ((ctxt->sax != NULL) && (base == 0) &&
11228 (ctxt->sax->cdataBlock != NULL) &&
11229 (!ctxt->disableSAX)) {
11235 if ((ctxt->input->cur - ctxt->input->base >= 9) &&
11236 (!strncmp((const char *)&ctxt->input->cur[-9],
11238 ctxt->sax->cdataBlock(ctxt->userData,
11240 } else if ((ctxt->sax != NULL) && (base > 0) &&
11241 (!ctxt->disableSAX)) {
11242 if (ctxt->sax->cdataBlock != NULL)
11243 ctxt->sax->cdataBlock(ctxt->userData,
11244 ctxt->input->cur, base);
11245 else if (ctxt->sax->characters != NULL)
11246 ctxt->sax->characters(ctxt->userData,
11247 ctxt->input->cur, base);
11250 ctxt->checkIndex = 0;
11251 ctxt->instate = XML_PARSER_CONTENT;
11261 if (ctxt->input->buf == NULL)
11262 avail = ctxt->input->length -
11263 (ctxt->input->cur - ctxt->input->base);
11265 avail = ctxt->input->buf->buffer->use -
11266 (ctxt->input->cur - ctxt->input->base);
11269 cur = ctxt->input->cur[0];
11270 next = ctxt->input->cur[1];
11273 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11279 xmlParsePI(ctxt);
11280 ctxt->checkIndex = 0;
11282 (ctxt->input->cur[2] == '-') &&
11283 (ctxt->input->cur[3] == '-')) {
11285 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
11291 xmlParseComment(ctxt);
11292 ctxt->instate = XML_PARSER_MISC;
11293 ctxt->checkIndex = 0;
11295 (ctxt->input->cur[2] == 'D') &&
11296 (ctxt->input->cur[3] == 'O') &&
11297 (ctxt->input->cur[4] == 'C') &&
11298 (ctxt->input->cur[5] == 'T') &&
11299 (ctxt->input->cur[6] == 'Y') &&
11300 (ctxt->input->cur[7] == 'P') &&
11301 (ctxt->input->cur[8] == 'E')) {
11303 (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0))
11309 ctxt->inSubset = 1;
11310 xmlParseDocTypeDecl(ctxt);
11312 ctxt->instate = XML_PARSER_DTD;
11321 ctxt->inSubset = 2;
11322 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11323 (ctxt->sax->externalSubset != NULL))
11324 ctxt->sax->externalSubset(ctxt->userData,
11325 ctxt->intSubName, ctxt->extSubSystem,
11326 ctxt->extSubURI);
11327 ctxt->inSubset = 0;
11328 xmlCleanSpecialAttr(ctxt);
11329 ctxt->instate = XML_PARSER_PROLOG;
11339 ctxt->instate = XML_PARSER_START_TAG;
11340 ctxt->progressive = 1;
11341 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11350 if (ctxt->input->buf == NULL)
11351 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
11353 avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
11356 cur = ctxt->input->cur[0];
11357 next = ctxt->input->cur[1];
11360 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11366 xmlParsePI(ctxt);
11368 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
11370 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
11376 xmlParseComment(ctxt);
11377 ctxt->instate = XML_PARSER_PROLOG;
11382 ctxt->instate = XML_PARSER_START_TAG;
11383 if (ctxt->progressive == 0)
11384 ctxt->progressive = 1;
11385 xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11394 if (ctxt->input->buf == NULL)
11395 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
11397 avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
11400 cur = ctxt->input->cur[0];
11401 next = ctxt->input->cur[1];
11404 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11410 xmlParsePI(ctxt);
11411 ctxt->instate = XML_PARSER_EPILOG;
11413 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
11415 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
11421 xmlParseComment(ctxt);
11422 ctxt->instate = XML_PARSER_EPILOG;
11427 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
11428 ctxt->instate = XML_PARSER_EOF;
11433 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11434 ctxt->sax->endDocument(ctxt->userData);
11453 base = ctxt->input->cur - ctxt->input->base;
11455 if (ctxt->checkIndex > base)
11456 base = ctxt->checkIndex;
11457 buf = ctxt->input->buf->buffer->content;
11458 for (;(unsigned int) base < ctxt->input->buf->buffer->use;
11469 ctxt->input->buf->buffer->use) &&
11474 ctxt->input->buf->buffer->use; base++) {
11506 ctxt->input->buf->buffer->use)
11514 (unsigned int) base + i < ctxt->input->buf->buffer->use;
11549 xmlParseInternalSubset(ctxt);
11550 ctxt->inSubset = 2;
11551 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11552 (ctxt->sax->externalSubset != NULL))
11553 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
11554 ctxt->extSubSystem, ctxt->extSubURI);
11555 ctxt->inSubset = 0;
11556 xmlCleanSpecialAttr(ctxt);
11557 ctxt->instate = XML_PARSER_PROLOG;
11558 ctxt->checkIndex = 0;
11568 ctxt->instate = XML_PARSER_CONTENT;
11577 ctxt->instate = XML_PARSER_DTD;
11586 ctxt->instate = XML_PARSER_CONTENT;
11595 ctxt->instate = XML_PARSER_DTD;
11604 ctxt->instate = XML_PARSER_CONTENT;
11613 ctxt->instate = XML_PARSER_START_TAG;
11622 ctxt->instate = XML_PARSER_START_TAG;
11631 ctxt->instate = XML_PARSER_START_TAG;
11649 ctxt->input->cur[0], ctxt->input->cur[1],
11650 ctxt->input->cur[2], ctxt->input->cur[3]);
11651 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
11660 * @ctxt: an XML parser context
11670 xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
11675 if (ctxt == NULL)
11677 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
11678 return(ctxt->errNo);
11679 if (ctxt->instate == XML_PARSER_START)
11680 xmlDetectSAX2(ctxt);
11689 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
11690 (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF)) {
11691 int base = ctxt->input->base - ctxt->input->buf->buffer->content;
11692 int cur = ctxt->input->cur - ctxt->input->base;
11700 if ((ctxt->instate == XML_PARSER_START) && (ctxt->input != NULL) &&
11701 (ctxt->input->buf != NULL) && (ctxt->input->buf->encoder != NULL)) {
11704 if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
11706 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
11709 else if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
11711 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
11715 if (ctxt->input->buf->rawconsumed < len)
11716 len -= ctxt->input->buf->rawconsumed;
11730 res =xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
11732 ctxt->errNo = XML_PARSER_EOF;
11733 ctxt->disableSAX = 1;
11736 ctxt->input->base = ctxt->input->buf->buffer->content + base;
11737 ctxt->input->cur = ctxt->input->base + cur;
11738 ctxt->input->end =
11739 &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
11744 } else if (ctxt->instate != XML_PARSER_EOF) {
11745 if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
11746 xmlParserInputBufferPtr in = ctxt->input->buf;
11762 xmlParseTryOrFinish(ctxt, 0);
11764 xmlParseTryOrFinish(ctxt, terminate);
11765 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
11766 return(ctxt->errNo);
11774 if ((end_in_lf == 1) && (ctxt->input != NULL) &&
11775 (ctxt->input->buf != NULL)) {
11776 xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
11784 if (ctxt->input != NULL) {
11785 if (ctxt->input->buf == NULL)
11786 avail = ctxt->input->length -
11787 (ctxt->input->cur - ctxt->input->base);
11789 avail = ctxt->input->buf->buffer->use -
11790 (ctxt->input->cur - ctxt->input->base);
11793 if ((ctxt->instate != XML_PARSER_EOF) &&
11794 (ctxt->instate != XML_PARSER_EPILOG)) {
11795 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
11797 if ((ctxt->instate == XML_PARSER_EPILOG) && (avail > 0)) {
11798 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
11800 if (ctxt->instate != XML_PARSER_EOF) {
11801 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11802 ctxt->sax->endDocument(ctxt->userData);
11804 ctxt->instate = XML_PARSER_EOF;
11806 return((xmlParserErrors) ctxt->errNo);
11837 xmlParserCtxtPtr ctxt;
11851 ctxt = xmlNewParserCtxt();
11852 if (ctxt == NULL) {
11857 ctxt->dictNames = 1;
11858 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * sizeof(xmlChar *));
11859 if (ctxt->pushTab == NULL) {
11860 xmlErrMemory(ctxt, NULL);
11862 xmlFreeParserCtxt(ctxt);
11867 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
11869 xmlFree(ctxt->sax);
11870 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
11871 if (ctxt->sax == NULL) {
11872 xmlErrMemory(ctxt, NULL);
11874 xmlFreeParserCtxt(ctxt);
11877 memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
11879 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
11881 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
11883 ctxt->userData = user_data;
11886 ctxt->directory = NULL;
11888 ctxt->directory = xmlParserGetDirectory(filename);
11891 inputStream = xmlNewInputStream(ctxt);
11893 xmlFreeParserCtxt(ctxt);
11904 xmlFreeParserCtxt(ctxt);
11915 inputPush(ctxt, inputStream);
11923 ctxt->charset = XML_CHAR_ENCODING_NONE;
11924 } else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) {
11925 int base = ctxt->input->base - ctxt->input->buf->buffer->content;
11926 int cur = ctxt->input->cur - ctxt->input->base;
11928 xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
11930 ctxt->input->base = ctxt->input->buf->buffer->content + base;
11931 ctxt->input->cur = ctxt->input->base + cur;
11932 ctxt->input->end =
11933 &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
11940 xmlSwitchEncoding(ctxt, enc);
11943 return(ctxt);
11949 * @ctxt: an XML parser context
11954 xmlStopParser(xmlParserCtxtPtr ctxt) {
11955 if (ctxt == NULL)
11957 ctxt->instate = XML_PARSER_EOF;
11958 ctxt->disableSAX = 1;
11959 if (ctxt->input != NULL) {
11960 ctxt->input->cur = BAD_CAST"";
11961 ctxt->input->base = ctxt->input->cur;
11983 xmlParserCtxtPtr ctxt;
11992 ctxt = xmlNewParserCtxt();
11993 if (ctxt == NULL) {
11999 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12001 xmlFree(ctxt->sax);
12002 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
12003 if (ctxt->sax == NULL) {
12004 xmlErrMemory(ctxt, NULL);
12005 xmlFreeParserCtxt(ctxt);
12008 memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
12010 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
12012 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12014 ctxt->userData = user_data;
12017 inputStream = xmlNewIOInputStream(ctxt, buf, enc);
12019 xmlFreeParserCtxt(ctxt);
12022 inputPush(ctxt, inputStream);
12024 return(ctxt);
12050 xmlParserCtxtPtr ctxt;
12057 ctxt = xmlNewParserCtxt();
12058 if (ctxt == NULL) {
12067 if (ctxt->sax != NULL)
12068 xmlFree(ctxt->sax);
12069 ctxt->sax = sax;
12070 ctxt->userData = ctxt;
12072 xmlDetectSAX2(ctxt);
12078 pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
12080 if (sax != NULL) ctxt->sax = NULL;
12082 xmlFreeParserCtxt(ctxt);
12089 if (xmlPushInput(ctxt, pinput) < 0) {
12090 if (sax != NULL) ctxt->sax = NULL;
12091 xmlFreeParserCtxt(ctxt);
12095 xmlSwitchEncoding(ctxt, enc);
12101 pinput->base = ctxt->input->cur;
12102 pinput->cur = ctxt->input->cur;
12108 ctxt->inSubset = 2;
12109 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
12110 if (ctxt->myDoc == NULL) {
12111 xmlErrMemory(ctxt, "New Doc failed");
12114 ctxt->myDoc->properties = XML_DOC_INTERNAL;
12115 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
12119 ((ctxt->input->end - ctxt->input->cur) >= 4)) {
12131 xmlSwitchEncoding(ctxt, enc);
12135 xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
12137 if (ctxt->myDoc != NULL) {
12138 if (ctxt->wellFormed) {
12139 ret = ctxt->myDoc->extSubset;
12140 ctxt->myDoc->extSubset = NULL;
12154 xmlFreeDoc(ctxt->myDoc);
12155 ctxt->myDoc = NULL;
12157 if (sax != NULL) ctxt->sax = NULL;
12158 xmlFreeParserCtxt(ctxt);
12178 xmlParserCtxtPtr ctxt;
12185 ctxt = xmlNewParserCtxt();
12186 if (ctxt == NULL) {
12194 if (ctxt->sax != NULL)
12195 xmlFree(ctxt->sax);
12196 ctxt->sax = sax;
12197 ctxt->userData = ctxt;
12205 xmlFreeParserCtxt(ctxt);
12213 if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
12214 input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
12217 if (sax != NULL) ctxt->sax = NULL;
12218 xmlFreeParserCtxt(ctxt);
12227 if (xmlPushInput(ctxt, input) < 0) {
12228 if (sax != NULL) ctxt->sax = NULL;
12229 xmlFreeParserCtxt(ctxt);
12234 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
12235 enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
12236 xmlSwitchEncoding(ctxt, enc);
12245 input->base = ctxt->input->cur;
12246 input->cur = ctxt->input->cur;
12252 ctxt->inSubset = 2;
12253 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
12254 if (ctxt->myDoc == NULL) {
12255 xmlErrMemory(ctxt, "New Doc failed");
12256 if (sax != NULL) ctxt->sax = NULL;
12257 xmlFreeParserCtxt(ctxt);
12260 ctxt->myDoc->properties = XML_DOC_INTERNAL;
12261 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
12263 xmlParseExternalSubset(ctxt, ExternalID, SystemID);
12265 if (ctxt->myDoc != NULL) {
12266 if (ctxt->wellFormed) {
12267 ret = ctxt->myDoc->extSubset;
12268 ctxt->myDoc->extSubset = NULL;
12282 xmlFreeDoc(ctxt->myDoc);
12283 ctxt->myDoc = NULL;
12285 if (sax != NULL) ctxt->sax = NULL;
12286 xmlFreeParserCtxt(ctxt);
12334 xmlParserCtxtPtr ctxt;
12356 ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, ctx);
12357 if (ctxt == NULL) {
12361 oldsax = ctxt->sax;
12362 ctxt->sax = ctx->sax;
12363 xmlDetectSAX2(ctxt);
12366 xmlFreeParserCtxt(ctxt);
12383 ctxt->sax = oldsax;
12384 xmlFreeParserCtxt(ctxt);
12391 nodePush(ctxt, newDoc->children);
12393 ctxt->myDoc = newDoc;
12395 ctxt->myDoc = ctx->myDoc;
12405 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
12412 xmlSwitchEncoding(ctxt, enc);
12420 xmlParseTextDecl(ctxt);
12425 (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) {
12426 xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH,
12434 ctxt->instate = XML_PARSER_CONTENT;
12435 ctxt->validate = ctx->validate;
12436 ctxt->valid = ctx->valid;
12437 ctxt->loadsubset = ctx->loadsubset;
12438 ctxt->depth = ctx->depth + 1;
12439 ctxt->replaceEntities = ctx->replaceEntities;
12440 if (ctxt->validate) {
12441 ctxt->vctxt.error = ctx->vctxt.error;
12442 ctxt->vctxt.warning = ctx->vctxt.warning;
12444 ctxt->vctxt.error = NULL;
12445 ctxt->vctxt.warning = NULL;
12447 ctxt->vctxt.nodeTab = NULL;
12448 ctxt->vctxt.nodeNr = 0;
12449 ctxt->vctxt.nodeMax = 0;
12450 ctxt->vctxt.node = NULL;
12451 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
12452 ctxt->dict = ctx->dict;
12453 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
12454 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
12455 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
12456 ctxt->dictNames = ctx->dictNames;
12457 ctxt->attsDefault = ctx->attsDefault;
12458 ctxt->attsSpecial = ctx->attsSpecial;
12459 ctxt->linenumbers = ctx->linenumbers;
12461 xmlParseContent(ctxt);
12463 ctx->validate = ctxt->validate;
12464 ctx->valid = ctxt->valid;
12466 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12468 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12470 if (ctxt->node != newDoc->children) {
12471 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12474 if (!ctxt->wellFormed) {
12475 if (ctxt->errNo == 0)
12478 ret = ctxt->errNo;
12497 ctxt->sax = oldsax;
12498 ctxt->dict = NULL;
12499 ctxt->attsDefault = NULL;
12500 ctxt->attsSpecial = NULL;
12501 xmlFreeParserCtxt(ctxt);
12531 xmlParserCtxtPtr ctxt;
12553 ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, oldctxt);
12554 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
12555 ctxt->userData = ctxt;
12557 ctxt->_private = oldctxt->_private;
12558 ctxt->loadsubset = oldctxt->loadsubset;
12559 ctxt->validate = oldctxt->validate;
12560 ctxt->external = oldctxt->external;
12561 ctxt->record_info = oldctxt->record_info;
12562 ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
12563 ctxt->node_seq.length = oldctxt->node_seq.length;
12564 ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
12570 ctxt->_private = NULL;
12571 ctxt->validate = 0;
12572 ctxt->external = 2;
12573 ctxt->loadsubset = 0;
12576 oldsax = ctxt->sax;
12577 ctxt->sax = sax;
12579 ctxt->userData = user_data;
12581 xmlDetectSAX2(ctxt);
12584 ctxt->node_seq.maximum = 0;
12585 ctxt->node_seq.length = 0;
12586 ctxt->node_seq.buffer = NULL;
12587 xmlFreeParserCtxt(ctxt);
12602 ctxt->sax = oldsax;
12603 ctxt->node_seq.maximum = 0;
12604 ctxt->node_seq.length = 0;
12605 ctxt->node_seq.buffer = NULL;
12606 xmlFreeParserCtxt(ctxt);
12613 nodePush(ctxt, newDoc->children);
12614 ctxt->myDoc = doc;
12623 if ((ctxt->input->end - ctxt->input->cur) >= 4) {
12630 xmlSwitchEncoding(ctxt, enc);
12638 xmlParseTextDecl(ctxt);
12641 ctxt->instate = XML_PARSER_CONTENT;
12642 ctxt->depth = depth;
12644 xmlParseContent(ctxt);
12647 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12649 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12651 if (ctxt->node != newDoc->children) {
12652 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12655 if (!ctxt->wellFormed) {
12656 if (ctxt->errNo == 0)
12659 ret = (xmlParserErrors)ctxt->errNo;
12684 oldctxt->nbentities += ctxt->nbentities;
12689 if (ctxt->input != NULL) {
12690 oldctxt->sizeentities += ctxt->input->consumed;
12691 oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base);
12696 if (ctxt->lastError.code != XML_ERR_OK)
12697 xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
12700 ctxt->sax = oldsax;
12701 oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
12702 oldctxt->node_seq.length = ctxt->node_seq.length;
12703 oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
12704 ctxt->node_seq.maximum = 0;
12705 ctxt->node_seq.length = 0;
12706 ctxt->node_seq.buffer = NULL;
12707 xmlFreeParserCtxt(ctxt);
12795 xmlParserCtxtPtr ctxt;
12820 ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
12821 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
12823 ctxt->userData = user_data;
12825 ctxt->userData = ctxt;
12826 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
12827 ctxt->dict = oldctxt->dict;
12828 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
12829 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
12830 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
12835 nsPush(ctxt, oldctxt->nsTab[i], oldctxt->nsTab[i+1]);
12839 oldsax = ctxt->sax;
12840 ctxt->sax = oldctxt->sax;
12841 xmlDetectSAX2(ctxt);
12842 ctxt->replaceEntities = oldctxt->replaceEntities;
12843 ctxt->options = oldctxt->options;
12845 ctxt->_private = oldctxt->_private;
12849 ctxt->sax = oldsax;
12850 ctxt->dict = NULL;
12851 xmlFreeParserCtxt(ctxt);
12855 newDoc->dict = ctxt->dict;
12857 ctxt->myDoc = newDoc;
12859 ctxt->myDoc = oldctxt->myDoc;
12860 content = ctxt->myDoc->children;
12861 last = ctxt->myDoc->last;
12863 newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
12865 ctxt->sax = oldsax;
12866 ctxt->dict = NULL;
12867 xmlFreeParserCtxt(ctxt);
12873 ctxt->myDoc->children = NULL;
12874 ctxt->myDoc->last = NULL;
12875 xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
12876 nodePush(ctxt, ctxt->myDoc->children);
12877 ctxt->instate = XML_PARSER_CONTENT;
12878 ctxt->depth = oldctxt->depth + 1;
12880 ctxt->validate = 0;
12881 ctxt->loadsubset = oldctxt->loadsubset;
12886 ctxt->loadsubset |= XML_SKIP_IDS;
12888 ctxt->dictNames = oldctxt->dictNames;
12889 ctxt->attsDefault = oldctxt->attsDefault;
12890 ctxt->attsSpecial = oldctxt->attsSpecial;
12892 xmlParseContent(ctxt);
12894 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12896 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12898 if (ctxt->node != ctxt->myDoc->children) {
12899 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12902 if (!ctxt->wellFormed) {
12903 if (ctxt->errNo == 0)
12906 ret = (xmlParserErrors)ctxt->errNo;
12918 cur = ctxt->myDoc->children->children;
12932 ctxt->myDoc->children->children = NULL;
12934 if (ctxt->myDoc != NULL) {
12935 xmlFreeNode(ctxt->myDoc->children);
12936 ctxt->myDoc->children = content;
12937 ctxt->myDoc->last = last;
12945 oldctxt->nbentities += ctxt->nbentities;
12950 if (ctxt->lastError.code != XML_ERR_OK)
12951 xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
12953 ctxt->sax = oldsax;
12954 ctxt->dict = NULL;
12955 ctxt->attsDefault = NULL;
12956 ctxt->attsSpecial = NULL;
12957 xmlFreeParserCtxt(ctxt);
12988 xmlParserCtxtPtr ctxt;
13033 ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
13036 ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
13047 if (ctxt == NULL)
13056 if (ctxt->dict != NULL)
13057 xmlDictFree(ctxt->dict);
13058 ctxt->dict = doc->dict;
13065 if (ctxt->encoding != NULL)
13066 xmlFree((xmlChar *) ctxt->encoding);
13067 ctxt->encoding = xmlStrdup((const xmlChar *) doc->encoding);
13071 xmlSwitchToEncoding(ctxt, hdlr);
13077 xmlCtxtUseOptionsInternal(ctxt, options, NULL);
13078 xmlDetectSAX2(ctxt);
13079 ctxt->myDoc = doc;
13083 xmlFreeParserCtxt(ctxt);
13089 nodePush(ctxt, node);
13099 if (ctxt->dict) {
13100 iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
13101 ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
13107 if (xmlGetNamespace(ctxt, iprefix) == NULL) {
13108 nsPush(ctxt, iprefix, ihref);
13115 ctxt->instate = XML_PARSER_CONTENT;
13118 if ((ctxt->validate) || (ctxt->replaceEntities != 0)) {
13122 ctxt->loadsubset |= XML_SKIP_IDS;
13127 __htmlParseContent(ctxt);
13130 xmlParseContent(ctxt);
13132 nsPop(ctxt, nsnr);
13134 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13136 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13138 if ((ctxt->node != NULL) && (ctxt->node != node)) {
13139 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13140 ctxt->wellFormed = 0;
13143 if (!ctxt->wellFormed) {
13144 if (ctxt->errNo == 0)
13147 ret = (xmlParserErrors)ctxt->errNo;
13182 ctxt->dict = NULL;
13183 xmlFreeParserCtxt(ctxt);
13221 xmlParserCtxtPtr ctxt;
13240 ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
13241 if (ctxt == NULL) return(-1);
13242 ctxt->userData = ctxt;
13244 oldsax = ctxt->sax;
13245 ctxt->sax = sax;
13247 ctxt->userData = user_data;
13251 xmlFreeParserCtxt(ctxt);
13256 xmlDictFree(ctxt->dict);
13257 ctxt->dict = doc->dict;
13258 xmlDictReference(ctxt->dict);
13259 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
13260 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
13261 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
13262 ctxt->dictNames = 1;
13264 xmlCtxtUseOptionsInternal(ctxt, XML_PARSE_NODICT, NULL);
13273 ctxt->sax = oldsax;
13274 xmlFreeParserCtxt(ctxt);
13281 nodePush(ctxt, newRoot);
13283 ctxt->myDoc = newDoc;
13285 ctxt->myDoc = newDoc;
13291 ctxt->instate = XML_PARSER_CONTENT;
13292 ctxt->depth = depth;
13297 ctxt->validate = 0;
13298 ctxt->loadsubset = 0;
13299 xmlDetectSAX2(ctxt);
13304 xmlParseContent(ctxt);
13308 xmlParseContent(ctxt);
13311 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13313 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13315 if (ctxt->node != newDoc->children) {
13316 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13319 if (!ctxt->wellFormed) {
13320 if (ctxt->errNo == 0)
13323 ret = ctxt->errNo;
13346 ctxt->sax = oldsax;
13347 xmlFreeParserCtxt(ctxt);
13375 xmlParserCtxtPtr ctxt;
13377 ctxt = xmlCreateFileParserCtxt(filename);
13378 if (ctxt == NULL) {
13382 if (ctxt->sax != NULL)
13383 xmlFree(ctxt->sax);
13384 ctxt->sax = sax;
13385 ctxt->userData = NULL;
13388 xmlParseExtParsedEnt(ctxt);
13390 if (ctxt->wellFormed)
13391 ret = ctxt->myDoc;
13394 xmlFreeDoc(ctxt->myDoc);
13395 ctxt->myDoc = NULL;
13398 ctxt->sax = NULL;
13399 xmlFreeParserCtxt(ctxt);
13439 xmlParserCtxtPtr ctxt;
13444 ctxt = xmlNewParserCtxt();
13445 if (ctxt == NULL) {
13450 ctxt->options = pctx->options;
13451 ctxt->_private = pctx->_private;
13457 inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
13459 xmlFreeParserCtxt(ctxt);
13463 inputPush(ctxt, inputStream);
13465 if ((ctxt->directory == NULL) && (directory == NULL))
13467 if ((ctxt->directory == NULL) && (directory != NULL))
13468 ctxt->directory = directory;
13470 inputStream = xmlLoadExternalEntity((char *)uri, (char *)ID, ctxt);
13473 xmlFreeParserCtxt(ctxt);
13477 inputPush(ctxt, inputStream);
13479 if ((ctxt->directory == NULL) && (directory == NULL))
13481 if ((ctxt->directory == NULL) && (directory != NULL))
13482 ctxt->directory = directory;
13485 return(ctxt);
13527 xmlParserCtxtPtr ctxt;
13531 ctxt = xmlNewParserCtxt();
13532 if (ctxt == NULL) {
13538 xmlCtxtUseOptionsInternal(ctxt, options, NULL);
13539 ctxt->linenumbers = 1;
13541 inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
13543 xmlFreeParserCtxt(ctxt);
13547 inputPush(ctxt, inputStream);
13548 if ((ctxt->directory == NULL) && (directory == NULL))
13550 if ((ctxt->directory == NULL) && (directory != NULL))
13551 ctxt->directory = directory;
13553 return(ctxt);
13596 xmlParserCtxtPtr ctxt;
13600 ctxt = xmlCreateFileParserCtxt(filename);
13601 if (ctxt == NULL) {
13605 if (ctxt->sax != NULL)
13606 xmlFree(ctxt->sax);
13607 ctxt->sax = sax;
13609 xmlDetectSAX2(ctxt);
13611 ctxt->_private = data;
13614 if (ctxt->directory == NULL)
13615 ctxt->directory = xmlParserGetDirectory(filename);
13617 ctxt->recovery = recovery;
13619 xmlParseDocument(ctxt);
13621 if ((ctxt->wellFormed) || recovery) {
13622 ret = ctxt->myDoc;
13624 if (ctxt->input->buf->compressed > 0)
13627 ret->compression = ctxt->input->buf->compressed;
13632 xmlFreeDoc(ctxt->myDoc);
13633 ctxt->myDoc = NULL;
13636 ctxt->sax = NULL;
13637 xmlFreeParserCtxt(ctxt);
13715 * @ctxt: an XML parser context
13724 xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
13729 if ((ctxt == NULL) || (buffer == NULL))
13732 input = xmlNewInputStream(ctxt);
13735 xmlClearParserCtxt(ctxt);
13739 xmlClearParserCtxt(ctxt);
13745 inputPush(ctxt, input);
13763 xmlParserCtxtPtr ctxt;
13765 ctxt = xmlCreateFileParserCtxt(filename);
13766 if (ctxt == NULL) return -1;
13767 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
13768 xmlFree(ctxt->sax);
13769 ctxt->sax = sax;
13770 xmlDetectSAX2(ctxt);
13773 ctxt->userData = user_data;
13775 xmlParseDocument(ctxt);
13777 if (ctxt->wellFormed)
13780 if (ctxt->errNo != 0)
13781 ret = ctxt->errNo;
13786 ctxt->sax = NULL;
13787 if (ctxt->myDoc != NULL) {
13788 xmlFreeDoc(ctxt->myDoc);
13789 ctxt->myDoc = NULL;
13791 xmlFreeParserCtxt(ctxt);
13814 xmlParserCtxtPtr ctxt;
13823 ctxt = xmlNewParserCtxt();
13824 if (ctxt == NULL)
13830 xmlFreeParserCtxt(ctxt);
13834 input = xmlNewInputStream(ctxt);
13837 xmlFreeParserCtxt(ctxt);
13847 inputPush(ctxt, input);
13848 return(ctxt);
13875 xmlParserCtxtPtr ctxt;
13879 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
13880 if (ctxt == NULL) return(NULL);
13882 if (ctxt->sax != NULL)
13883 xmlFree(ctxt->sax);
13884 ctxt->sax = sax;
13886 xmlDetectSAX2(ctxt);
13888 ctxt->_private=data;
13891 ctxt->recovery = recovery;
13893 xmlParseDocument(ctxt);
13895 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
13898 xmlFreeDoc(ctxt->myDoc);
13899 ctxt->myDoc = NULL;
13902 ctxt->sax = NULL;
13903 xmlFreeParserCtxt(ctxt);
13973 xmlParserCtxtPtr ctxt;
13977 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
13978 if (ctxt == NULL) return -1;
13979 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
13980 xmlFree(ctxt->sax);
13981 ctxt->sax = sax;
13982 xmlDetectSAX2(ctxt);
13985 ctxt->userData = user_data;
13987 xmlParseDocument(ctxt);
13989 if (ctxt->wellFormed)
13992 if (ctxt->errNo != 0)
13993 ret = ctxt->errNo;
13998 ctxt->sax = NULL;
13999 if (ctxt->myDoc != NULL) {
14000 xmlFreeDoc(ctxt->myDoc);
14001 ctxt->myDoc = NULL;
14003 xmlFreeParserCtxt(ctxt);
14045 xmlParserCtxtPtr ctxt;
14051 ctxt = xmlCreateDocParserCtxt(cur);
14052 if (ctxt == NULL) return(NULL);
14054 oldsax = ctxt->sax;
14055 ctxt->sax = sax;
14056 ctxt->userData = NULL;
14058 xmlDetectSAX2(ctxt);
14060 xmlParseDocument(ctxt);
14061 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
14064 xmlFreeDoc(ctxt->myDoc);
14065 ctxt->myDoc = NULL;
14068 ctxt->sax = oldsax;
14069 xmlFreeParserCtxt(ctxt);
14253 * @ctxt: an XML parser context
14258 xmlCtxtReset(xmlParserCtxtPtr ctxt)
14263 if (ctxt == NULL)
14266 dict = ctxt->dict;
14268 while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
14271 ctxt->inputNr = 0;
14272 ctxt->input = NULL;
14274 ctxt->spaceNr = 0;
14275 if (ctxt->spaceTab != NULL) {
14276 ctxt->spaceTab[0] = -1;
14277 ctxt->space = &ctxt
14279 ctxt->space = NULL;
14283 ctxt->nodeNr = 0;
14284 ctxt->node = NULL;
14286 ctxt->nameNr = 0;
14287 ctxt->name = NULL;
14289 DICT_FREE(ctxt->version);
14290 ctxt->version = NULL;
14291 DICT_FREE(ctxt->encoding);
14292 ctxt->encoding = NULL;
14293 DICT_FREE(ctxt->directory);
14294 ctxt->directory = NULL;
14295 DICT_FREE(ctxt->extSubURI);
14296 ctxt->extSubURI = NULL;
14297 DICT_FREE(ctxt->extSubSystem);
14298 ctxt->extSubSystem = NULL;
14299 if (ctxt->myDoc != NULL)
14300 xmlFreeDoc(ctxt->myDoc);
14301 ctxt->myDoc = NULL;
14303 ctxt->standalone = -1;
14304 ctxt->hasExternalSubset = 0;
14305 ctxt->hasPErefs = 0;
14306 ctxt->html = 0;
14307 ctxt->external = 0;
14308 ctxt->instate = XML_PARSER_START;
14309 ctxt->token = 0;
14311 ctxt->wellFormed = 1;
14312 ctxt->nsWellFormed = 1;
14313 ctxt->disableSAX = 0;
14314 ctxt->valid = 1;
14316 ctxt->vctxt.userData = ctxt;
14317 ctxt->vctxt.error = xmlParserValidityError;
14318 ctxt->vctxt.warning = xmlParserValidityWarning;
14320 ctxt->record_info = 0;
14321 ctxt->nbChars = 0;
14322 ctxt->checkIndex = 0;
14323 ctxt->inSubset = 0;
14324 ctxt->errNo = XML_ERR_OK;
14325 ctxt->depth = 0;
14326 ctxt->charset = XML_CHAR_ENCODING_UTF8;
14327 ctxt->catalogs = NULL;
14328 ctxt->nbentities = 0;
14329 ctxt->sizeentities = 0;
14330 xmlInitNodeInfoSeq(&ctxt->node_seq);
14332 if (ctxt->attsDefault != NULL) {
14333 xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
14334 ctxt->attsDefault = NULL;
14336 if (ctxt->attsSpecial != NULL) {
14337 xmlHashFree(ctxt->attsSpecial, NULL);
14338 ctxt->attsSpecial = NULL;
14342 if (ctxt->catalogs != NULL)
14343 xmlCatalogFreeLocal(ctxt->catalogs);
14345 if (ctxt->lastError.code != XML_ERR_OK)
14346 xmlResetError(&ctxt->lastError);
14351 * @ctxt: an XML parser context
14362 xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
14369 if (ctxt == NULL)
14379 if (ctxt == NULL) {
14384 xmlCtxtReset(ctxt);
14386 if (ctxt->pushTab == NULL) {
14387 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 *
14389 if (ctxt->pushTab == NULL) {
14390 xmlErrMemory(ctxt, NULL);
14397 ctxt->directory = NULL;
14399 ctxt->directory = xmlParserGetDirectory(filename);
14402 inputStream = xmlNewInputStream(ctxt);
14419 inputPush(ctxt, inputStream);
14421 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
14422 (ctxt->input->buf != NULL)) {
14423 int base = ctxt->input->base - ctxt->input->buf->buffer->content;
14424 int cur = ctxt->input->cur - ctxt->input->base;
14426 xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
14428 ctxt->input->base = ctxt->input->buf->buffer->content + base;
14429 ctxt->input->cur = ctxt->input->base + cur;
14430 ctxt->input->end =
14431 &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->
14441 if (ctxt->encoding != NULL)
14442 xmlFree((xmlChar *) ctxt->encoding);
14443 ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
14447 xmlSwitchToEncoding(ctxt, hdlr);
14449 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
14453 xmlSwitchEncoding(ctxt, enc);
14462 * @ctxt: an XML parser context
14472 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, const char *encoding)
14474 if (ctxt == NULL)
14477 if (ctxt->encoding != NULL)
14478 xmlFree((xmlChar *) ctxt->encoding);
14479 ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
14482 ctxt->recovery = 1;
14484 ctxt->options |= XML_PARSE_RECOVER;
14486 ctxt->recovery = 0;
14488 ctxt->loadsubset = XML_DETECT_IDS;
14490 ctxt->options |= XML_PARSE_DTDLOAD;
14492 ctxt->loadsubset = 0;
14494 ctxt->loadsubset |= XML_COMPLETE_ATTRS;
14496 ctxt->options |= XML_PARSE_DTDATTR;
14499 ctxt->replaceEntities = 1;
14500 /* ctxt->loadsubset |= XML_DETECT_IDS; */
14502 ctxt->options |= XML_PARSE_NOENT;
14504 ctxt->replaceEntities = 0;
14506 ctxt->pedantic = 1;
14508 ctxt->options |= XML_PARSE_PEDANTIC;
14510 ctxt->pedantic = 0;
14512 ctxt->keepBlanks = 0;
14513 ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
14515 ctxt->options |= XML_PARSE_NOBLANKS;
14517 ctxt->keepBlanks = 1;
14519 ctxt->validate = 1;
14521 ctxt->vctxt.warning = NULL;
14523 ctxt->vctxt.error = NULL;
14525 ctxt->options |= XML_PARSE_DTDVALID;
14527 ctxt->validate = 0;
14529 ctxt->sax->warning = NULL;
14533 ctxt->sax->error = NULL;
14534 ctxt->sax->fatalError = NULL;
14539 ctxt->sax->startElement = xmlSAX2StartElement;
14540 ctxt->sax->endElement = xmlSAX2EndElement;
14541 ctxt->sax->startElementNs = NULL;
14542 ctxt->sax->endElementNs = NULL;
14543 ctxt->sax->initialized = 1;
14545 ctxt->options |= XML_PARSE_SAX1;
14549 ctxt->dictNames = 0;
14551 ctxt->options |= XML_PARSE_NODICT;
14553 ctxt->dictNames = 1;
14556 ctxt->sax->cdataBlock = NULL;
14558 ctxt->options |= XML_PARSE_NOCDATA;
14561 ctxt->options |= XML_PARSE_NSCLEAN;
14565 ctxt->options |= XML_PARSE_NONET;
14569 ctxt->options |= XML_PARSE_COMPACT;
14573 ctxt->options |= XML_PARSE_OLD10;
14577 ctxt->options |= XML_PARSE_NOBASEFIX;
14581 ctxt->options |= XML_PARSE_HUGE;
14585 ctxt->options |= XML_PARSE_OLDSAX;
14589 ctxt->options |= XML_PARSE_IGNORE_ENC;
14592 ctxt->linenumbers = 1;
14598 * @ctxt: an XML parser context
14607 xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
14609 return(xmlCtxtUseOptionsInternal(ctxt, options, NULL));
14614 * @ctxt: an XML parser context
14625 xmlDoRead(xmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
14630 xmlCtxtUseOptionsInternal(ctxt, options, encoding);
14636 xmlSwitchToEncoding(ctxt, hdlr);
14638 if ((URL != NULL) && (ctxt->input != NULL) &&
14639 (ctxt->input->filename == NULL))
14640 ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
14641 xmlParseDocument(ctxt);
14642 if ((ctxt->wellFormed) || ctxt->recovery)
14643 ret = ctxt->myDoc;
14646 if (ctxt->myDoc != NULL) {
14647 xmlFreeDoc(ctxt->myDoc);
14650 ctxt->myDoc = NULL;
14652 xmlFreeParserCtxt(ctxt);
14672 xmlParserCtxtPtr ctxt;
14677 ctxt = xmlCreateDocParserCtxt(cur);
14678 if (ctxt == NULL)
14680 return (xmlDoRead(ctxt, URL, encoding, options, 0));
14696 xmlParserCtxtPtr ctxt;
14698 ctxt = xmlCreateURLParserCtxt(filename, options);
14699 if (ctxt == NULL)
14701 return (xmlDoRead(ctxt, NULL, encoding, options, 0));
14719 xmlParserCtxtPtr ctxt;
14721 ctxt = xmlCreateMemoryParserCtxt(buffer, size);
14722 if (ctxt == NULL)
14724 return (xmlDoRead(ctxt, URL, encoding, options, 0));
14743 xmlParserCtxtPtr ctxt;
14754 ctxt = xmlNewParserCtxt();
14755 if (ctxt == NULL) {
14759 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
14762 xmlFreeParserCtxt(ctxt);
14765 inputPush(ctxt, stream);
14766 return (xmlDoRead(ctxt, URL, encoding, options, 0));
14786 xmlParserCtxtPtr ctxt;
14797 ctxt = xmlNewParserCtxt();
14798 if (ctxt == NULL) {
14802 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
14805 xmlFreeParserCtxt(ctxt);
14808 inputPush(ctxt, stream);
14809 return (xmlDoRead(ctxt, URL, encoding, options, 0));
14814 * @ctxt: an XML parser context
14821 * This reuses the existing @ctxt parser context
14826 xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
14833 if (ctxt == NULL)
14836 xmlCtxtReset(ctxt);
14838 stream = xmlNewStringInputStream(ctxt, cur);
14842 inputPush(ctxt, stream);
14843 return (xmlDoRead(ctxt, URL, encoding, options, 1));
14848 * @ctxt: an XML parser context
14854 * This reuses the existing @ctxt parser context
14859 xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
14866 if (ctxt == NULL)
14869 xmlCtxtReset(ctxt);
14871 stream = xmlLoadExternalEntity(filename, NULL, ctxt);
14875 inputPush(ctxt, stream);
14876 return (xmlDoRead(ctxt, NULL, encoding, options, 1));
14881 * @ctxt: an XML parser context
14889 * This reuses the existing @ctxt parser context
14894 xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
14900 if (ctxt == NULL)
14905 xmlCtxtReset(ctxt);
14912 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
14918 inputPush(ctxt, stream);
14919 return (xmlDoRead(ctxt, URL, encoding, options, 1));
14924 * @ctxt: an XML parser context
14931 * This reuses the existing @ctxt parser context
14938 xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
14946 if (ctxt == NULL)
14949 xmlCtxtReset(ctxt);
14956 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
14961 inputPush(ctxt, stream);
14962 return (xmlDoRead(ctxt, URL, encoding, options, 1));
14967 * @ctxt: an XML parser context
14976 * This reuses the existing @ctxt parser context
14981 xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
14991 if (ctxt == NULL)
14994 xmlCtxtReset(ctxt);
15000 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15005 inputPush(ctxt, stream);
15006 return (xmlDoRead(ctxt, URL, encoding, options, 1));
