Lines Matching refs:parser
7 |_| XML parser
242 static void copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key);
305 A parser reuses these structures, maintaining a list of allocated
439 XML_ACCOUNT_DIRECT, /* bytes directly passed to the Expat parser */
463 typedef enum XML_Error PTRCALL Processor(XML_Parser parser, const char *start,
485 static enum XML_Error handleUnknownEncoding(XML_Parser parser,
487 static enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
489 static enum XML_Error initializeEncoding(XML_Parser parser);
490 static enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc,
495 static enum XML_Error processEntity(XML_Parser parser, ENTITY *entity,
497 static enum XML_Error doContent(XML_Parser parser, int startTagLevel,
501 static enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *enc,
506 static enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *enc,
511 static void freeBindings(XML_Parser parser, BINDING *bindings);
512 static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *enc,
516 static enum XML_Error addBinding(XML_Parser parser, PREFIX *prefix,
521 const XML_Char *value, XML_Parser parser);
522 static enum XML_Error storeAttributeValue(XML_Parser parser,
528 appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
531 static ATTRIBUTE_ID *getAttributeId(XML_Parser parser, const ENCODING *enc,
533 static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType);
535 static enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc,
539 static enum XML_Error callStoreEntityValue(XML_Parser parser,
544 static enum XML_Error storeSelfEntityValue(XML_Parser parser, ENTITY *entity);
546 static int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
548 static int reportComment(XML_Parser parser, const ENCODING *enc,
550 static void reportDefault(XML_Parser parser, const ENCODING *enc,
553 static const XML_Char *getContext(XML_Parser parser);
554 static XML_Bool setContext(XML_Parser parser, const XML_Char *context);
567 static NAMED *lookup(XML_Parser parser, HASH_TABLE *table, KEY name,
593 static int FASTCALL nextScaffoldPart(XML_Parser parser);
594 static XML_Content *build_model(XML_Parser parser);
595 static ELEMENT_TYPE *getElementType(XML_Parser parser, const ENCODING *enc,
601 static unsigned long generate_hash_secret_salt(XML_Parser parser);
602 static XML_Bool startParsing(XML_Parser parser);
608 static void parserInit(XML_Parser parser, const XML_Char *encodingName);
624 static void entityTrackingReportStats(XML_Parser parser, ENTITY *entity,
626 static void entityTrackingOnOpen(XML_Parser parser, ENTITY *entity,
628 static void entityTrackingOnClose(XML_Parser parser, ENTITY *entity,
631 static XML_Parser getRootParserOf(XML_Parser parser,
781 #define MALLOC(parser, s) (parser->m_mem.malloc_fcn((s)))
782 #define REALLOC(parser, p, s) (parser->m_mem.realloc_fcn((p), (s)))
783 #define FREE(parser, p) (parser->m_mem.free_fcn((p)))
971 generate_hash_secret_salt(XML_Parser parser) {
973 (void)parser;
1014 get_hash_secret_salt(XML_Parser parser) {
1015 if (parser->m_parentParser != NULL)
1016 return get_hash_secret_salt(parser->m_parentParser);
1017 return parser->m_hash_secret_salt;
1021 callProcessor(XML_Parser parser, const char *start, const char *end,
1025 if (parser->m_reparseDeferralEnabled
1026 && ! parser->m_parsingStatus.finalBuffer) {
1029 const size_t had_before = parser->m_partialTokenBytesBefore;
1032 = EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);
1037 += EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd);
1041 || ((size_t)parser->m_lastBufferRequestSize > available_buffer);
1057 ret = parser->m_processor(parser, *endPtr, end, endPtr);
1061 if (parser->m_parsingStatus.parsing != XML_PARSING) {
1062 parser->m_reenter = XML_FALSE;
1065 if (! parser->m_reenter) {
1069 parser->m_reenter = XML_FALSE;
1077 parser->m_partialTokenBytesBefore = have_now;
1079 parser->m_partialTokenBytesBefore = 0;
1085 static XML_Bool /* only valid for root parser */
1086 startParsing(XML_Parser parser) {
1088 if (parser->m_hash_secret_salt == 0)
1089 parser->m_hash_secret_salt = generate_hash_secret_salt(parser);
1090 if (parser->m_ns) {
1091 /* implicit context only set for root parser, since child
1094 return setContext(parser, implicitContext);
1110 XML_Parser parser;
1114 parser = memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));
1115 if (parser != NULL) {
1116 mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
1123 parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));
1124 if (parser != NULL) {
1125 mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
1132 if (! parser)
1133 return parser;
1135 parser->m_buffer = NULL;
1136 parser->m_bufferLim = NULL;
1138 parser->m_attsSize = INIT_ATTS_SIZE;
1139 parser->m_atts
1140 = (ATTRIBUTE *)MALLOC(parser, parser->m_attsSize * sizeof(ATTRIBUTE));
1141 if (parser->m_atts == NULL) {
1142 FREE(parser, parser);
1146 parser->m_attInfo = (XML_AttrInfo *)MALLOC(
1147 parser, parser->m_attsSize * sizeof(XML_AttrInfo));
1148 if (parser->m_attInfo == NULL) {
1149 FREE(parser, parser->m_atts);
1150 FREE(parser, parser);
1154 parser->m_dataBuf
1155 = (XML_Char *)MALLOC(parser, INIT_DATA_BUF_SIZE * sizeof(XML_Char));
1156 if (parser->m_dataBuf == NULL) {
1157 FREE(parser, parser->m_atts);
1159 FREE(parser, parser->m_attInfo);
1161 FREE(parser, parser);
1164 parser->m_dataBufEnd = parser->m_dataBuf + INIT_DATA_BUF_SIZE;
1167 parser->m_dtd = dtd;
1169 parser->m_dtd = dtdCreate(&parser->m_mem);
1170 if (parser->m_dtd == NULL) {
1171 FREE(parser, parser->m_dataBuf);
1172 FREE(parser, parser->m_atts);
1174 FREE(parser, parser->m_attInfo);
1176 FREE(parser, parser);
1181 parser->m_freeBindingList = NULL;
1182 parser->m_freeTagList = NULL;
1183 parser->m_freeInternalEntities = NULL;
1184 parser->m_freeAttributeEntities = NULL;
1185 parser->m_freeValueEntities = NULL;
1187 parser->m_groupSize = 0;
1188 parser->m_groupConnector = NULL;
1190 parser->m_unknownEncodingHandler = NULL;
1191 parser->m_unknownEncodingHandlerData = NULL;
1193 parser->m_namespaceSeparator = ASCII_EXCL;
1194 parser->m_ns = XML_FALSE;
1195 parser->m_ns_triplets = XML_FALSE;
1197 parser->m_nsAtts = NULL;
1198 parser->m_nsAttsVersion = 0;
1199 parser->m_nsAttsPower = 0;
1201 parser->m_protocolEncodingName = NULL;
1203 poolInit(&parser->m_tempPool, &(parser->m_mem));
1204 poolInit(&parser->m_temp2Pool, &(parser->m_mem));
1205 parserInit(parser, encodingName);
1207 if (encodingName && ! parser->m_protocolEncodingName) {
1210 // destroying parser->m_dtd because the DTD is shared with the parent
1211 // parser and the only guard that keeps XML_ParserFree from destroying
1212 // parser->m_dtd is parser->m_isParamEntity but it will be set to
1214 parser->m_dtd = NULL;
1216 XML_ParserFree(parser);
1221 parser->m_ns = XML_TRUE;
1222 parser->m_internalEncoding = XmlGetInternalEncodingNS();
1223 parser->m_namespaceSeparator = *nameSep;
1225 parser->m_internalEncoding = XmlGetInternalEncoding();
1228 return parser;
1232 parserInit(XML_Parser parser, const XML_Char *encodingName) {
1233 parser->m_processor = prologInitProcessor;
1234 XmlPrologStateInit(&parser->m_prologState);
1236 parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
1238 parser->m_curBase = NULL;
1239 XmlInitEncoding(&parser->m_initEncoding, &parser->m_encoding, 0);
1240 parser->m_userData = NULL;
1241 parser->m_handlerArg = NULL;
1242 parser->m_startElementHandler = NULL;
1243 parser->m_endElementHandler = NULL;
1244 parser->m_characterDataHandler = NULL;
1245 parser->m_processingInstructionHandler = NULL;
1246 parser->m_commentHandler = NULL;
1247 parser->m_startCdataSectionHandler = NULL;
1248 parser->m_endCdataSectionHandler = NULL;
1249 parser->m_defaultHandler = NULL;
1250 parser->m_startDoctypeDeclHandler = NULL;
1251 parser->m_endDoctypeDeclHandler = NULL;
1252 parser->m_unparsedEntityDeclHandler = NULL;
1253 parser->m_notationDeclHandler = NULL;
1254 parser->m_startNamespaceDeclHandler = NULL;
1255 parser->m_endNamespaceDeclHandler = NULL;
1256 parser->m_notStandaloneHandler = NULL;
1257 parser->m_externalEntityRefHandler = NULL;
1258 parser->m_externalEntityRefHandlerArg = parser;
1259 parser->m_skippedEntityHandler = NULL;
1260 parser->m_elementDeclHandler = NULL;
1261 parser->m_attlistDeclHandler = NULL;
1262 parser->m_entityDeclHandler = NULL;
1263 parser->m_xmlDeclHandler = NULL;
1264 parser->m_bufferPtr = parser->m_buffer;
1265 parser->m_bufferEnd = parser->m_buffer;
1266 parser->m_parseEndByteIndex = 0;
1267 parser->m_parseEndPtr = NULL;
1268 parser->m_partialTokenBytesBefore = 0;
1269 parser->m_reparseDeferralEnabled = g_reparseDeferralEnabledDefault;
1270 parser->m_lastBufferRequestSize = 0;
1271 parser->m_declElementType = NULL;
1272 parser->m_declAttributeId = NULL;
1273 parser->m_declEntity = NULL;
1274 parser->m_doctypeName = NULL;
1275 parser->m_doctypeSysid = NULL;
1276 parser->m_doctypePubid = NULL;
1277 parser->m_declAttributeType = NULL;
1278 parser->m_declNotationName = NULL;
1279 parser->m_declNotationPublicId = NULL;
1280 parser->m_declAttributeIsCdata = XML_FALSE;
1281 parser->m_declAttributeIsId = XML_FALSE;
1282 memset(&parser->m_position, 0, sizeof(POSITION));
1283 parser->m_errorCode = XML_ERROR_NONE;
1284 parser->m_eventPtr = NULL;
1285 parser->m_eventEndPtr = NULL;
1286 parser->m_positionPtr = NULL;
1287 parser->m_openInternalEntities = NULL;
1288 parser->m_openAttributeEntities = NULL;
1289 parser->m_openValueEntities = NULL;
1290 parser->m_defaultExpandInternalEntities = XML_TRUE;
1291 parser->m_tagLevel = 0;
1292 parser->m_tagStack = NULL;
1293 parser->m_inheritedBindings = NULL;
1294 parser->m_nSpecifiedAtts = 0;
1295 parser->m_unknownEncodingMem = NULL;
1296 parser->m_unknownEncodingRelease = NULL;
1297 parser->m_unknownEncodingData = NULL;
1298 parser->m_parentParser = NULL;
1299 parser->m_parsingStatus.parsing = XML_INITIALIZED;
1301 parser->m_reenter = XML_FALSE;
1303 parser->m_isParamEntity = XML_FALSE;
1304 parser->m_useForeignDTD = XML_FALSE;
1305 parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
1307 parser->m_hash_secret_salt = 0;
1310 memset(&parser->m_accounting, 0, sizeof(ACCOUNTING));
1311 parser->m_accounting.debugLevel = getDebugLevel("EXPAT_ACCOUNTING_DEBUG", 0u);
1312 parser->m_accounting.maximumAmplificationFactor
1314 parser->m_accounting.activationThresholdBytes
1317 memset(&parser->m_entity_stats, 0, sizeof(ENTITY_STATS));
1318 parser->m_entity_stats.debugLevel = getDebugLevel("EXPAT_ENTITY_DEBUG", 0u);
1324 moveToFreeBindingList(XML_Parser parser, BINDING *bindings) {
1328 b->nextTagBinding = parser->m_freeBindingList;
1329 parser->m_freeBindingList = b;
1334 XML_ParserReset(XML_Parser parser, const XML_Char *encodingName) {
1338 if (parser == NULL)
1341 if (parser->m_parentParser)
1344 tStk = parser->m_tagStack;
1348 tag->parent = parser->m_freeTagList;
1349 moveToFreeBindingList(parser, tag->bindings);
1351 parser->m_freeTagList = tag;
1354 openEntityList = parser->m_openInternalEntities;
1358 openEntity->next = parser->m_freeInternalEntities;
1359 parser->m_freeInternalEntities = openEntity;
1363 openEntityList = parser->m_openAttributeEntities;
1367 openEntity->next = parser->m_freeAttributeEntities;
1368 parser->m_freeAttributeEntities = openEntity;
1372 openEntityList = parser->m_openValueEntities;
1376 openEntity->next = parser->m_freeValueEntities;
1377 parser->m_freeValueEntities = openEntity;
1379 moveToFreeBindingList(parser, parser->m_inheritedBindings);
1380 FREE(parser, parser->m_unknownEncodingMem);
1381 if (parser->m_unknownEncodingRelease)
1382 parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
1383 poolClear(&parser->m_tempPool);
1384 poolClear(&parser->m_temp2Pool);
1385 FREE(parser, (void *)parser->m_protocolEncodingName);
1386 parser->m_protocolEncodingName = NULL;
1387 parserInit(parser, encodingName);
1388 dtdReset(parser->m_dtd, &parser->m_mem);
1393 parserBusy(XML_Parser parser) {
1394 switch (parser->m_parsingStatus.parsing) {
1406 XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName) {
1407 if (parser == NULL)
1413 if (parserBusy(parser))
1417 FREE(parser, (void *)parser->m_protocolEncodingName);
1421 parser->m_protocolEncodingName = NULL;
1424 parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
1425 if (! parser->m_protocolEncodingName)
1434 XML_Parser parser = oldParser;
1468 /* Note that the new parser shares the same hash secret as the old
1469 parser, so that dtdCopy and copyEntityTable can lookup values
1470 from hash tables associated with either parser without us having
1480 /* Stash the original parser contents on the stack */
1481 oldDtd = parser->m_dtd;
1482 oldStartElementHandler = parser->m_startElementHandler;
1483 oldEndElementHandler = parser->m_endElementHandler;
1484 oldCharacterDataHandler = parser->m_characterDataHandler;
1485 oldProcessingInstructionHandler = parser->m_processingInstructionHandler;
1486 oldCommentHandler = parser->m_commentHandler;
1487 oldStartCdataSectionHandler = parser->m_startCdataSectionHandler;
1488 oldEndCdataSectionHandler = parser->m_endCdataSectionHandler;
1489 oldDefaultHandler = parser->m_defaultHandler;
1490 oldUnparsedEntityDeclHandler = parser->m_unparsedEntityDeclHandler;
1491 oldNotationDeclHandler = parser->m_notationDeclHandler;
1492 oldStartNamespaceDeclHandler = parser->m_startNamespaceDeclHandler;
1493 oldEndNamespaceDeclHandler = parser->m_endNamespaceDeclHandler;
1494 oldNotStandaloneHandler = parser->m_notStandaloneHandler;
1495 oldExternalEntityRefHandler = parser->m_externalEntityRefHandler;
1496 oldSkippedEntityHandler = parser->m_skippedEntityHandler;
1497 oldUnknownEncodingHandler = parser->m_unknownEncodingHandler;
1498 oldElementDeclHandler = parser->m_elementDeclHandler;
1499 oldAttlistDeclHandler = parser->m_attlistDeclHandler;
1500 oldEntityDeclHandler = parser->m_entityDeclHandler;
1501 oldXmlDeclHandler = parser->m_xmlDeclHandler;
1502 oldDeclElementType = parser->m_declElementType;
1504 oldUserData = parser->m_userData;
1505 oldHandlerArg = parser->m_handlerArg;
1506 oldDefaultExpandInternalEntities = parser->m_defaultExpandInternalEntities;
1507 oldExternalEntityRefHandlerArg = parser->m_externalEntityRefHandlerArg;
1509 oldParamEntityParsing = parser->m_paramEntityParsing;
1510 oldInEntityValue = parser->m_prologState.inEntityValue;
1512 oldns_triplets = parser->m_ns_triplets;
1513 /* Note that the new parser shares the same hash secret as the old
1514 parser, so that dtdCopy and copyEntityTable can lookup values
1515 from hash tables associated with either parser without us having
1518 oldhash_secret_salt = parser->m_hash_secret_salt;
1519 oldReparseDeferralEnabled = parser->m_reparseDeferralEnabled;
1527 access look more like C++ require that `parser' be overwritten
1531 if (parser->m_ns) {
1532 XML_Char tmp[2] = {parser->m_namespaceSeparator, 0};
1533 parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);
1535 parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);
1538 if (! parser)
1541 parser->m_startElementHandler = oldStartElementHandler;
1542 parser->m_endElementHandler = oldEndElementHandler;
1543 parser->m_characterDataHandler = oldCharacterDataHandler;
1544 parser->m_processingInstructionHandler = oldProcessingInstructionHandler;
1545 parser->m_commentHandler = oldCommentHandler;
1546 parser->m_startCdataSectionHandler = oldStartCdataSectionHandler;
1547 parser->m_endCdataSectionHandler = oldEndCdataSectionHandler;
1548 parser->m_defaultHandler = oldDefaultHandler;
1549 parser->m_unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;
1550 parser->m_notationDeclHandler = oldNotationDeclHandler;
1551 parser->m_startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
1552 parser->m_endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
1553 parser->m_notStandaloneHandler = oldNotStandaloneHandler;
1554 parser->m_externalEntityRefHandler = oldExternalEntityRefHandler;
1555 parser->m_skippedEntityHandler = oldSkippedEntityHandler;
1556 parser->m_unknownEncodingHandler = oldUnknownEncodingHandler;
1557 parser->m_elementDeclHandler = oldElementDeclHandler;
1558 parser->m_attlistDeclHandler = oldAttlistDeclHandler;
1559 parser->m_entityDeclHandler = oldEntityDeclHandler;
1560 parser->m_xmlDeclHandler = oldXmlDeclHandler;
1561 parser->m_declElementType = oldDeclElementType;
1562 parser->m_userData = oldUserData;
1564 parser->m_handlerArg = parser->m_userData;
1566 parser->m_handlerArg = parser;
1568 parser->m_externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
1569 parser->m_defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
1570 parser->m_ns_triplets = oldns_triplets;
1571 parser->m_hash_secret_salt = oldhash_secret_salt;
1572 parser->m_reparseDeferralEnabled = oldReparseDeferralEnabled;
1573 parser->m_parentParser = oldParser;
1575 parser->m_paramEntityParsing = oldParamEntityParsing;
1576 parser->m_prologState.inEntityValue = oldInEntityValue;
1579 if (! dtdCopy(oldParser, parser->m_dtd, oldDtd, &parser->m_mem)
1580 || ! setContext(parser, context)) {
1581 XML_ParserFree(parser);
1584 parser->m_processor = externalEntityInitProcessor;
1587 /* The DTD instance referenced by parser->m_dtd is shared between the
1588 document's root parser and external PE parsers, therefore one does not
1591 pointers in parser->m_dtd with ones that get destroyed with the external
1592 PE parser. This would leave those prefixes with dangling pointers.
1594 parser->m_isParamEntity = XML_TRUE;
1595 XmlPrologStateInitExternalEntity(&parser->m_prologState);
1596 parser->m_processor = externalParEntInitProcessor;
1599 return parser;
1603 destroyBindings(BINDING *bindings, XML_Parser parser) {
1609 FREE(parser, b->uri);
1610 FREE(parser, b);
1615 XML_ParserFree(XML_Parser parser) {
1618 if (parser == NULL)
1621 tagList = parser->m_tagStack;
1625 if (parser->m_freeTagList == NULL)
1627 tagList = parser->m_freeTagList;
1628 parser->m_freeTagList = NULL;
1632 FREE(parser, p->buf);
1633 destroyBindings(p->bindings, parser);
1634 FREE(parser, p);
1637 entityList = parser->m_openInternalEntities;
1641 if (parser->m_freeInternalEntities == NULL)
1643 entityList = parser->m_freeInternalEntities;
1644 parser->m_freeInternalEntities = NULL;
1648 FREE(parser, openEntity);
1651 entityList = parser->m_openAttributeEntities;
1655 if (parser->m_freeAttributeEntities == NULL)
1657 entityList = parser->m_freeAttributeEntities;
1658 parser->m_freeAttributeEntities = NULL;
1662 FREE(parser, openEntity);
1665 entityList = parser->m_openValueEntities;
1669 if (parser->m_freeValueEntities == NULL)
1671 entityList = parser->m_freeValueEntities;
1672 parser->m_freeValueEntities = NULL;
1676 FREE(parser, openEntity);
1678 destroyBindings(parser->m_freeBindingList, parser);
1679 destroyBindings(parser->m_inheritedBindings, parser);
1680 poolDestroy(&parser->m_tempPool);
1681 poolDestroy(&parser->m_temp2Pool);
1682 FREE(parser, (void *)parser->m_protocolEncodingName);
1685 parser->m_dtd with the root parser, so we must not destroy it
1687 if (! parser->m_isParamEntity && parser->m_dtd)
1689 if (parser->m_dtd)
1691 dtdDestroy(parser->m_dtd, (XML_Bool)! parser->m_parentParser,
1692 &parser->m_mem);
1693 FREE(parser, (void *)parser->m_atts);
1695 FREE(parser, (void *)parser->m_attInfo);
1697 FREE(parser, parser->m_groupConnector);
1698 FREE(parser, parser->m_buffer);
1699 FREE(parser, parser->m_dataBuf);
1700 FREE(parser, parser->m_nsAtts);
1701 FREE(parser, parser->m_unknownEncodingMem);
1702 if (parser->m_unknownEncodingRelease)
1703 parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
1704 FREE(parser, parser);
1708 XML_UseParserAsHandlerArg(XML_Parser parser) {
1709 if (parser != NULL)
1710 parser->m_handlerArg = parser;
1714 XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD) {
1715 if (parser == NULL)
1719 if (parserBusy(parser))
1721 parser->m_useForeignDTD = useDTD;
1730 XML_SetReturnNSTriplet(XML_Parser parser, int do_nst) {
1731 if (parser == NULL)
1734 if (parserBusy(parser))
1736 parser->m_ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
1740 XML_SetUserData(XML_Parser parser, void *p) {
1741 if (parser == NULL)
1743 if (parser->m_handlerArg == parser->m_userData)
1744 parser->m_handlerArg = parser->m_userData = p;
1746 parser->m_userData = p;
1750 XML_SetBase(XML_Parser parser, const XML_Char *p) {
1751 if (parser == NULL)
1754 p = poolCopyString(&parser->m_dtd->pool, p);
1757 parser->m_curBase = p;
1759 parser->m_curBase = NULL;
1764 XML_GetBase(XML_Parser parser) {
1765 if (parser == NULL)
1767 return parser->m_curBase;
1771 XML_GetSpecifiedAttributeCount(XML_Parser parser) {
1772 if (parser == NULL)
1774 return parser->m_nSpecifiedAtts;
1778 XML_GetIdAttributeIndex(XML_Parser parser) {
1779 if (parser == NULL)
1781 return parser->m_idAttIndex;
1786 XML_GetAttributeInfo(XML_Parser parser) {
1787 if (parser == NULL)
1789 return parser->m_attInfo;
1794 XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
1796 if (parser == NULL)
1798 parser->m_startElementHandler = start;
1799 parser->m_endElementHandler = end;
1803 XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler start) {
1804 if (parser != NULL)
1805 parser->m_startElementHandler = start;
1809 XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler end) {
1810 if (parser != NULL)
1811 parser->m_endElementHandler = end;
1815 XML_SetCharacterDataHandler(XML_Parser parser,
1817 if (parser != NULL)
1818 parser->m_characterDataHandler = handler;
1822 XML_SetProcessingInstructionHandler(XML_Parser parser,
1824 if (parser != NULL)
1825 parser->m_processingInstructionHandler = handler;
1829 XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler) {
1830 if (parser != NULL)
1831 parser
1835 XML_SetCdataSectionHandler(XML_Parser parser,
1838 if (parser == NULL)
1840 parser->m_startCdataSectionHandler = start;
1841 parser->m_endCdataSectionHandler = end;
1845 XML_SetStartCdataSectionHandler(XML_Parser parser,
1847 if (parser != NULL)
1848 parser->m_startCdataSectionHandler = start;
1852 XML_SetEndCdataSectionHandler(XML_Parser parser,
1854 if (parser != NULL)
1855 parser->m_endCdataSectionHandler = end;
1859 XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler) {
1860 if (parser == NULL)
1862 parser->m_defaultHandler = handler;
1863 parser->m_defaultExpandInternalEntities = XML_FALSE;
1867 XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler) {
1868 if (parser == NULL)
1870 parser->m_defaultHandler = handler;
1871 parser->m_defaultExpandInternalEntities = XML_TRUE;
1875 XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,
1877 if (parser == NULL)
1879 parser->m_startDoctypeDeclHandler = start;
1880 parser->m_endDoctypeDeclHandler = end;
1884 XML_SetStartDoctypeDeclHandler(XML_Parser parser,
1886 if (parser != NULL)
1887 parser->m_startDoctypeDeclHandler = start;
1891 XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end) {
1892 if (parser != NULL)
1893 parser->m_endDoctypeDeclHandler = end;
1897 XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
1899 if (parser != NULL)
1900 parser->m_unparsedEntityDeclHandler = handler;
1904 XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler) {
1905 if (parser != NULL)
1906 parser->m_notationDeclHandler = handler;
1910 XML_SetNamespaceDeclHandler(XML_Parser parser,
1913 if (parser == NULL)
1915 parser->m_startNamespaceDeclHandler = start;
1916 parser->m_endNamespaceDeclHandler = end;
1920 XML_SetStartNamespaceDeclHandler(XML_Parser parser,
1922 if (parser != NULL)
1923 parser->m_startNamespaceDeclHandler = start;
1927 XML_SetEndNamespaceDeclHandler(XML_Parser parser,
1929 if (parser != NULL)
1930 parser->m_endNamespaceDeclHandler = end;
1934 XML_SetNotStandaloneHandler(XML_Parser parser,
1936 if (parser != NULL)
1937 parser->m_notStandaloneHandler = handler;
1941 XML_SetExternalEntityRefHandler(XML_Parser parser,
1943 if (parser != NULL)
1944 parser->m_externalEntityRefHandler = handler;
1948 XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg) {
1949 if (parser == NULL)
1952 parser->m_externalEntityRefHandlerArg = (XML_Parser)arg;
1954 parser->m_externalEntityRefHandlerArg = parser;
1958 XML_SetSkippedEntityHandler(XML_Parser parser,
1960 if (parser != NULL)
1961 parser->m_skippedEntityHandler = handler;
1965 XML_SetUnknownEncodingHandler(XML_Parser parser,
1967 if (parser == NULL)
1969 parser->m_unknownEncodingHandler = handler;
1970 parser->m_unknownEncodingHandlerData = data;
1974 XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl) {
1975 if (parser != NULL)
1976 parser->m_elementDeclHandler = eldecl;
1980 XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl) {
1981 if (parser != NULL)
1982 parser->m_attlistDeclHandler = attdecl;
1986 XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler) {
1987 if (parser != NULL)
1988 parser->m_entityDeclHandler = handler;
1992 XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler handler) {
1993 if (parser != NULL)
1994 parser->m_xmlDeclHandler = handler;
1998 XML_SetParamEntityParsing(XML_Parser parser,
2000 if (parser == NULL)
2003 if (parserBusy(parser))
2006 parser->m_paramEntityParsing = peParsing;
2014 XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt) {
2015 if (parser == NULL)
2017 if (parser->m_parentParser)
2018 return XML_SetHashSalt(parser->m_parentParser, hash_salt);
2020 if (parserBusy(parser))
2022 parser->m_hash_secret_salt = hash_salt;
2027 XML_Parse(XML_Parser parser, const char *s, int len, int isFinal) {
2028 if ((parser == NULL) || (len < 0) || ((s == NULL) && (len != 0))) {
2029 if (parser != NULL)
2030 parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;
2033 switch (parser->m_parsingStatus.parsing) {
2035 parser->m_errorCode = XML_ERROR_SUSPENDED;
2038 parser->m_errorCode = XML_ERROR_FINISHED;
2041 if (parser->m_parentParser == NULL && ! startParsing(parser)) {
2042 parser->m_errorCode = XML_ERROR_NO_MEMORY;
2047 parser->m_parsingStatus.parsing = XML_PARSING;
2051 if (parser->m_bufferPtr == parser->m_bufferEnd) {
2056 if ((XML_Size)len > ((XML_Size)-1) / 2 - parser->m_parseEndByteIndex) {
2057 parser->m_errorCode = XML_ERROR_NO_MEMORY;
2058 parser->m_eventPtr = parser->m_eventEndPtr = NULL;
2059 parser->m_processor = errorProcessor;
2064 parser->m_lastBufferRequestSize = len;
2065 parser->m_parseEndByteIndex += len;
2066 parser->m_positionPtr = s;
2067 parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
2069 parser->m_errorCode
2070 = callProcessor(parser, s, parser->m_parseEndPtr = s + len, &end);
2072 if (parser->m_errorCode != XML_ERROR_NONE) {
2073 parser->m_eventEndPtr = parser->m_eventPtr;
2074 parser->m_processor = errorProcessor;
2077 switch (parser->m_parsingStatus.parsing) {
2084 parser->m_parsingStatus.parsing = XML_FINISHED;
2093 XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, end,
2094 &parser->m_position);
2099 const enum XML_Parsing originalStatus = parser->m_parsingStatus.parsing;
2100 parser->m_parsingStatus.parsing = XML_PARSING;
2101 void *const temp = XML_GetBuffer(parser, nLeftOver);
2102 parser->m_parsingStatus.parsing = originalStatus;
2105 parser->m_lastBufferRequestSize = len;
2107 // NOTE: parser->m_errorCode has already been set by XML_GetBuffer().
2108 parser->m_eventPtr = parser->m_eventEndPtr = NULL;
2109 parser->m_processor = errorProcessor;
2116 memcpy(parser->m_buffer, end, nLeftOver);
2118 parser->m_bufferPtr = parser->m_buffer;
2119 parser->m_bufferEnd = parser->m_buffer + nLeftOver;
2120 parser->m_positionPtr = parser->m_bufferPtr;
2121 parser->m_parseEndPtr = parser->m_bufferEnd;
2122 parser->m_eventPtr = parser->m_bufferPtr;
2123 parser->m_eventEndPtr = parser->m_bufferPtr;
2127 void *buff = XML_GetBuffer(parser, len);
2134 return XML_ParseBuffer(parser, len, isFinal);
2138 XML_ParseBuffer(XML_Parser parser, int len, int isFinal) {
2142 if (parser == NULL)
2146 parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;
2150 switch (parser->m_parsingStatus.parsing) {
2152 parser->m_errorCode = XML_ERROR_SUSPENDED;
2155 parser->m_errorCode = XML_ERROR_FINISHED;
2159 if (! parser->m_bufferPtr) {
2160 parser->m_errorCode = XML_ERROR_NO_BUFFER;
2164 if (parser->m_parentParser == NULL && ! startParsing(parser)) {
2165 parser->m_errorCode = XML_ERROR_NO_MEMORY;
2170 parser->m_parsingStatus.parsing = XML_PARSING;
2173 start = parser->m_bufferPtr;
2174 parser->m_positionPtr = start;
2175 parser->m_bufferEnd += len;
2176 parser->m_parseEndPtr = parser->m_bufferEnd;
2177 parser->m_parseEndByteIndex += len;
2178 parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
2180 parser->m_errorCode = callProcessor(parser, start, parser->m_parseEndPtr,
2181 &parser->m_bufferPtr);
2183 if (parser->m_errorCode != XML_ERROR_NONE) {
2184 parser->m_eventEndPtr = parser->m_eventPtr;
2185 parser->m_processor = errorProcessor;
2188 switch (parser->m_parsingStatus.parsing) {
2195 parser->m_parsingStatus.parsing = XML_FINISHED;
2202 XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2203 parser->m_bufferPtr, &parser->m_position);
2204 parser->m_positionPtr = parser->m_bufferPtr;
2209 XML_GetBuffer(XML_Parser parser, int len) {
2210 if (parser == NULL)
2213 parser->m_errorCode = XML_ERROR_NO_MEMORY;
2216 switch (parser->m_parsingStatus.parsing) {
2218 parser->m_errorCode = XML_ERROR_SUSPENDED;
2221 parser->m_errorCode = XML_ERROR_FINISHED;
2228 parser->m_lastBufferRequestSize = len;
2229 if (len > EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd)
2230 || parser->m_buffer == NULL) {
2237 parser->m_bufferEnd, parser->m_bufferPtr));
2239 parser->m_errorCode = XML_ERROR_NO_MEMORY;
2243 keep = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);
2248 parser->m_errorCode = XML_ERROR_NO_MEMORY;
2253 if (parser->m_buffer && parser->m_bufferPtr
2255 <= EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer)) {
2257 if (keep < EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)) {
2259 = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)
2263 memmove(parser->m_buffer, &parser->m_buffer[offset],
2264 parser->m_bufferEnd - parser->m_bufferPtr + keep);
2265 parser->m_bufferEnd -= offset;
2266 parser->m_bufferPtr -= offset;
2269 memmove(parser->m_buffer, parser->m_bufferPtr,
2270 EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
2271 parser->m_bufferEnd
2272 = parser->m_buffer
2273 + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
2274 parser->m_bufferPtr = parser->m_buffer;
2279 = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer);
2287 parser->m_errorCode = XML_ERROR_NO_MEMORY;
2290 newBuf = (char *)MALLOC(parser, bufferSize);
2292 parser->m_errorCode = XML_ERROR_NO_MEMORY;
2295 parser->m_bufferLim = newBuf + bufferSize;
2297 if (parser->m_bufferPtr) {
2298 memcpy(newBuf, &parser->m_bufferPtr[-keep],
2299 EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
2301 FREE(parser, parser->m_buffer);
2302 parser->m_buffer = newBuf;
2303 parser->m_bufferEnd
2304 = parser->m_buffer
2305 + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
2307 parser->m_bufferPtr = parser->m_buffer + keep;
2310 parser->m_bufferEnd = newBuf;
2311 parser->m_bufferPtr = parser->m_buffer = newBuf;
2314 if (parser->m_bufferPtr) {
2315 memcpy(newBuf, parser->m_bufferPtr,
2316 EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
2317 FREE(parser, parser->m_buffer);
2318 parser->m_bufferEnd
2320 + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
2323 parser->m_bufferEnd = newBuf;
2325 parser->m_bufferPtr = parser->m_buffer = newBuf;
2328 parser->m_eventPtr = parser->m_eventEndPtr = NULL;
2329 parser->m_positionPtr = NULL;
2331 return parser->m_bufferEnd;
2335 triggerReenter(XML_Parser parser) {
2336 parser->m_reenter = XML_TRUE;
2340 parser, XML_Bool resumable) {
2341 if (parser == NULL)
2343 switch (parser->m_parsingStatus.parsing) {
2345 parser->m_errorCode = XML_ERROR_NOT_STARTED;
2349 parser->m_errorCode = XML_ERROR_SUSPENDED;
2352 parser->m_parsingStatus.parsing = XML_FINISHED;
2355 parser->m_errorCode = XML_ERROR_FINISHED;
2360 if (parser->m_isParamEntity) {
2361 parser->m_errorCode = XML_ERROR_SUSPEND_PE;
2365 parser->m_parsingStatus.parsing = XML_SUSPENDED;
2367 parser->m_parsingStatus.parsing = XML_FINISHED;
2376 XML_ResumeParser(XML_Parser parser) {
2379 if (parser == NULL)
2381 if (parser->m_parsingStatus.parsing != XML_SUSPENDED) {
2382 parser->m_errorCode = XML_ERROR_NOT_SUSPENDED;
2385 parser->m_parsingStatus.parsing = XML_PARSING;
2387 parser->m_errorCode = callProcessor(
2388 parser, parser->m_bufferPtr, parser->m_parseEndPtr, &parser->m_bufferPtr);
2390 if (parser->m_errorCode != XML_ERROR_NONE) {
2391 parser->m_eventEndPtr = parser->m_eventPtr;
2392 parser->m_processor = errorProcessor;
2395 switch (parser->m_parsingStatus.parsing) {
2401 if (parser->m_parsingStatus.finalBuffer) {
2402 parser->m_parsingStatus.parsing = XML_FINISHED;
2409 XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2410 parser->m_bufferPtr, &parser->m_position);
2411 parser->m_positionPtr = parser->m_bufferPtr;
2416 XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status) {
2417 if (parser == NULL)
2420 *status = parser->m_parsingStatus;
2424 XML_GetErrorCode(XML_Parser parser) {
2425 if (parser == NULL)
2427 return parser->m_errorCode;
2431 XML_GetCurrentByteIndex(XML_Parser parser) {
2432 if (parser == NULL)
2434 if (parser->m_eventPtr)
2435 return (XML_Index)(parser->m_parseEndByteIndex
2436 - (parser->m_parseEndPtr - parser->m_eventPtr));
2441 XML_GetCurrentByteCount(XML_Parser parser) {
2442 if (parser == NULL)
2444 if (parser->m_eventEndPtr && parser->m_eventPtr)
2445 return (int)(parser->m_eventEndPtr - parser->m_eventPtr);
2450 XML_GetInputContext(XML_Parser parser, int *offset, int *size) {
2452 if (parser == NULL)
2454 if (parser->m_eventPtr && parser->m_buffer) {
2456 *offset = (int)(parser->m_eventPtr - parser->m_buffer);
2458 *size = (int)(parser->m_bufferEnd - parser->m_buffer);
2459 return parser->m_buffer;
2462 (void)parser;
2470 XML_GetCurrentLineNumber(XML_Parser parser) {
2471 if (parser == NULL)
2473 if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
2474 XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2475 parser->m_eventPtr, &parser->m_position);
2476 parser->m_positionPtr = parser->m_eventPtr;
2478 return parser->m_position.lineNumber + 1;
2482 XML_GetCurrentColumnNumber(XML_Parser parser) {
2483 if (parser == NULL)
2485 if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
2486 XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2487 parser->m_eventPtr, &parser->m_position);
2488 parser->m_positionPtr = parser->m_eventPtr;
2490 return parser->m_position.columnNumber;
2494 XML_FreeContentModel(XML_Parser parser, XML_Content *model) {
2495 if (parser != NULL)
2496 FREE(parser, model);
2500 XML_MemMalloc(XML_Parser parser, size_t size) {
2501 if (parser == NULL)
2503 return MALLOC(parser, size);
2507 XML_MemRealloc(XML_Parser parser, void *ptr, size_t size) {
2508 if (parser == NULL)
2510 return REALLOC(parser, ptr, size);
2514 XML_MemFree(XML_Parser parser, void *ptr) {
2515 if (parser != NULL)
2516 FREE(parser, ptr);
2520 XML_DefaultCurrent(XML_Parser parser) {
2521 if (parser == NULL)
2523 if (parser->m_defaultHandler) {
2524 if (parser->m_openInternalEntities)
2525 reportDefault(parser, parser->m_internalEncoding,
2526 parser->m_openInternalEntities->internalEventPtr,
2527 parser->m_openInternalEntities->internalEventEndPtr);
2529 reportDefault(parser, parser->m_encoding, parser->m_eventPtr,
2530 parser->m_eventEndPtr);
2584 return XML_L("unexpected parser state - please send a bug report");
2606 return XML_L("parser suspended");
2608 return XML_L("parser not suspended");
2637 return XML_L("parser not started");
2725 XML_Parser parser, float maximumAmplificationFactor) {
2726 if ((parser == NULL) || (parser->m_parentParser != NULL)
2731 parser->m_accounting.maximumAmplificationFactor = maximumAmplificationFactor;
2737 XML_Parser parser, unsigned long long activationThresholdBytes) {
2738 if ((parser == NULL) || (parser->m_parentParser != NULL)) {
2741 parser->m_accounting.activationThresholdBytes = activationThresholdBytes;
2747 XML_SetReparseDeferralEnabled(XML_Parser parser, XML_Bool enabled) {
2748 if (parser != NULL && (enabled == XML_TRUE || enabled == XML_FALSE)) {
2749 parser->m_reparseDeferralEnabled = enabled;
2761 storeRawNames(XML_Parser parser) {
2762 TAG *tag = parser->m_tagStack;
2784 char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
2810 contentProcessor(XML_Parser parser, const char *start, const char *end,
2813 parser, parser->m_parentParser ? 1 : 0, parser->m_encoding, start, end,
2814 endPtr, (XML_Bool)! parser->m_parsingStatus.finalBuffer,
2817 if (! storeRawNames(parser))
2824 externalEntityInitProcessor(XML_Parser parser, const char *start,
2826 enum XML_Error result = initializeEncoding(parser);
2829 parser->m_processor = externalEntityInitProcessor2;
2830 return externalEntityInitProcessor2(parser, start, end, endPtr);
2834 externalEntityInitProcessor2(XML_Parser parser, const char *start,
2837 int tok = XmlContentTok(parser->m_encoding, start, end, &next);
2841 if (! accountingDiffTolerated(parser, tok, start, next, __LINE__,
2843 accountingOnAbort(parser);
2853 if (next == end && ! parser->m_parsingStatus.finalBuffer) {
2860 if (! parser->m_parsingStatus.finalBuffer) {
2864 parser->m_eventPtr = start;
2867 if (! parser->m_parsingStatus.finalBuffer) {
2871 parser->m_eventPtr = start;
2874 parser->m_processor = externalEntityInitProcessor3;
2875 return externalEntityInitProcessor3(parser, start, end, endPtr);
2879 externalEntityInitProcessor3(XML_Parser parser, const char *start,
2883 parser->m_eventPtr = start;
2884 tok = XmlContentTok(parser->m_encoding, start, end, &next);
2889 parser->m_eventEndPtr = next;
2894 result = processXmlDecl(parser, 1, start, next);
2897 switch (parser->m_parsingStatus.parsing) {
2904 if (parser->m_reenter) {
2913 if (! parser->m_parsingStatus.finalBuffer) {
2919 if (! parser->m_parsingStatus.finalBuffer) {
2925 parser->m_processor = externalEntityContentProcessor;
2926 parser->m_tagLevel = 1;
2927 return externalEntityContentProcessor(parser, start, end, endPtr);
2931 externalEntityContentProcessor(XML_Parser parser, const char *start,
2934 = doContent(parser, 1, parser->m_encoding, start, end, endPtr,
2935 (XML_Bool)! parser->m_parsingStatus.finalBuffer,
2938 if (! storeRawNames(parser))
2945 doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
2949 DTD *const dtd = parser->m_dtd;
2953 if (enc == parser->m_encoding) {
2954 eventPP = &parser->m_eventPtr;
2955 eventEndPP = &parser->m_eventEndPtr;
2957 eventPP = &(parser->m_openInternalEntities->internalEventPtr);
2958 eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
2970 if (! accountingDiffTolerated(parser, tok, s, accountAfter, __LINE__,
2972 accountingOnAbort(parser);
2984 if (parser->m_characterDataHandler) {
2986 parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
2987 } else if (parser->m_defaultHandler)
2988 reportDefault(parser, enc, s, end);
2994 if (parser->m_tagLevel != startTagLevel)
3004 if (parser->m_tagLevel != startTagLevel)
3035 accountingDiffTolerated(parser, tok, (char *)&ch,
3039 if (parser->m_characterDataHandler)
3040 parser->m_characterDataHandler(parser->m_handlerArg, &ch, 1);
3041 else if (parser->m_defaultHandler)
3042 reportDefault(parser, enc, s, next);
3049 entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
3061 if (parser->m_skippedEntityHandler)
3062 parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
3063 else if (parser->m_defaultHandler)
3064 reportDefault(parser, enc, s, next);
3073 if (! parser->m_defaultExpandInternalEntities) {
3074 if (parser->m_skippedEntityHandler)
3075 parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name,
3077 else if (parser->m_defaultHandler)
3078 reportDefault(parser, enc, s, next);
3081 result = processEntity(parser, entity, XML_FALSE, ENTITY_INTERNAL);
3084 } else if (parser->m_externalEntityRefHandler) {
3087 context = getContext(parser);
3091 if (! parser->m_externalEntityRefHandler(
3092 parser->m_externalEntityRefHandlerArg, context, entity->base,
3095 poolDiscard(&parser->m_tempPool);
3096 } else if (parser->m_defaultHandler)
3097 reportDefault(parser, enc, s, next);
3106 if (parser->m_freeTagList) {
3107 tag = parser->m_freeTagList;
3108 parser->m_freeTagList = parser->m_freeTagList->parent;
3110 tag = (TAG *)MALLOC(parser, sizeof(TAG));
3113 tag->buf = (char *)MALLOC(parser, INIT_TAG_BUF_SIZE);
3115 FREE(parser, tag);
3121 tag->parent = parser->m_tagStack;
3122 parser->m_tagStack = tag;
3127 ++parser->m_tagLevel;
3146 char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
3158 = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings), account);
3161 if (parser->m_startElementHandler)
3162 parser->m_startElementHandler(parser->m_handlerArg, tag->name.str,
3163 (const XML_Char **)parser->m_atts);
3164 else if (parser->m_defaultHandler)
3165 reportDefault(parser, enc, s, next);
3166 poolClear(&parser->m_tempPool);
3177 name.str = poolStoreString(&parser->m_tempPool, enc, rawName,
3181 poolFinish(&parser->m_tempPool);
3182 result = storeAtts(parser, enc, s, &name, &bindings,
3185 freeBindings(parser, bindings);
3188 poolFinish(&parser->m_tempPool);
3189 if (parser->m_startElementHandler) {
3190 parser->m_startElementHandler(parser->m_handlerArg, name.str,
3191 (const XML_Char **)parser->m_atts);
3194 if (parser->m_endElementHandler) {
3195 if (parser->m_startElementHandler)
3197 parser->m_endElementHandler(parser->m_handlerArg, name.str);
3200 if (noElmHandlers && parser->m_defaultHandler)
3201 reportDefault(parser, enc, s, next);
3202 poolClear(&parser->m_tempPool);
3203 freeBindings(parser, bindings);
3205 if ((parser->m_tagLevel == 0)
3206 && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
3207 if (parser->m_parsingStatus.parsing == XML_SUSPENDED
3208 || (parser->m_parsingStatus.parsing == XML_PARSING
3209 && parser->m_reenter))
3210 parser->m_processor = epilogProcessor;
3212 return epilogProcessor(parser, next, end, nextPtr);
3216 if (parser->m_tagLevel == startTagLevel)
3221 TAG *tag = parser->m_tagStack;
3229 parser->m_tagStack = tag->parent;
3230 tag->parent = parser->m_freeTagList;
3231 parser->m_freeTagList = tag;
3232 --parser->m_tagLevel;
3233 if (parser->m_endElementHandler) {
3238 if (parser->m_ns && localPart) {
3248 if (parser->m_ns_triplets && prefix) {
3249 *uri++ = parser->m_namespaceSeparator;
3255 parser->m_endElementHandler(parser->m_handlerArg, tag->name.str);
3256 } else if (parser->m_defaultHandler)
3257 reportDefault(parser, enc, s, next);
3260 if (parser->m_endNamespaceDeclHandler)
3261 parser->m_endNamespaceDeclHandler(parser->m_handlerArg,
3264 b->nextTagBinding = parser->m_freeBindingList;
3265 parser->m_freeBindingList = b;
3268 if ((parser->m_tagLevel == 0)
3269 && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
3270 if (parser->m_parsingStatus.parsing == XML_SUSPENDED
3271 || (parser->m_parsingStatus.parsing == XML_PARSING
3272 && parser->m_reenter))
3273 parser->m_processor = epilogProcessor;
3275 return epilogProcessor(parser, next, end, nextPtr);
3283 if (parser->m_characterDataHandler) {
3285 parser->m_characterDataHandler(parser->m_handlerArg, buf,
3287 } else if (parser->m_defaultHandler)
3288 reportDefault(parser, enc, s, next);
3293 if (parser->m_characterDataHandler) {
3295 parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
3296 } else if (parser->m_defaultHandler)
3297 reportDefault(parser, enc, s, next);
3301 if (parser->m_startCdataSectionHandler)
3302 parser->m_startCdataSectionHandler(parser->m_handlerArg);
3316 else if ((0) && parser->m_characterDataHandler)
3317 parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
3320 else if (parser->m_defaultHandler)
3321 reportDefault(parser, enc, s, next);
3323 = doCdataSection(parser, enc, &next, end, nextPtr, haveMore, account);
3327 parser->m_processor = cdataSectionProcessor;
3336 if (parser->m_characterDataHandler) {
3338 ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
3339 XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
3340 parser->m_characterDataHandler(
3341 parser->m_handlerArg, parser->m_dataBuf,
3342 (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
3344 parser->m_characterDataHandler(
3345 parser->m_handlerArg, (const XML_Char *)s,
3347 } else if (parser->m_defaultHandler)
3348 reportDefault(parser, enc, s, end);
3356 if (parser->m_tagLevel != startTagLevel) {
3363 XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
3367 ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
3369 enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
3371 charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
3372 (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
3379 charDataHandler(parser->m_handlerArg, (const XML_Char *)s,
3381 } else if (parser->m_defaultHandler)
3382 reportDefault(parser, enc, s, next);
3385 if (! reportProcessingInstruction(parser, enc, s, next))
3389 if (! reportComment(parser, enc, s, next))
3400 if (parser->m_defaultHandler)
3401 reportDefault(parser, enc, s, next);
3405 switch (parser->m_parsingStatus.parsing) {
3414 if (parser->m_reenter) {
3427 * moving it to the parser's m_freeBindingList where it can be freed or
3431 freeBindings(XML_Parser parser, BINDING *bindings) {
3438 if (parser->m_endNamespaceDeclHandler)
3439 parser->m_endNamespaceDeclHandler(parser->m_handlerArg, b->prefix->name);
3442 b->nextTagBinding = parser->m_freeBindingList;
3443 parser->m_freeBindingList = b;
3459 storeAtts(XML_Parser parser, const ENCODING *enc, const char *attStr,
3462 DTD *const dtd = parser->m_dtd; /* save one level of indirection */
3477 = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str, 0);
3482 elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
3486 if (parser->m_ns && ! setElementTypePrefix(parser, elementType))
3492 n = XmlGetAttributes(enc, attStr, parser->m_attsSize, parser->m_atts);
3499 if (n + nDefaultAtts > parser->m_attsSize) {
3500 int oldAttsSize = parser->m_attsSize;
3512 parser->m_attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
3519 if ((unsigned)parser->m_attsSize > (size_t)(-1) / sizeof(ATTRIBUTE)) {
3520 parser->m_attsSize = oldAttsSize;
3525 temp = (ATTRIBUTE *)REALLOC(parser, (void *)parser->m_atts,
3526 parser->m_attsSize * sizeof(ATTRIBUTE));
3528 parser->m_attsSize = oldAttsSize;
3531 parser->m_atts = temp;
3538 if ((unsigned)parser->m_attsSize > (size_t)(-1) / sizeof(XML_AttrInfo)) {
3539 parser->m_attsSize = oldAttsSize;
3544 temp2 = (XML_AttrInfo *)REALLOC(parser, (void *)parser->m_attInfo,
3545 parser->m_attsSize * sizeof(XML_AttrInfo));
3547 parser->m_attsSize = oldAttsSize;
3550 parser->m_attInfo = temp2;
3553 XmlGetAttributes(enc, attStr, n, parser->m_atts);
3556 appAtts = (const XML_Char **)parser->m_atts;
3558 ATTRIBUTE *currAtt = &parser->m_atts[i];
3560 XML_AttrInfo *currAttInfo = &parser->m_attInfo[i];
3564 = getAttributeId(parser, enc, currAtt->name,
3570 = parser->m_parseEndByteIndex - (parser->m_parseEndPtr - currAtt->name);
3573 currAttInfo->valueStart = parser->m_parseEndByteIndex
3574 - (parser->m_parseEndPtr - currAtt->valuePtr);
3575 currAttInfo->valueEnd = parser->m_parseEndByteIndex
3576 - (parser->m_parseEndPtr - currAtt->valueEnd);
3583 if (enc == parser->m_encoding)
3584 parser->m_eventPtr = parser->m_atts[i].name;
3589 if (! parser->m_atts[i].normalized) {
3606 parser, enc, isCdata, parser->m_atts[i].valuePtr,
3607 parser->m_atts[i].valueEnd, &parser->m_tempPool, account);
3610 appAtts[attIndex] = poolStart(&parser->m_tempPool);
3611 poolFinish(&parser->m_tempPool);
3614 appAtts[attIndex] = poolStoreString(&parser->m_tempPool, enc,
3615 parser->m_atts[i].valuePtr,
3616 parser->m_atts[i].valueEnd);
3619 poolFinish(&parser->m_tempPool);
3625 enum XML_Error result = addBinding(parser, attId->prefix, attId,
3641 parser->m_nSpecifiedAtts = attIndex;
3645 parser->m_idAttIndex = i;
3649 parser->m_idAttIndex = -1;
3657 enum XML_Error result = addBinding(parser, da->id->prefix, da->id,
3681 unsigned long version = parser->m_nsAttsVersion;
3684 if (parser->m_nsAttsPower >= sizeof(unsigned int) * 8 /* bits per byte */) {
3688 unsigned int nsAttsSize = 1u << parser->m_nsAttsPower;
3689 unsigned char oldNsAttsPower = parser->m_nsAttsPower;
3692 >> parser->m_nsAttsPower) { /* true for m_nsAttsPower = 0 */
3695 while (nPrefixes >> parser->m_nsAttsPower++)
3697 if (parser->m_nsAttsPower < 3)
3698 parser->m_nsAttsPower = 3;
3701 if (parser->m_nsAttsPower >= sizeof(nsAttsSize) * 8 /* bits per byte */) {
3703 parser->m_nsAttsPower = oldNsAttsPower;
3707 nsAttsSize = 1u << parser->m_nsAttsPower;
3716 parser->m_nsAttsPower = oldNsAttsPower;
3721 temp = (NS_ATT *)REALLOC(parser, parser->m_nsAtts,
3725 parser->m_nsAttsPower = oldNsAttsPower;
3728 parser->m_nsAtts = temp;
3735 parser->m_nsAtts[--j].version = version;
3737 parser->m_nsAttsVersion = --version;
3749 copy_salt_to_sipkey(parser, &sip_key);
3753 id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);
3777 if (! poolAppendChar(&parser->m_tempPool, c))
3789 if (! poolAppendChar(&parser->m_tempPool, *s))
3796 Derived from code in lookup(parser, HASH_TABLE *table, ...).
3801 while (parser->m_nsAtts[j].version == version) {
3803 if (uriHash == parser->m_nsAtts[j].hash) {
3804 const XML_Char *s1 = poolStart(&parser->m_tempPool);
3805 const XML_Char *s2 = parser->m_nsAtts[j].uriName;
3813 step = PROBE_STEP(uriHash, mask, parser->m_nsAttsPower);
3818 if (parser->m_ns_triplets) { /* append namespace separator and prefix */
3819 parser->m_tempPool.ptr[-1] = parser->m_namespaceSeparator;
3822 if (! poolAppendChar(&parser->m_tempPool, *s))
3828 s = poolStart(&parser->m_tempPool);
3829 poolFinish(&parser->m_tempPool);
3833 parser->m_nsAtts[j].version = version;
3834 parser->m_nsAtts[j].hash = uriHash;
3835 parser->m_nsAtts[j].uriName = s;
3851 if (! parser->m_ns)
3868 if (parser->m_ns_triplets && binding->prefix->name) {
3903 uri = (XML_Char *)MALLOC(parser, (n + EXPAND_SPARE) * sizeof(XML_Char));
3908 for (p = parser->m_tagStack; p; p = p->parent)
3911 FREE(parser, binding->uri);
3920 *uri = parser->m_namespaceSeparator; /* replace null terminator */
4042 addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
4114 if (parser->m_ns && (uri[len] == parser->m_namespaceSeparator)
4129 if (parser->m_namespaceSeparator)
4131 if (parser->m_freeBindingList) {
4132 b = parser->m_freeBindingList;
4150 parser, b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));
4156 parser->m_freeBindingList = b->nextTagBinding;
4158 b = (BINDING *)MALLOC(parser, sizeof(BINDING));
4177 = (XML_Char *)MALLOC(parser, sizeof(XML_Char) * (len + EXPAND_SPARE));
4179 FREE(parser, b);
4186 if (parser->m_namespaceSeparator)
4187 b->uri[len - 1] = parser->m_namespaceSeparator;
4192 if (*uri == XML_T('\0') && prefix == &parser->m_dtd->defaultPrefix)
4199 if (attId && parser->m_startNamespaceDeclHandler)
4200 parser->m_startNamespaceDeclHandler(parser->m_handlerArg, prefix->name,
4209 cdataSectionProcessor(XML_Parser parser, const char *start, const char *end,
4212 parser, parser->m_encoding, &start, end, endPtr,
4213 (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_ACCOUNT_DIRECT);
4217 if (parser->m_parentParser) { /* we are parsing an external entity */
4218 parser->m_processor = externalEntityContentProcessor;
4219 return externalEntityContentProcessor(parser, start, end, endPtr);
4221 parser->m_processor = contentProcessor;
4222 return contentProcessor(parser, start, end, endPtr);
4232 doCdataSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
4238 if (enc == parser->m_encoding) {
4239 eventPP = &parser->m_eventPtr;
4241 eventEndPP = &parser->m_eventEndPtr;
4243 eventPP = &(parser
4244 eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
4253 if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
4254 accountingOnAbort(parser);
4263 if (parser->m_endCdataSectionHandler)
4264 parser->m_endCdataSectionHandler(parser->m_handlerArg);
4267 else if ((0) && parser->m_characterDataHandler)
4268 parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
4271 else if (parser->m_defaultHandler)
4272 reportDefault(parser, enc, s, next);
4275 if (parser->m_parsingStatus.parsing == XML_FINISHED)
4280 if (parser->m_characterDataHandler) {
4282 parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
4283 } else if (parser->m_defaultHandler)
4284 reportDefault(parser, enc, s, next);
4287 XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
4291 ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
4293 enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
4295 charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
4296 (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
4303 charDataHandler(parser->m_handlerArg, (const XML_Char *)s,
4305 } else if (parser->m_defaultHandler)
4306 reportDefault(parser, enc, s, next);
4337 switch (parser->m_parsingStatus.parsing) {
4346 if (parser->m_reenter) {
4363 ignoreSectionProcessor(XML_Parser parser, const char *start, const char *end,
4366 = doIgnoreSection(parser, parser->m_encoding, &start, end, endPtr,
4367 (XML_Bool)! parser->m_parsingStatus.finalBuffer);
4371 parser->m_processor = prologProcessor;
4372 return prologProcessor(parser, start, end, endPtr);
4381 doIgnoreSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
4388 if (enc == parser->m_encoding) {
4389 eventPP = &parser->m_eventPtr;
4391 eventEndPP = &parser->m_eventEndPtr;
4404 eventPP = &(parser->m_openInternalEntities->internalEventPtr);
4405 eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
4412 if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4414 accountingOnAbort(parser);
4421 if (parser->m_defaultHandler)
4422 reportDefault(parser, enc, s, next);
4425 if (parser->m_parsingStatus.parsing == XML_FINISHED)
4463 initializeEncoding(XML_Parser parser) {
4468 if (! parser->m_protocolEncodingName)
4472 for (i = 0; parser->m_protocolEncodingName[i]; i++) {
4474 || (parser->m_protocolEncodingName[i] & ~0x7f) != 0) {
4478 encodingBuf[i] = (char)parser->m_protocolEncodingName[i];
4484 s = parser->m_protocolEncodingName;
4486 if ((parser->m_ns ? XmlInitEncodingNS : XmlInitEncoding)(
4487 &parser->m_initEncoding, &parser->m_encoding, s))
4489 return handleUnknownEncoding(parser, parser->m_protocolEncodingName);
4493 processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *s,
4504 if (! accountingDiffTolerated(parser, XML_TOK_XML_DECL, s, next, __LINE__,
4506 accountingOnAbort(parser);
4511 if (! (parser->m_ns ? XmlParseXmlDeclNS : XmlParseXmlDecl)(
4512 isGeneralTextEntity, parser->m_encoding, s, next, &parser->m_eventPtr,
4520 parser->m_dtd->standalone = XML_TRUE;
4522 if (parser->m_paramEntityParsing
4524 parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
4527 if (parser->m_xmlDeclHandler) {
4530 &parser->m_temp2Pool, parser->m_encoding, encodingName,
4531 encodingName + XmlNameLength(parser->m_encoding, encodingName));
4534 poolFinish(&parser->m_temp2Pool);
4538 = poolStoreString(&parser->m_temp2Pool, parser->m_encoding, version,
4539 versionend - parser->m_encoding->minBytesPerChar);
4543 parser->m_xmlDeclHandler(parser->m_handlerArg, storedversion, storedEncName,
4545 } else if (parser->m_defaultHandler)
4546 reportDefault(parser, parser->m_encoding, s, next);
4547 if (parser->m_protocolEncodingName == NULL) {
4550 * the parser has already deduced. Do we have the same number
4554 if (newEncoding->minBytesPerChar != parser->m_encoding->minBytesPerChar
4556 && newEncoding != parser->m_encoding)) {
4557 parser->m_eventPtr = encodingName;
4560 parser->m_encoding = newEncoding;
4565 &parser->m_temp2Pool, parser->m_encoding, encodingName,
4566 encodingName + XmlNameLength(parser->m_encoding, encodingName));
4570 result = handleUnknownEncoding(parser, storedEncName);
4571 poolClear(&parser->m_temp2Pool);
4573 parser->m_eventPtr = encodingName;
4579 poolClear(&parser->m_temp2Pool);
4585 handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName) {
4586 if (parser->m_unknownEncodingHandler) {
4594 if (parser->m_unknownEncodingHandler(parser->m_unknownEncodingHandlerData,
4597 parser->m_unknownEncodingMem = MALLOC(parser, XmlSizeOfUnknownEncoding());
4598 if (! parser->m_unknownEncodingMem) {
4603 enc = (parser->m_ns ? XmlInitUnknownEncodingNS : XmlInitUnknownEncoding)(
4604 parser->m_unknownEncodingMem, info.map, info.convert, info.data);
4606 parser->m_unknownEncodingData = info.data;
4607 parser->m_unknownEncodingRelease = info.release;
4608 parser->m_encoding = enc;
4619 prologInitProcessor(XML_Parser parser, const char *s, const char *end,
4621 enum XML_Error result = initializeEncoding(parser);
4624 parser->m_processor = prologProcessor;
4625 return prologProcessor(parser, s, end, nextPtr);
4631 externalParEntInitProcessor(XML_Parser parser, const char *s, const char *end,
4633 enum XML_Error result = initializeEncoding(parser);
4639 parser->m_dtd->paramEntityRead = XML_TRUE;
4641 if (parser->m_prologState.inEntityValue) {
4642 parser->m_processor = entityValueInitProcessor;
4643 return entityValueInitProcessor(parser, s, end, nextPtr);
4645 parser->m_processor = externalParEntProcessor;
4646 return externalParEntProcessor(parser, s, end, nextPtr);
4651 entityValueInitProcessor(XML_Parser parser, const char *s, const char *end,
4656 parser->m_eventPtr = start;
4659 tok = XmlPrologTok(parser->m_encoding, start, end, &next);
4664 parser->m_eventEndPtr = next;
4666 if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
4682 return storeEntityValue(parser, parser->m_encoding, s, end,
4686 result = processXmlDecl(parser, 0, start, next);
4691 * to suspend the parser, which fails and raises an error. The parser can
4694 if (parser->m_parsingStatus.parsing == XML_FINISHED)
4698 parser->m_processor = entityValueProcessor;
4699 return entityValueProcessor(parser, next, end, nextPtr);
4711 if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4713 accountingOnAbort(parser);
4730 parser->m_eventPtr = start;
4735 externalParEntProcessor(XML_Parser parser, const char *s, const char *end,
4740 tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4742 if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
4764 if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4766 accountingOnAbort(parser);
4771 tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4774 parser->m_processor = prologProcessor;
4775 return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
4776 (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
4781 entityValueProcessor(XML_Parser parser, const char *s, const char *end,
4785 const ENCODING *enc = parser->m_encoding;
4794 if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
4810 return storeEntityValue(parser, enc, s, end, XML_ACCOUNT_DIRECT, NULL);
4819 prologProcessor(XML_Parser parser, const char *s, const char *end,
4822 int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4823 return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
4824 (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
4829 doProlog(XML_Parser parser, const ENCODING *enc, const char *s, const char *end,
4863 DTD *const dtd = parser->m_dtd;
4869 if (enc == parser->m_encoding) {
4870 eventPP = &parser->m_eventPtr;
4871 eventEndPP = &parser->m_eventEndPtr;
4873 eventPP = &(parser->m_openInternalEntities->internalEventPtr);
4874 eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
4901 if (enc != parser->m_encoding
4902 && ! parser->m_openInternalEntities->betweenDecl) {
4910 if (parser->m_isParamEntity || enc != parser->m_encoding) {
4911 if (XmlTokenRole(&parser->m_prologState, XML_TOK_NONE, end, end, enc)
4925 role = XmlTokenRole(&parser->m_prologState, tok, s, next, enc);
4935 if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
4936 accountingOnAbort(parser);
4943 enum XML_Error result = processXmlDecl(parser, 0, s, next);
4946 enc = parser->m_encoding;
4950 if (parser->m_startDoctypeDeclHandler) {
4951 parser->m_doctypeName
4952 = poolStoreString(&parser->m_tempPool, enc, s, next);
4953 if (! parser->m_doctypeName)
4955 poolFinish(&parser->m_tempPool);
4956 parser->m_doctypePubid = NULL;
4959 parser->m_doctypeSysid = NULL; /* always initialize to NULL */
4962 if (parser->m_startDoctypeDeclHandler) {
4963 parser->m_startDoctypeDeclHandler(
4964 parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
4965 parser->m_doctypePubid, 1);
4966 parser->m_doctypeName = NULL;
4967 poolClear(&parser->m_tempPool);
4973 enum XML_Error result = processXmlDecl(parser, 1, s, next);
4976 enc = parser->m_encoding;
4982 parser->m_useForeignDTD = XML_FALSE;
4983 parser->m_declEntity = (ENTITY *)lookup(
4984 parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
4985 if (! parser->m_declEntity)
4989 if (parser->m_startDoctypeDeclHandler) {
4993 pubId = poolStoreString(&parser->m_tempPool, enc,
4999 poolFinish(&parser->m_tempPool);
5000 parser->m_doctypePubid = pubId;
5009 if (dtd->keepProcessing && parser->m_declEntity) {
5016 parser->m_declEntity->publicId = tem;
5021 if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_PUBLIC_ID)
5031 if (parser->m_doctypeName) {
5032 parser->m_startDoctypeDeclHandler(
5033 parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
5034 parser->m_doctypePubid, 0);
5035 poolClear(&parser->m_tempPool);
5038 /* parser->m_doctypeSysid will be non-NULL in the case of a previous
5039 XML_ROLE_DOCTYPE_SYSTEM_ID, even if parser->m_startDoctypeDeclHandler
5043 if (parser->m_doctypeSysid || parser->m_useForeignDTD) {
5046 if (parser->m_paramEntityParsing
5047 && parser->m_externalEntityRefHandler) {
5048 ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
5058 if (parser->m_useForeignDTD)
5059 entity->base = parser->m_curBase;
5061 if (! parser->m_externalEntityRefHandler(
5062 parser->m_externalEntityRefHandlerArg, 0, entity->base,
5066 if (! dtd->standalone && parser->m_notStandaloneHandler
5067 && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
5073 else if (! parser->m_doctypeSysid)
5077 parser->m_useForeignDTD = XML_FALSE;
5080 if (parser->m_endDoctypeDeclHandler) {
5081 parser->m_endDoctypeDeclHandler(parser->m_handlerArg);
5090 if (parser->m_useForeignDTD) {
5093 if (parser->m_paramEntityParsing
5094 && parser->m_externalEntityRefHandler) {
5095 ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
5099 entity->base = parser->m_curBase;
5101 if (! parser->m_externalEntityRefHandler(
5102 parser->m_externalEntityRefHandlerArg, 0, entity->base,
5106 if (! dtd->standalone && parser->m_notStandaloneHandler
5107 && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
5119 parser->m_processor = contentProcessor;
5120 return contentProcessor(parser, s, end, nextPtr);
5122 parser->m_declElementType = getElementType(parser, enc, s, next);
5123 if (! parser->m_declElementType)
5127 parser->m_declAttributeId = getAttributeId(parser, enc, s, next);
5128 if (! parser->m_declAttributeId)
5130 parser->m_declAttributeIsCdata = XML_FALSE;
5131 parser->m_declAttributeType = NULL;
5132 parser->m_declAttributeIsId = XML_FALSE;
5135 parser->m_declAttributeIsCdata = XML_TRUE;
5136 parser->m_declAttributeType = atypeCDATA;
5139 parser->m_declAttributeIsId = XML_TRUE;
5140 parser->m_declAttributeType = atypeID;
5143 parser->m_declAttributeType = atypeIDREF;
5146 parser->m_declAttributeType = atypeIDREFS;
5149 parser->m_declAttributeType = atypeENTITY;
5152 parser->m_declAttributeType = atypeENTITIES;
5155 parser->m_declAttributeType = atypeNMTOKEN;
5158 parser->m_declAttributeType = atypeNMTOKENS;
5160 if (dtd->keepProcessing && parser->m_attlistDeclHandler)
5165 if (dtd->keepProcessing && parser->m_attlistDeclHandler) {
5167 if (parser->m_declAttributeType) {
5173 if (! poolAppendString(&parser->m_tempPool, prefix))
5175 if (! poolAppend(&parser->m_tempPool, enc, s, next))
5177 parser->m_declAttributeType = parser->m_tempPool.start;
5184 if (! defineAttribute(parser->m_declElementType,
5185 parser->m_declAttributeId,
5186 parser->m_declAttributeIsCdata,
5187 parser->m_declAttributeIsId, 0, parser))
5189 if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
5190 if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
5191 || (*parser->m_declAttributeType == XML_T(ASCII_N)
5192 && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
5194 if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
5195 || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
5197 parser->m_declAttributeType = parser->m_tempPool.start;
5198 poolFinish(&parser->m_tempPool);
5201 parser->m_attlistDeclHandler(
5202 parser->m_handlerArg, parser->m_declElementType->name,
5203 parser->m_declAttributeId->name, parser->m_declAttributeType, 0,
5208 poolClear(&parser->m_tempPool);
5215 parser, enc, parser->m_declAttributeIsCdata,
5224 parser->m_declElementType, parser->m_declAttributeId,
5225 parser->m_declAttributeIsCdata, XML_FALSE, attVal, parser))
5227 if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
5228 if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
5229 || (*parser->m_declAttributeType == XML_T(ASCII_N)
5230 && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
5232 if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
5233 || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
5235 parser->m_declAttributeType = parser->m_tempPool.start;
5236 poolFinish(&parser->m_tempPool);
5239 parser->m_attlistDeclHandler(
5240 parser->m_handlerArg, parser->m_declElementType->name,
5241 parser->m_declAttributeId->name, parser->m_declAttributeType,
5243 poolClear(&parser->m_tempPool);
5252 // parser->m_declEntity->textPtr.
5254 parser, enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar,
5256 if (parser->m_declEntity) {
5257 parser->m_declEntity->textPtr = poolStart(&dtd->entityValuePool);
5258 parser->m_declEntity->textLen
5261 if (parser->m_entityDeclHandler) {
5263 parser->m_entityDeclHandler(
5264 parser->m_handlerArg, parser->m_declEntity->name,
5265 parser->m_declEntity->is_param, parser->m_declEntity->textPtr,
5266 parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);
5274 // This will store "&entity123;" in parser->m_declEntity->textPtr
5276 if (parser->m_declEntity != NULL) {
5278 = storeSelfEntityValue(parser, parser->m_declEntity);
5282 if (parser->m_entityDeclHandler) {
5284 parser->m_entityDeclHandler(
5285 parser->m_handlerArg, parser->m_declEntity->name,
5286 parser->m_declEntity->is_param, parser->m_declEntity->textPtr,
5287 parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);
5296 parser->m_useForeignDTD = XML_FALSE;
5299 if (parser->m_startDoctypeDeclHandler) {
5300 parser->m_doctypeSysid = poolStoreString(&parser->m_tempPool, enc,
5303 if (parser->m_doctypeSysid == NULL)
5305 poolFinish(&parser->m_tempPool);
5310 /* use externalSubsetName to make parser->m_doctypeSysid non-NULL
5311 for the case where no parser->m_startDoctypeDeclHandler is set */
5312 parser->m_doctypeSysid = externalSubsetName;
5316 && ! parser->m_paramEntityParsing
5318 && parser->m_notStandaloneHandler
5319 && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
5324 if (! parser->m_declEntity) {
5325 parser->m_declEntity = (ENTITY *)lookup(
5326 parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
5327 if (! parser->m_declEntity)
5329 parser->m_declEntity->publicId = NULL;
5334 if (dtd->keepProcessing && parser->m_declEntity) {
5335 parser->m_declEntity->systemId
5338 if (! parser->m_declEntity->systemId)
5340 parser->m_declEntity->base = parser->m_curBase;
5345 if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_SYSTEM_ID)
5353 if (parser->m_declEntity != NULL) {
5355 = storeSelfEntityValue(parser, parser->m_declEntity);
5360 if (dtd->keepProcessing && parser->m_declEntity
5361 && parser->m_entityDeclHandler) {
5363 parser->m_entityDeclHandler(
5364 parser->m_handlerArg, parser->m_declEntity->name,
5365 parser->m_declEntity->is_param, 0, 0, parser->m_declEntity->base,
5366 parser->m_declEntity->systemId, parser->m_declEntity->publicId, 0);
5371 if (dtd->keepProcessing && parser->m_declEntity) {
5372 parser->m_declEntity->notation
5374 if (! parser->m_declEntity->notation)
5377 if (parser->m_unparsedEntityDeclHandler) {
5379 parser->m_unparsedEntityDeclHandler(
5380 parser->m_handlerArg, parser->m_declEntity->name,
5381 parser->m_declEntity->base, parser->m_declEntity->systemId,
5382 parser->m_declEntity->publicId, parser->m_declEntity->notation);
5384 } else if (parser->m_entityDeclHandler) {
5386 parser->m_entityDeclHandler(
5387 parser->m_handlerArg, parser->m_declEntity->name, 0, 0, 0,
5388 parser->m_declEntity->base, parser->m_declEntity->systemId,
5389 parser->m_declEntity->publicId, parser->m_declEntity->notation);
5396 parser->m_declEntity = NULL;
5403 parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities,
5405 if (! parser->m_declEntity)
5407 if (parser->m_declEntity->name != name) {
5409 parser->m_declEntity = NULL;
5412 parser->m_declEntity->publicId = NULL;
5413 parser->m_declEntity->is_param = XML_FALSE;
5414 /* if we have a parent parser or are reading an internal parameter
5417 parser->m_declEntity->is_internal
5418 = ! (parser->m_parentParser || parser->m_openInternalEntities);
5419 if (parser->m_entityDeclHandler)
5424 parser->m_declEntity = NULL;
5433 parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,
5435 if (! parser->m_declEntity)
5437 if (parser->m_declEntity->name != name) {
5439 parser->m_declEntity = NULL;
5442 parser->m_declEntity->publicId = NULL;
5443 parser->m_declEntity->is_param = XML_TRUE;
5444 /* if we have a parent parser or are reading an internal parameter
5447 parser->m_declEntity->is_internal
5448 = ! (parser->m_parentParser || parser->m_openInternalEntities);
5449 if (parser->m_entityDeclHandler)
5454 parser->m_declEntity = NULL;
5457 parser->m_declEntity = NULL;
5461 parser->m_declNotationPublicId = NULL;
5462 parser->m_declNotationName = NULL;
5463 if (parser->m_notationDeclHandler) {
5464 parser->m_declNotationName
5465 = poolStoreString(&parser->m_tempPool, enc, s, next);
5466 if (! parser->m_declNotationName)
5468 poolFinish(&parser->m_tempPool);
5475 if (parser
5477 XML_Char *tem = poolStoreString(&parser->m_tempPool, enc,
5483 parser->m_declNotationPublicId = tem;
5484 poolFinish(&parser->m_tempPool);
5489 if (parser->m_declNotationName && parser->m_notationDeclHandler) {
5490 const XML_Char *systemId = poolStoreString(&parser->m_tempPool, enc,
5496 parser->m_notationDeclHandler(
5497 parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
5498 systemId, parser->m_declNotationPublicId);
5501 poolClear(&parser->m_tempPool);
5504 if (parser->m_declNotationPublicId && parser->m_notationDeclHandler) {
5506 parser->m_notationDeclHandler(
5507 parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
5508 0, parser->m_declNotationPublicId);
5511 poolClear(&parser->m_tempPool);
5527 if (parser->m_defaultHandler)
5528 reportDefault(parser, enc, s, next);
5530 result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
5534 parser->m_processor = ignoreSectionProcessor;
5540 if (parser->m_prologState.level >= parser->m_groupSize) {
5541 if (parser->m_groupSize) {
5544 if (parser->m_groupSize > (unsigned int)(-1) / 2u) {
5549 parser, parser->m_groupConnector, parser->m_groupSize *= 2);
5551 parser->m_groupSize /= 2;
5554 parser->m_groupConnector = new_connector;
5563 if (parser->m_groupSize > (size_t)(-1) / sizeof(int)) {
5569 parser, dtd->scaffIndex, parser->m_groupSize * sizeof(int));
5575 parser->m_groupConnector
5576 = (char *)MALLOC(parser, parser->m_groupSize = 32);
5577 if (! parser->m_groupConnector) {
5578 parser->m_groupSize = 0;
5583 parser->m_groupConnector[parser->m_prologState.level] = 0;
5585 int myindex = nextScaffoldPart(parser);
5592 if (parser->m_elementDeclHandler)
5597 if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_PIPE)
5599 parser->m_groupConnector[parser->m_prologState.level] = ASCII_COMMA;
5600 if (dtd->in_eldecl && parser->m_elementDeclHandler)
5604 if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_COMMA)
5607 && ! parser->m_groupConnector[parser->m_prologState.level]
5612 if (parser->m_elementDeclHandler)
5615 parser->m_groupConnector[parser->m_prologState.level] = ASCII_PIPE;
5621 if (! parser->m_paramEntityParsing)
5630 entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
5636 if (parser->m_prologState.documentEntity
5637 && (dtd->standalone ? ! parser->m_openInternalEntities
5668 && parser->m_skippedEntityHandler) {
5669 parser->m_skippedEntityHandler(parser->m_handlerArg, name, 1);
5680 result = processEntity(parser, entity, betweenDecl, ENTITY_INTERNAL);
5686 if (parser->m_externalEntityRefHandler) {
5689 entityTrackingOnOpen(parser, entity, __LINE__);
5690 if (! parser->m_externalEntityRefHandler(
5691 parser->m_externalEntityRefHandlerArg, 0, entity->base,
5693 entityTrackingOnClose(parser, entity, __LINE__);
5697 entityTrackingOnClose(parser, entity, __LINE__);
5710 if (! dtd->standalone && parser->m_notStandaloneHandler
5711 && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
5718 if (parser->m_elementDeclHandler) {
5719 parser->m_declElementType = getElementType(parser, enc, s, next);
5720 if (! parser->m_declElementType)
5732 if (parser->m_elementDeclHandler) {
5734 = (XML_Content *)MALLOC(parser, sizeof(XML_Content));
5744 parser->m_elementDeclHandler(
5745 parser->m_handlerArg, parser->m_declElementType->name, content);
5756 if (parser->m_elementDeclHandler)
5779 int myindex = nextScaffoldPart(parser);
5784 el = getElementType(parser, enc, s, nxt);
5799 if (parser->m_elementDeclHandler)
5817 if (parser->m_elementDeclHandler)
5823 XML_Content *model = build_model(parser);
5827 parser->m_elementDeclHandler(
5828 parser->m_handlerArg, parser->m_declElementType->name, model);
5838 if (! reportProcessingInstruction(parser, enc, s, next))
5843 if (! reportComment(parser, enc, s, next))
5855 if (parser->m_startDoctypeDeclHandler)
5859 if (dtd->keepProcessing && parser->m_entityDeclHandler)
5863 if (parser->m_notationDeclHandler)
5867 if (dtd->keepProcessing && parser->m_attlistDeclHandler)
5871 if (parser->m_elementDeclHandler)
5876 if (handleDefault && parser->m_defaultHandler)
5877 reportDefault(parser, enc, s, next);
5879 switch (parser->m_parsingStatus.parsing) {
5886 if (parser->m_reenter) {
5900 epilogProcessor(XML_Parser parser, const char *s, const char *end,
5902 parser->m_processor = epilogProcessor;
5903 parser->m_eventPtr = s;
5906 int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
5908 if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
5910 accountingOnAbort(parser);
5914 parser->m_eventEndPtr = next;
5918 if (parser->m_defaultHandler) {
5919 reportDefault(parser, parser->m_encoding, s, next);
5920 if (parser->m_parsingStatus.parsing == XML_FINISHED)
5929 if (parser->m_defaultHandler)
5930 reportDefault(parser, parser->m_encoding, s, next);
5933 if (! reportProcessingInstruction(parser, parser->m_encoding, s, next))
5937 if (! reportComment(parser, parser->m_encoding, s, next))
5941 parser->m_eventPtr = next;
5944 if (! parser->m_parsingStatus.finalBuffer) {
5950 if (! parser->m_parsingStatus.finalBuffer) {
5958 switch (parser->m_parsingStatus.parsing) {
5960 parser->m_eventPtr = next;
5964 parser->m_eventPtr = next;
5967 if (parser->m_reenter) {
5972 parser->m_eventPtr = s = next;
5978 processEntity(XML_Parser parser, ENTITY *entity, XML_Bool betweenDecl,
5983 parser->m_processor = internalEntityProcessor;
5984 openEntityList = &parser->m_openInternalEntities;
5985 freeEntityList = &parser->m_freeInternalEntities;
5988 openEntityList = &parser->m_openAttributeEntities;
5989 freeEntityList = &parser->m_freeAttributeEntities;
5992 openEntityList = &parser->m_openValueEntities;
5993 freeEntityList = &parser->m_freeValueEntities;
6012 = (OPEN_INTERNAL_ENTITY *)MALLOC(parser, sizeof(OPEN_INTERNAL_ENTITY));
6019 entityTrackingOnOpen(parser, entity, __LINE__);
6026 openEntity->startTagLevel = parser->m_tagLevel;
6034 triggerReenter(parser);
6040 internalEntityProcessor(XML_Parser parser, const char *s, const char *end,
6049 OPEN_INTERNAL_ENTITY *openEntity = parser->m_openInternalEntities;
6064 = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
6065 result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
6069 result = doContent(parser, openEntity->startTagLevel,
6070 parser->m_internalEncoding, textStart, textEnd, &next,
6079 && (parser->m_parsingStatus.parsing == XML_SUSPENDED
6080 || (parser->m_parsingStatus.parsing == XML_PARSING
6081 && parser->m_reenter))) {
6090 triggerReenter(parser);
6096 entityTrackingOnClose(parser, entity, __LINE__);
6102 assert(parser->m_openInternalEntities == openEntity);
6104 parser->m_openInternalEntities = parser->m_openInternalEntities->next;
6107 openEntity->next = parser->m_freeInternalEntities;
6108 parser->m_freeInternalEntities = openEntity;
6110 if (parser->m_openInternalEntities == NULL) {
6111 parser->m_processor = entity->is_param ? prologProcessor : contentProcessor;
6113 triggerReenter(parser);
6118 errorProcessor(XML_Parser parser, const char *s, const char *end,
6123 return parser->m_errorCode;
6127 storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
6134 if (! parser->m_openAttributeEntities) {
6135 result = appendAttributeValue(parser, enc, isCdata, next, end, pool,
6138 OPEN_INTERNAL_ENTITY *const openEntity = parser->m_openAttributeEntities;
6151 parser, parser->m_internalEncoding, isCdata, textStart, textEnd,
6157 // appendAttributeValue will never suspend the parser.
6173 entityTrackingOnClose(parser, entity, __LINE__);
6179 assert(parser->m_openAttributeEntities == openEntity);
6181 parser->m_openAttributeEntities = parser->m_openAttributeEntities->next;
6184 openEntity->next = parser->m_freeAttributeEntities;
6185 parser->m_freeAttributeEntities = openEntity;
6189 if (result || (parser->m_openAttributeEntities == NULL && end == next)) {
6204 appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
6207 DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6217 if (! accountingDiffTolerated(parser, tok, ptr, next, __LINE__, account)) {
6218 accountingOnAbort(parser);
6229 if (enc == parser->m_encoding)
6230 parser->m_eventPtr = next;
6233 if (enc == parser->m_encoding)
6234 parser->m_eventPtr = ptr;
6241 if (enc == parser->m_encoding)
6242 parser->m_eventPtr = ptr;
6288 accountingDiffTolerated(parser, tok, (char *)&ch,
6296 name = poolStoreString(&parser->m_temp2Pool, enc,
6301 entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
6302 poolDiscard(&parser->m_temp2Pool);
6309 parser->m_prologState.documentEntity &&
6311 (dtd->standalone ? ! parser->m_openInternalEntities
6313 else /* if (pool == &parser->m_tempPool): we are called from content */
6322 parser->m_skippedEntityHandler.
6323 if (parser->m_skippedEntityHandler)
6324 parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
6328 if ((pool == &parser->m_tempPool) && parser->m_defaultHandler)
6329 reportDefault(parser, enc, ptr, next);
6334 if (enc == parser->m_encoding) {
6342 * sets the local encoding ("enc") to the parser's
6352 parser->m_eventPtr = ptr; /* LCOV_EXCL_LINE */
6357 if (enc == parser->m_encoding)
6358 parser->m_eventPtr = ptr;
6362 if (enc == parser->m_encoding)
6363 parser->m_eventPtr = ptr;
6367 result = processEntity(parser, entity, XML_FALSE, ENTITY_ATTRIBUTE);
6386 if (enc == parser->m_encoding)
6387 parser->m_eventPtr = ptr;
6398 storeEntityValue(XML_Parser parser, const ENCODING *enc,
6401 DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6405 int oldInEntityValue = parser->m_prologState.inEntityValue;
6406 parser->m_prologState.inEntityValue = 1;
6424 if (! accountingDiffTolerated(parser, tok, entityTextPtr, next, __LINE__,
6426 accountingOnAbort(parser);
6434 if (parser->m_isParamEntity || enc != parser->m_encoding) {
6437 name = poolStoreString(&parser->m_tempPool, enc,
6444 entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
6445 poolDiscard(&parser->m_tempPool);
6449 parser->m_skippedEntityHandler
6450 if (parser->m_skippedEntityHandler)
6451 parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
6456 if (entity->open || (entity == parser->m_declEntity)) {
6457 parser->m_encoding)
6458 parser->m_eventPtr = entityTextPtr;
6463 if (parser->m_externalEntityRefHandler) {
6466 entityTrackingOnOpen(parser, entity, __LINE__);
6467 if (! parser->m_externalEntityRefHandler(
6468 parser->m_externalEntityRefHandlerArg, 0, entity->base,
6470 entityTrackingOnClose(parser, entity, __LINE__);
6475 entityTrackingOnClose(parser, entity, __LINE__);
6482 result = processEntity(parser, entity, XML_FALSE, ENTITY_VALUE);
6490 parser->m_eventPtr = entityTextPtr;
6518 if (enc == parser->m_encoding)
6519 parser->m_eventPtr = entityTextPtr;
6542 if (enc == parser->m_encoding)
6543 parser->m_eventPtr = entityTextPtr;
6547 if (enc == parser->m_encoding)
6548 parser->m_eventPtr = next;
6559 if (enc == parser->m_encoding)
6560 parser->m_eventPtr = entityTextPtr;
6569 parser->m_prologState.inEntityValue = oldInEntityValue;
6579 callStoreEntityValue(XML_Parser parser, const ENCODING *enc,
6585 if (! parser->m_openValueEntities) {
6587 = storeEntityValue(parser, enc, next, entityTextEnd, account, &next);
6589 OPEN_INTERNAL_ENTITY *const openEntity = parser->m_openValueEntities;
6601 result = storeEntityValue(parser, parser->m_internalEncoding, textStart,
6608 // appendAttributeValue will never suspend the parser.
6624 entityTrackingOnClose(parser, entity, __LINE__);
6630 assert(parser->m_openValueEntities == openEntity);
6632 parser->m_openValueEntities = parser->m_openValueEntities->next;
6635 openEntity->next = parser->m_freeValueEntities;
6636 parser->m_freeValueEntities = openEntity;
6641 || (parser->m_openValueEntities == NULL && entityTextEnd == next)) {
6652 storeSelfEntityValue(XML_Parser parser, ENTITY *entity) {
6658 STRING_POOL *const pool = &(parser->m_dtd->entityValuePool);
6697 reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
6702 if (! parser->m_processingInstructionHandler) {
6703 if (parser->m_defaultHandler)
6704 reportDefault(parser, enc, start, end);
6709 target = poolStoreString(&parser->m_tempPool, enc, start, tem);
6712 poolFinish(&parser->m_tempPool);
6713 data = poolStoreString(&parser->m_tempPool, enc, XmlSkipS(enc, tem),
6718 parser->m_processingInstructionHandler(parser->m_handlerArg, target, data);
6719 poolClear(&parser->m_tempPool);
6724 reportComment(XML_Parser parser, const ENCODING *enc, const char *start,
6727 if (! parser->m_commentHandler) {
6728 if (parser->m_defaultHandler)
6729 reportDefault(parser, enc, start, end);
6732 data = poolStoreString(&parser->m_tempPool, enc,
6738 parser->m_commentHandler(parser->m_handlerArg, data);
6739 poolClear(&parser->m_tempPool);
6744 reportDefault(XML_Parser parser, const ENCODING *enc, const char *s,
6750 if (enc == parser->m_encoding) {
6751 eventPP = &parser->m_eventPtr;
6752 eventEndPP = &parser->m_eventEndPtr;
6754 /* To get here, two things must be true; the parser must be
6759 * in is not the same as the parser's encoding are when it is
6770 eventPP = &(parser->m_openInternalEntities->internalEventPtr);
6771 eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
6775 ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
6777 = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
6779 parser->m_defaultHandler(parser->m_handlerArg, parser->m_dataBuf,
6780 (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
6785 parser->m_defaultHandler(
6786 parser->m_handlerArg, (const XML_Char *)s,
6792 XML_Bool isId, const XML_Char *value, XML_Parser parser) {
6808 parser, type->allocDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
6833 temp = (DEFAULT_ATTRIBUTE *)REALLOC(parser, type->defaultAtts,
6852 setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType) {
6853 DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6865 prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
6881 getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,
6883 DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6893 id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name,
6901 if (! parser->m_ns)
6910 id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6,
6925 id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes,
6944 getContext(XML_Parser parser) {
6945 DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6952 if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
6955 if (parser->m_namespaceSeparator)
6958 if (! poolAppendChar(&parser->m_tempPool,
6964 * URI into the parser's temporary string pool. Previously,
7002 if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
7005 if (! poolAppendChar(&parser->m_tempPool, *s))
7007 if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
7010 if (parser->m_namespaceSeparator)
7013 if (! poolAppendChar(&parser->m_tempPool, prefix->binding->uri[i]))
7026 if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
7029 if (! poolAppendChar(&parser->m_tempPool, *s))
7034 if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
7036 return parser->m_tempPool.start;
7040 setContext(XML_Parser parser, const XML_Char *context) {
7045 DTD *const dtd = parser->m_dtd; /* save one level of indirection */
7051 if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
7053 e = (ENTITY *)lookup(parser, &dtd->generalEntities,
7054 poolStart(&parser->m_tempPool), 0);
7060 poolDiscard(&parser->m_tempPool);
7063 if (poolLength(&parser->m_tempPool) == 0)
7066 if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
7069 = (PREFIX *)lookup(parser, &dtd->prefixes,
7070 poolStart(&parser->m_tempPool), sizeof(PREFIX));
7073 if (prefix->name == poolStart(&parser->m_tempPool)) {
7078 poolDiscard(&parser->m_tempPool);
7082 if (! poolAppendChar(&parser->m_tempPool, *context))
7084 if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
7086 if (addBinding(parser, prefix, NULL, poolStart(&parser->m_tempPool),
7087 &parser->m_inheritedBindings)
7090 poolDiscard(&parser->m_tempPool);
7095 if (! poolAppendChar(&parser->m_tempPool, *s))
7445 copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key) {
7447 key->k[1] = get_hash_secret_salt(parser);
7451 hash(XML_Parser parser, KEY s) {
7455 copy_salt_to_sipkey(parser, &key);
7462 lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize) {
7478 i = hash(parser, name) & ((unsigned long)table->size - 1);
7480 unsigned long h = hash(parser, name);
7518 unsigned long newHash = hash(parser, table->v[i]->name);
7845 nextScaffoldPart(XML_Parser parser) {
7846 DTD *const dtd = parser->m_dtd; /* save one level of indirection */
7856 if (parser->m_groupSize > ((size_t)(-1) / sizeof(int))) {
7860 dtd->scaffIndex = (int *)MALLOC(parser, parser->m_groupSize * sizeof(int));
7884 parser, dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
7889 temp = (CONTENT_SCAFFOLD *)MALLOC(parser, INIT_SCAFFOLD_ELEMENTS
7915 build_model(XML_Parser parser) {
7916 /* Function build_model transforms the existing parser->m_dtd->scaffold
7920 DTD *const dtd = parser->m_dtd; /* save one level of indirection */
7944 ret = (XML_Content *)MALLOC(parser, allocsize);
8042 getElementType(XML_Parser parser, const ENCODING *enc, const char *ptr,
8044 DTD *const dtd = parser->m_dtd; /* save one level of indirection */
8050 ret = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
8058 if (! setElementTypePrefix(parser, ret))
8222 testingAccountingGetCountBytesDirect(XML_Parser parser) {
8223 if (! parser)
8225 return parser->m_accounting.countBytesDirect;
8229 testingAccountingGetCountBytesIndirect(XML_Parser parser) {
8230 if (! parser)
8232 return parser->m_accounting.countBytesIndirect;
8284 getRootParserOf(XML_Parser parser, unsigned int *outLevelDiff) {
8285 XML_Parser rootParser = parser;
Indexes created Sun Mar 01 05:31:48 UTC 2026