xref: /third_party/python/Modules/expat/xmlparse.c

7                                  |_| XML parser
219 static void copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key);
282    A parser re-uses these structures, maintaining a list of allocated
405   XML_ACCOUNT_DIRECT,           /* bytes directly passed to the Expat parser */
429 typedef enum XML_Error PTRCALL Processor(XML_Parser parser, const char *start,
451 static enum XML_Error handleUnknownEncoding(XML_Parser parser,
453 static enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
455 static enum XML_Error initializeEncoding(XML_Parser parser);
456 static enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc,
461 static enum XML_Error processInternalEntity(XML_Parser parser, ENTITY *entity,
463 static enum XML_Error doContent(XML_Parser parser, int startTagLevel,
467 static enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *,
472 static enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *,
477 static void freeBindings(XML_Parser parser, BINDING *bindings);
478 static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *,
482 static enum XML_Error addBinding(XML_Parser parser, PREFIX *prefix,
487                            XML_Parser parser);
488 static enum XML_Error storeAttributeValue(XML_Parser parser, const ENCODING *,
492 static enum XML_Error appendAttributeValue(XML_Parser parser, const ENCODING *,
496 static ATTRIBUTE_ID *getAttributeId(XML_Parser parser, const ENCODING *enc,
498 static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
499 static enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc,
502 static int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
504 static int reportComment(XML_Parser parser, const ENCODING *enc,
506 static void reportDefault(XML_Parser parser, const ENCODING *enc,
509 static const XML_Char *getContext(XML_Parser parser);
510 static XML_Bool setContext(XML_Parser parser, const XML_Char *context);
523 static NAMED *lookup(XML_Parser parser, HASH_TABLE *table, KEY name,
548 static int FASTCALL nextScaffoldPart(XML_Parser parser);
549 static XML_Content *build_model(XML_Parser parser);
550 static ELEMENT_TYPE *getElementType(XML_Parser parser, const ENCODING *enc,
556 static unsigned long generate_hash_secret_salt(XML_Parser parser);
557 static XML_Bool startParsing(XML_Parser parser);
563 static void parserInit(XML_Parser parser, const XML_Char *encodingName);
579 static void entityTrackingReportStats(XML_Parser parser, ENTITY *entity,
581 static void entityTrackingOnOpen(XML_Parser parser, ENTITY *entity,
583 static void entityTrackingOnClose(XML_Parser parser, ENTITY *entity,
586 static XML_Parser getRootParserOf(XML_Parser parser,
712 #define MALLOC(parser, s) (parser->m_mem.malloc_fcn((s)))
713 #define REALLOC(parser, p, s) (parser->m_mem.realloc_fcn((p), (s)))
714 #define FREE(parser, p) (parser->m_mem.free_fcn((p)))
902 generate_hash_secret_salt(XML_Parser parser) {
904   (void)parser;
945 get_hash_secret_salt(XML_Parser parser) {
946   if (parser->m_parentParser != NULL)
947     return get_hash_secret_salt(parser->m_parentParser);
948   return parser->m_hash_secret_salt;
951 static XML_Bool /* only valid for root parser */
952 startParsing(XML_Parser parser) {
954   if (parser->m_hash_secret_salt == 0)
955     parser->m_hash_secret_salt = generate_hash_secret_salt(parser);
956   if (parser->m_ns) {
957     /* implicit context only set for root parser, since child
960     return setContext(parser, implicitContext);
976   XML_Parser parser;
980     parser = memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));
981     if (parser != NULL) {
982       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
989     parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));
990     if (parser != NULL) {
991       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
998   if (! parser)
999     return parser;
1001   parser->m_buffer = NULL;
1002   parser->m_bufferLim = NULL;
1004   parser->m_attsSize = INIT_ATTS_SIZE;
1005   parser->m_atts
1006       = (ATTRIBUTE *)MALLOC(parser, parser->m_attsSize * sizeof(ATTRIBUTE));
1007   if (parser->m_atts == NULL) {
1008     FREE(parser, parser);
1012   parser->m_attInfo = (XML_AttrInfo *)MALLOC(
1013       parser, parser->m_attsSize * sizeof(XML_AttrInfo));
1014   if (parser->m_attInfo == NULL) {
1015     FREE(parser, parser->m_atts);
1016     FREE(parser, parser);
1020   parser->m_dataBuf
1021       = (XML_Char *)MALLOC(parser, INIT_DATA_BUF_SIZE * sizeof(XML_Char));
1022   if (parser->m_dataBuf == NULL) {
1023     FREE(parser, parser->m_atts);
1025     FREE(parser, parser->m_attInfo);
1027     FREE(parser, parser);
1030   parser->m_dataBufEnd = parser->m_dataBuf + INIT_DATA_BUF_SIZE;
1033     parser->m_dtd = dtd;
1035     parser->m_dtd = dtdCreate(&parser->m_mem);
1036     if (parser->m_dtd == NULL) {
1037       FREE(parser, parser->m_dataBuf);
1038       FREE(parser, parser->m_atts);
1040       FREE(parser, parser->m_attInfo);
1042       FREE(parser, parser);
1047   parser->m_freeBindingList = NULL;
1048   parser->m_freeTagList = NULL;
1049   parser->m_freeInternalEntities = NULL;
1051   parser->m_groupSize = 0;
1052   parser->m_groupConnector = NULL;
1054   parser->m_unknownEncodingHandler = NULL;
1055   parser->m_unknownEncodingHandlerData = NULL;
1057   parser->m_namespaceSeparator = ASCII_EXCL;
1058   parser->m_ns = XML_FALSE;
1059   parser->m_ns_triplets = XML_FALSE;
1061   parser->m_nsAtts = NULL;
1062   parser->m_nsAttsVersion = 0;
1063   parser->m_nsAttsPower = 0;
1065   parser->m_protocolEncodingName = NULL;
1067   poolInit(&parser->m_tempPool, &(parser->m_mem));
1068   poolInit(&parser->m_temp2Pool, &(parser->m_mem));
1069   parserInit(parser, encodingName);
1071   if (encodingName && ! parser->m_protocolEncodingName) {
1074       // destroying parser->m_dtd because the DTD is shared with the parent
1075       // parser and the only guard that keeps XML_ParserFree from destroying
1076       // parser->m_dtd is parser->m_isParamEntity but it will be set to
1078       parser->m_dtd = NULL;
1080     XML_ParserFree(parser);
1085     parser->m_ns = XML_TRUE;
1086     parser->m_internalEncoding = XmlGetInternalEncodingNS();
1087     parser->m_namespaceSeparator = *nameSep;
1089     parser->m_internalEncoding = XmlGetInternalEncoding();
1092   return parser;
1096 parserInit(XML_Parser parser, const XML_Char *encodingName) {
1097   parser->m_processor = prologInitProcessor;
1098   XmlPrologStateInit(&parser->m_prologState);
1100     parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
1102   parser->m_curBase = NULL;
1103   XmlInitEncoding(&parser->m_initEncoding, &parser->m_encoding, 0);
1104   parser->m_userData = NULL;
1105   parser->m_handlerArg = NULL;
1106   parser->m_startElementHandler = NULL;
1107   parser->m_endElementHandler = NULL;
1108   parser->m_characterDataHandler = NULL;
1109   parser->m_processingInstructionHandler = NULL;
1110   parser->m_commentHandler = NULL;
1111   parser->m_startCdataSectionHandler = NULL;
1112   parser->m_endCdataSectionHandler = NULL;
1113   parser->m_defaultHandler = NULL;
1114   parser->m_startDoctypeDeclHandler = NULL;
1115   parser->m_endDoctypeDeclHandler = NULL;
1116   parser->m_unparsedEntityDeclHandler = NULL;
1117   parser->m_notationDeclHandler = NULL;
1118   parser->m_startNamespaceDeclHandler = NULL;
1119   parser->m_endNamespaceDeclHandler = NULL;
1120   parser->m_notStandaloneHandler = NULL;
1121   parser->m_externalEntityRefHandler = NULL;
1122   parser->m_externalEntityRefHandlerArg = parser;
1123   parser->m_skippedEntityHandler = NULL;
1124   parser->m_elementDeclHandler = NULL;
1125   parser->m_attlistDeclHandler = NULL;
1126   parser->m_entityDeclHandler = NULL;
1127   parser->m_xmlDeclHandler = NULL;
1128   parser->m_bufferPtr = parser->m_buffer;
1129   parser->m_bufferEnd = parser->m_buffer;
1130   parser->m_parseEndByteIndex = 0;
1131   parser->m_parseEndPtr = NULL;
1132   parser->m_declElementType = NULL;
1133   parser->m_declAttributeId = NULL;
1134   parser->m_declEntity = NULL;
1135   parser->m_doctypeName = NULL;
1136   parser->m_doctypeSysid = NULL;
1137   parser->m_doctypePubid = NULL;
1138   parser->m_declAttributeType = NULL;
1139   parser->m_declNotationName = NULL;
1140   parser->m_declNotationPublicId = NULL;
1141   parser->m_declAttributeIsCdata = XML_FALSE;
1142   parser->m_declAttributeIsId = XML_FALSE;
1143   memset(&parser->m_position, 0, sizeof(POSITION));
1144   parser->m_errorCode = XML_ERROR_NONE;
1145   parser->m_eventPtr = NULL;
1146   parser->m_eventEndPtr = NULL;
1147   parser->m_positionPtr = NULL;
1148   parser->m_openInternalEntities = NULL;
1149   parser->m_defaultExpandInternalEntities = XML_TRUE;
1150   parser->m_tagLevel = 0;
1151   parser->m_tagStack = NULL;
1152   parser->m_inheritedBindings = NULL;
1153   parser->m_nSpecifiedAtts = 0;
1154   parser->m_unknownEncodingMem = NULL;
1155   parser->m_unknownEncodingRelease = NULL;
1156   parser->m_unknownEncodingData = NULL;
1157   parser->m_parentParser = NULL;
1158   parser->m_parsingStatus.parsing = XML_INITIALIZED;
1160   parser->m_isParamEntity = XML_FALSE;
1161   parser->m_useForeignDTD = XML_FALSE;
1162   parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
1164   parser->m_hash_secret_salt = 0;
1167   memset(&parser->m_accounting, 0, sizeof(ACCOUNTING));
1168   parser->m_accounting.debugLevel = getDebugLevel("EXPAT_ACCOUNTING_DEBUG", 0u);
1169   parser->m_accounting.maximumAmplificationFactor
1171   parser->m_accounting.activationThresholdBytes
1174   memset(&parser->m_entity_stats, 0, sizeof(ENTITY_STATS));
1175   parser->m_entity_stats.debugLevel = getDebugLevel("EXPAT_ENTITY_DEBUG", 0u);
1181 moveToFreeBindingList(XML_Parser parser, BINDING *bindings) {
1185     b->nextTagBinding = parser->m_freeBindingList;
1186     parser->m_freeBindingList = b;
1191 XML_ParserReset(XML_Parser parser, const XML_Char *encodingName) {
1195   if (parser == NULL)
1198   if (parser->m_parentParser)
1201   tStk = parser->m_tagStack;
1205     tag->parent = parser->m_freeTagList;
1206     moveToFreeBindingList(parser, tag->bindings);
1208     parser->m_freeTagList = tag;
1211   openEntityList = parser->m_openInternalEntities;
1215     openEntity->next = parser->m_freeInternalEntities;
1216     parser->m_freeInternalEntities = openEntity;
1218   moveToFreeBindingList(parser, parser->m_inheritedBindings);
1219   FREE(parser, parser->m_unknownEncodingMem);
1220   if (parser->m_unknownEncodingRelease)
1221     parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
1222   poolClear(&parser->m_tempPool);
1223   poolClear(&parser->m_temp2Pool);
1224   FREE(parser, (void *)parser->m_protocolEncodingName);
1225   parser->m_protocolEncodingName = NULL;
1226   parserInit(parser, encodingName);
1227   dtdReset(parser->m_dtd, &parser->m_mem);
1232 XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName) {
1233   if (parser == NULL)
1239   if (parser->m_parsingStatus.parsing == XML_PARSING
1240       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1244   FREE(parser, (void *)parser->m_protocolEncodingName);
1248     parser->m_protocolEncodingName = NULL;
1251     parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
1252     if (! parser->m_protocolEncodingName)
1261   XML_Parser parser = oldParser;
1295   /* Note that the new parser shares the same hash secret as the old
1296      parser, so that dtdCopy and copyEntityTable can lookup values
1297      from hash tables associated with either parser without us having
1306   /* Stash the original parser contents on the stack */
1307   oldDtd = parser->m_dtd;
1308   oldStartElementHandler = parser->m_startElementHandler;
1309   oldEndElementHandler = parser->m_endElementHandler;
1310   oldCharacterDataHandler = parser->m_characterDataHandler;
1311   oldProcessingInstructionHandler = parser->m_processingInstructionHandler;
1312   oldCommentHandler = parser->m_commentHandler;
1313   oldStartCdataSectionHandler = parser->m_startCdataSectionHandler;
1314   oldEndCdataSectionHandler = parser->m_endCdataSectionHandler;
1315   oldDefaultHandler = parser->m_defaultHandler;
1316   oldUnparsedEntityDeclHandler = parser->m_unparsedEntityDeclHandler;
1317   oldNotationDeclHandler = parser->m_notationDeclHandler;
1318   oldStartNamespaceDeclHandler = parser->m_startNamespaceDeclHandler;
1319   oldEndNamespaceDeclHandler = parser->m_endNamespaceDeclHandler;
1320   oldNotStandaloneHandler = parser->m_notStandaloneHandler;
1321   oldExternalEntityRefHandler = parser->m_externalEntityRefHandler;
1322   oldSkippedEntityHandler = parser->m_skippedEntityHandler;
1323   oldUnknownEncodingHandler = parser->m_unknownEncodingHandler;
1324   oldElementDeclHandler = parser->m_elementDeclHandler;
1325   oldAttlistDeclHandler = parser->m_attlistDeclHandler;
1326   oldEntityDeclHandler = parser->m_entityDeclHandler;
1327   oldXmlDeclHandler = parser->m_xmlDeclHandler;
1328   oldDeclElementType = parser->m_declElementType;
1330   oldUserData = parser->m_userData;
1331   oldHandlerArg = parser->m_handlerArg;
1332   oldDefaultExpandInternalEntities = parser->m_defaultExpandInternalEntities;
1333   oldExternalEntityRefHandlerArg = parser->m_externalEntityRefHandlerArg;
1335   oldParamEntityParsing = parser->m_paramEntityParsing;
1336   oldInEntityValue = parser->m_prologState.inEntityValue;
1338   oldns_triplets = parser->m_ns_triplets;
1339   /* Note that the new parser shares the same hash secret as the old
1340      parser, so that dtdCopy and copyEntityTable can lookup values
1341      from hash tables associated with either parser without us having
1344   oldhash_secret_salt = parser->m_hash_secret_salt;
1352      access look more like C++ require that `parser' be overwritten
1356   if (parser->m_ns) {
1357     XML_Char tmp[2] = {parser->m_namespaceSeparator, 0};
1358     parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);
1360     parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);
1363   if (! parser)
1366   parser->m_startElementHandler = oldStartElementHandler;
1367   parser->m_endElementHandler = oldEndElementHandler;
1368   parser->m_characterDataHandler = oldCharacterDataHandler;
1369   parser->m_processingInstructionHandler = oldProcessingInstructionHandler;
1370   parser->m_commentHandler = oldCommentHandler;
1371   parser->m_startCdataSectionHandler = oldStartCdataSectionHandler;
1372   parser->m_endCdataSectionHandler = oldEndCdataSectionHandler;
1373   parser->m_defaultHandler = oldDefaultHandler;
1374   parser->m_unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;
1375   parser->m_notationDeclHandler = oldNotationDeclHandler;
1376   parser->m_startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
1377   parser->m_endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
1378   parser->m_notStandaloneHandler = oldNotStandaloneHandler;
1379   parser->m_externalEntityRefHandler = oldExternalEntityRefHandler;
1380   parser->m_skippedEntityHandler = oldSkippedEntityHandler;
1381   parser->m_unknownEncodingHandler = oldUnknownEncodingHandler;
1382   parser->m_elementDeclHandler = oldElementDeclHandler;
1383   parser->m_attlistDeclHandler = oldAttlistDeclHandler;
1384   parser->m_entityDeclHandler = oldEntityDeclHandler;
1385   parser->m_xmlDeclHandler = oldXmlDeclHandler;
1386   parser->m_declElementType = oldDeclElementType;
1387   parser->m_userData = oldUserData;
1389     parser->m_handlerArg = parser->m_userData;
1391     parser->m_handlerArg = parser;
1393     parser->m_externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
1394   parser->m_defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
1395   parser->m_ns_triplets = oldns_triplets;
1396   parser->m_hash_secret_salt = oldhash_secret_salt;
1397   parser->m_parentParser = oldParser;
1399   parser->m_paramEntityParsing = oldParamEntityParsing;
1400   parser->m_prologState.inEntityValue = oldInEntityValue;
1403     if (! dtdCopy(oldParser, parser->m_dtd, oldDtd, &parser->m_mem)
1404         || ! setContext(parser, context)) {
1405       XML_ParserFree(parser);
1408     parser->m_processor = externalEntityInitProcessor;
1411     /* The DTD instance referenced by parser->m_dtd is shared between the
1412        document's root parser and external PE parsers, therefore one does not
1415        pointers in parser->m_dtd with ones that get destroyed with the external
1416        PE parser. This would leave those prefixes with dangling pointers.
1418     parser->m_isParamEntity = XML_TRUE;
1419     XmlPrologStateInitExternalEntity(&parser->m_prologState);
1420     parser->m_processor = externalParEntInitProcessor;
1423   return parser;
1427 destroyBindings(BINDING *bindings, XML_Parser parser) {
1433     FREE(parser, b->uri);
1434     FREE(parser, b);
1439 XML_ParserFree(XML_Parser parser) {
1442   if (parser == NULL)
1445   tagList = parser->m_tagStack;
1449       if (parser->m_freeTagList == NULL)
1451       tagList = parser->m_freeTagList;
1452       parser->m_freeTagList = NULL;
1456     FREE(parser, p->buf);
1457     destroyBindings(p->bindings, parser);
1458     FREE(parser, p);
1461   entityList = parser->m_openInternalEntities;
1465       if (parser->m_freeInternalEntities == NULL)
1467       entityList = parser->m_freeInternalEntities;
1468       parser->m_freeInternalEntities = NULL;
1472     FREE(parser, openEntity);
1475   destroyBindings(parser->m_freeBindingList, parser);
1476   destroyBindings(parser->m_inheritedBindings, parser);
1477   poolDestroy(&parser->m_tempPool);
1478   poolDestroy(&parser->m_temp2Pool);
1479   FREE(parser, (void *)parser->m_protocolEncodingName);
1482      parser->m_dtd with the root parser, so we must not destroy it
1484   if (! parser->m_isParamEntity && parser->m_dtd)
1486   if (parser->m_dtd)
1488     dtdDestroy(parser->m_dtd, (XML_Bool)! parser->m_parentParser,
1489                &parser->m_mem);
1490   FREE(parser, (void *)parser->m_atts);
1492   FREE(parser, (void *)parser->m_attInfo);
1494   FREE(parser, parser->m_groupConnector);
1495   FREE(parser, parser->m_buffer);
1496   FREE(parser, parser->m_dataBuf);
1497   FREE(parser, parser->m_nsAtts);
1498   FREE(parser, parser->m_unknownEncodingMem);
1499   if (parser->m_unknownEncodingRelease)
1500     parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
1501   FREE(parser, parser);
1505 XML_UseParserAsHandlerArg(XML_Parser parser) {
1506   if (parser != NULL)
1507     parser->m_handlerArg = parser;
1511 XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD) {
1512   if (parser == NULL)
1516   if (parser->m_parsingStatus.parsing == XML_PARSING
1517       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1519   parser->m_useForeignDTD = useDTD;
1528 XML_SetReturnNSTriplet(XML_Parser parser, int do_nst) {
1529   if (parser == NULL)
1532   if (parser->m_parsingStatus.parsing == XML_PARSING
1533       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1535   parser->m_ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
1539 XML_SetUserData(XML_Parser parser, void *p) {
1540   if (parser == NULL)
1542   if (parser->m_handlerArg == parser->m_userData)
1543     parser->m_handlerArg = parser->m_userData = p;
1545     parser->m_userData = p;
1549 XML_SetBase(XML_Parser parser, const XML_Char *p) {
1550   if (parser == NULL)
1553     p = poolCopyString(&parser->m_dtd->pool, p);
1556     parser->m_curBase = p;
1558     parser->m_curBase = NULL;
1563 XML_GetBase(XML_Parser parser) {
1564   if (parser == NULL)
1566   return parser->m_curBase;
1570 XML_GetSpecifiedAttributeCount(XML_Parser parser) {
1571   if (parser == NULL)
1573   return parser->m_nSpecifiedAtts;
1577 XML_GetIdAttributeIndex(XML_Parser parser) {
1578   if (parser == NULL)
1580   return parser->m_idAttIndex;
1585 XML_GetAttributeInfo(XML_Parser parser) {
1586   if (parser == NULL)
1588   return parser->m_attInfo;
1593 XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
1595   if (parser == NULL)
1597   parser->m_startElementHandler = start;
1598   parser->m_endElementHandler = end;
1602 XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler start) {
1603   if (parser != NULL)
1604     parser->m_startElementHandler = start;
1608 XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler end) {
1609   if (parser != NULL)
1610     parser->m_endElementHandler = end;
1614 XML_SetCharacterDataHandler(XML_Parser parser,
1616   if (parser != NULL)
1617     parser->m_characterDataHandler = handler;
1621 XML_SetProcessingInstructionHandler(XML_Parser parser,
1623   if (parser != NULL)
1624     parser->m_processingInstructionHandler = handler;
1628 XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler) {
1629   if (parser != NULL)
1630     parser->m_commentHandler = handler;
1634 XML_SetCdataSectionHandler(XML_Parser parser,
1637   if (parser == NULL)
1639   parser->m_startCdataSectionHandler = start;
1640   parser->m_endCdataSectionHandler = end;
1644 XML_SetStartCdataSectionHandler(XML_Parser parser,
1646   if (parser != NULL)
1647     parser->m_startCdataSectionHandler = start;
1651 XML_SetEndCdataSectionHandler(XML_Parser parser,
1653   if (parser != NULL)
1654     parser->m_endCdataSectionHandler = end;
1658 XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler) {
1659   if (parser == NULL)
1661   parser->m_defaultHandler = handler;
1662   parser->m_defaultExpandInternalEntities = XML_FALSE;
1666 XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler) {
1667   if (parser == NULL)
1669   parser->m_defaultHandler = handler;
1670   parser->m_defaultExpandInternalEntities = XML_TRUE;
1674 XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,
1676   if (parser == NULL)
1678   parser->m_startDoctypeDeclHandler = start;
1679   parser->m_endDoctypeDeclHandler = end;
1683 XML_SetStartDoctypeDeclHandler(XML_Parser parser,
1685   if (parser != NULL)
1686     parser->m_startDoctypeDeclHandler = start;
1690 XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end) {
1691   if (parser != NULL)
1692     parser->m_endDoctypeDeclHandler = end;
1696 XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
1698   if (parser != NULL)
1699     parser->m_unparsedEntityDeclHandler = handler;
1703 XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler) {
1704   if (parser != NULL)
1705     parser->m_notationDeclHandler = handler;
1709 XML_SetNamespaceDeclHandler(XML_Parser parser,
1712   if (parser == NULL)
1714   parser->m_startNamespaceDeclHandler = start;
1715   parser->m_endNamespaceDeclHandler = end;
1719 XML_SetStartNamespaceDeclHandler(XML_Parser parser,
1721   if (parser != NULL)
1722     parser->m_startNamespaceDeclHandler = start;
1726 XML_SetEndNamespaceDeclHandler(XML_Parser parser,
1728   if (parser != NULL)
1729     parser->m_endNamespaceDeclHandler = end;
1733 XML_SetNotStandaloneHandler(XML_Parser parser,
1735   if (parser != NULL)
1736     parser->m_notStandaloneHandler = handler;
1740 XML_SetExternalEntityRefHandler(XML_Parser parser,
1742   if (parser != NULL)
1743     parser->m_externalEntityRefHandler = handler;
1747 XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg) {
1748   if (parser == NULL)
1751     parser->m_externalEntityRefHandlerArg = (XML_Parser)arg;
1753     parser->m_externalEntityRefHandlerArg = parser;
1757 XML_SetSkippedEntityHandler(XML_Parser parser,
1759   if (parser != NULL)
1760     parser->m_skippedEntityHandler = handler;
1764 XML_SetUnknownEncodingHandler(XML_Parser parser,
1766   if (parser == NULL)
1768   parser->m_unknownEncodingHandler = handler;
1769   parser->m_unknownEncodingHandlerData = data;
1773 XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl) {
1774   if (parser != NULL)
1775     parser->m_elementDeclHandler = eldecl;
1779 XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl) {
1780   if (parser != NULL)
1781     parser->m_attlistDeclHandler = attdecl;
1785 XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler) {
1786   if (parser != NULL)
1787     parser->m_entityDeclHandler = handler;
1791 XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler handler) {
1792   if (parser != NULL)
1793     parser->m_xmlDeclHandler = handler;
1797 XML_SetParamEntityParsing(XML_Parser parser,
1799   if (parser == NULL)
1802   if (parser->m_parsingStatus.parsing == XML_PARSING
1803       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1806   parser->m_paramEntityParsing = peParsing;
1814 XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt) {
1815   if (parser == NULL)
1817   if (parser->m_parentParser)
1818     return XML_SetHashSalt(parser->m_parentParser, hash_salt);
1820   if (parser->m_parsingStatus.parsing == XML_PARSING
1821       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1823   parser->m_hash_secret_salt = hash_salt;
1828 XML_Parse(XML_Parser parser, const char *s, int len, int isFinal) {
1829   if ((parser == NULL) || (len < 0) || ((s == NULL) && (len != 0))) {
1830     if (parser != NULL)
1831       parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;
1834   switch (parser->m_parsingStatus.parsing) {
1836     parser->m_errorCode = XML_ERROR_SUSPENDED;
1839     parser->m_errorCode = XML_ERROR_FINISHED;
1842     if (parser->m_parentParser == NULL && ! startParsing(parser)) {
1843       parser->m_errorCode = XML_ERROR_NO_MEMORY;
1848     parser->m_parsingStatus.parsing = XML_PARSING;
1852     parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
1855     parser->m_positionPtr = parser->m_bufferPtr;
1856     parser->m_parseEndPtr = parser->m_bufferEnd;
1862     parser->m_errorCode
1863         = parser->m_processor(parser, parser->m_bufferPtr,
1864                               parser->m_parseEndPtr, &parser->m_bufferPtr);
1866     if (parser->m_errorCode == XML_ERROR_NONE) {
1867       switch (parser->m_parsingStatus.parsing) {
1881         XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
1882                           parser->m_bufferPtr, &parser->m_position);
1883         parser->m_positionPtr = parser->m_bufferPtr;
1888         parser->m_parsingStatus.parsing = XML_FINISHED;
1894     parser->m_eventEndPtr = parser->m_eventPtr;
1895     parser->m_processor = errorProcessor;
1899   else if (parser->m_bufferPtr == parser->m_bufferEnd) {
1904     if ((XML_Size)len > ((XML_Size)-1) / 2 - parser->m_parseEndByteIndex) {
1905       parser->m_errorCode = XML_ERROR_NO_MEMORY;
1906       parser->m_eventPtr = parser->m_eventEndPtr = NULL;
1907       parser->m_processor = errorProcessor;
1910     parser->m_parseEndByteIndex += len;
1911     parser->m_positionPtr = s;
1912     parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
1914     parser->m_errorCode
1915         = parser->m_processor(parser, s, parser->m_parseEndPtr = s + len, &end);
1917     if (parser->m_errorCode != XML_ERROR_NONE) {
1918       parser->m_eventEndPtr = parser->m_eventPtr;
1919       parser->m_processor = errorProcessor;
1922       switch (parser->m_parsingStatus.parsing) {
1929           parser->m_parsingStatus.parsing = XML_FINISHED;
1938     XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, end,
1939                       &parser->m_position);
1942       if (parser->m_buffer == NULL
1943           || nLeftOver > parser->m_bufferLim - parser->m_buffer) {
1948           temp = (char *)REALLOC(parser, parser->m_buffer, bytesToAllocate);
1951           parser->m_errorCode = XML_ERROR_NO_MEMORY;
1952           parser->m_eventPtr = parser->m_eventEndPtr = NULL;
1953           parser->m_processor = errorProcessor;
1956         parser->m_buffer = temp;
1957         parser->m_bufferLim = parser->m_buffer + bytesToAllocate;
1959       memcpy(parser->m_buffer, end, nLeftOver);
1961     parser->m_bufferPtr = parser->m_buffer;
1962     parser->m_bufferEnd = parser->m_buffer + nLeftOver;
1963     parser->m_positionPtr = parser->m_bufferPtr;
1964     parser->m_parseEndPtr = parser->m_bufferEnd;
1965     parser->m_eventPtr = parser->m_bufferPtr;
1966     parser->m_eventEndPtr = parser->m_bufferPtr;
1971     void *buff = XML_GetBuffer(parser, len);
1976       return XML_ParseBuffer(parser, len, isFinal);
1982 XML_ParseBuffer(XML_Parser parser, int len, int isFinal) {
1986   if (parser == NULL)
1988   switch (parser->m_parsingStatus.parsing) {
1990     parser->m_errorCode = XML_ERROR_SUSPENDED;
1993     parser->m_errorCode = XML_ERROR_FINISHED;
1997     if (! parser->m_bufferPtr) {
1998       parser->m_errorCode = XML_ERROR_NO_BUFFER;
2002     if (parser->m_parentParser == NULL && ! startParsing(parser)) {
2003       parser->m_errorCode = XML_ERROR_NO_MEMORY;
2008     parser->m_parsingStatus.parsing = XML_PARSING;
2011   start = parser->m_bufferPtr;
2012   parser->m_positionPtr = start;
2013   parser->m_bufferEnd += len;
2014   parser->m_parseEndPtr = parser->m_bufferEnd;
2015   parser->m_parseEndByteIndex += len;
2016   parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
2018   parser->m_errorCode = parser->m_processor(
2019       parser, start, parser->m_parseEndPtr, &parser->m_bufferPtr);
2021   if (parser->m_errorCode != XML_ERROR_NONE) {
2022     parser->m_eventEndPtr = parser->m_eventPtr;
2023     parser->m_processor = errorProcessor;
2026     switch (parser->m_parsingStatus.parsing) {
2033         parser->m_parsingStatus.parsing = XML_FINISHED;
2040   XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2041                     parser->m_bufferPtr, &parser->m_position);
2042   parser->m_positionPtr = parser->m_bufferPtr;
2047 XML_GetBuffer(XML_Parser parser, int len) {
2048   if (parser == NULL)
2051     parser->m_errorCode = XML_ERROR_NO_MEMORY;
2054   switch (parser->m_parsingStatus.parsing) {
2056     parser->m_errorCode = XML_ERROR_SUSPENDED;
2059     parser->m_errorCode = XML_ERROR_FINISHED;
2064   if (len > EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd)) {
2071                                parser->m_bufferEnd, parser->m_bufferPtr));
2073       parser->m_errorCode = XML_ERROR_NO_MEMORY;
2077     keep = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);
2082       parser->m_errorCode = XML_ERROR_NO_MEMORY;
2088         <= EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer)) {
2090       if (keep < EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)) {
2092             = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)
2096         memmove(parser->m_buffer, &parser->m_buffer[offset],
2097                 parser->m_bufferEnd - parser->m_bufferPtr + keep);
2098         parser->m_bufferEnd -= offset;
2099         parser->m_bufferPtr -= offset;
2102       if (parser->m_buffer && parser->m_bufferPtr) {
2103         memmove(parser->m_buffer, parser->m_bufferPtr,
2104                 EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
2105         parser->m_bufferEnd
2106             = parser->m_buffer
2107               + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
2108         parser->m_bufferPtr = parser->m_buffer;
2114           = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferPtr);
2122         parser->m_errorCode = XML_ERROR_NO_MEMORY;
2125       newBuf = (char *)MALLOC(parser, bufferSize);
2127         parser->m_errorCode = XML_ERROR_NO_MEMORY;
2130       parser->m_bufferLim = newBuf + bufferSize;
2132       if (parser->m_bufferPtr) {
2133         memcpy(newBuf, &parser->m_bufferPtr[-keep],
2134                EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
2136         FREE(parser, parser->m_buffer);
2137         parser->m_buffer = newBuf;
2138         parser->m_bufferEnd
2139             = parser->m_buffer
2140               + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
2142         parser->m_bufferPtr = parser->m_buffer + keep;
2145         parser->m_bufferEnd = newBuf;
2146         parser->m_bufferPtr = parser->m_buffer = newBuf;
2149       if (parser->m_bufferPtr) {
2150         memcpy(newBuf, parser->m_bufferPtr,
2151                EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
2152         FREE(parser, parser->m_buffer);
2153         parser->m_bufferEnd
2155               + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
2158         parser->m_bufferEnd = newBuf;
2160       parser->m_bufferPtr = parser->m_buffer = newBuf;
2163     parser->m_eventPtr = parser->m_eventEndPtr = NULL;
2164     parser->m_positionPtr = NULL;
2166   return parser->m_bufferEnd;
2170 XML_StopParser(XML_Parser parser, XML_Bool resumable) {
2171   if (parser == NULL)
2173   switch (parser->m_parsingStatus.parsing) {
2176       parser->m_errorCode = XML_ERROR_SUSPENDED;
2179     parser->m_parsingStatus.parsing = XML_FINISHED;
2182     parser->m_errorCode = XML_ERROR_FINISHED;
2187       if (parser->m_isParamEntity) {
2188         parser->m_errorCode = XML_ERROR_SUSPEND_PE;
2192       parser->m_parsingStatus.parsing = XML_SUSPENDED;
2194       parser->m_parsingStatus.parsing = XML_FINISHED;
2200 XML_ResumeParser(XML_Parser parser) {
2203   if (parser == NULL)
2205   if (parser->m_parsingStatus.parsing != XML_SUSPENDED) {
2206     parser->m_errorCode = XML_ERROR_NOT_SUSPENDED;
2209   parser->m_parsingStatus.parsing = XML_PARSING;
2211   parser->m_errorCode = parser->m_processor(
2212       parser, parser->m_bufferPtr, parser->m_parseEndPtr, &parser->m_bufferPtr);
2214   if (parser->m_errorCode != XML_ERROR_NONE) {
2215     parser->m_eventEndPtr = parser->m_eventPtr;
2216     parser->m_processor = errorProcessor;
2219     switch (parser->m_parsingStatus.parsing) {
2225       if (parser->m_parsingStatus.finalBuffer) {
2226         parser->m_parsingStatus.parsing = XML_FINISHED;
2233   XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2234                     parser->m_bufferPtr, &parser->m_position);
2235   parser->m_positionPtr = parser->m_bufferPtr;
2240 XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status) {
2241   if (parser == NULL)
2244   *status = parser->m_parsingStatus;
2248 XML_GetErrorCode(XML_Parser parser) {
2249   if (parser == NULL)
2251   return parser->m_errorCode;
2255 XML_GetCurrentByteIndex(XML_Parser parser) {
2256   if (parser == NULL)
2258   if (parser->m_eventPtr)
2259     return (XML_Index)(parser->m_parseEndByteIndex
2260                        - (parser->m_parseEndPtr - parser->m_eventPtr));
2265 XML_GetCurrentByteCount(XML_Parser parser) {
2266   if (parser == NULL)
2268   if (parser->m_eventEndPtr && parser->m_eventPtr)
2269     return (int)(parser->m_eventEndPtr - parser->m_eventPtr);
2274 XML_GetInputContext(XML_Parser parser, int *offset, int *size) {
2276   if (parser == NULL)
2278   if (parser->m_eventPtr && parser->m_buffer) {
2280       *offset = (int)(parser->m_eventPtr - parser->m_buffer);
2282       *size = (int)(parser->m_bufferEnd - parser->m_buffer);
2283     return parser->m_buffer;
2286   (void)parser;
2294 XML_GetCurrentLineNumber(XML_Parser parser) {
2295   if (parser == NULL)
2297   if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
2298     XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2299                       parser->m_eventPtr, &parser->m_position);
2300     parser->m_positionPtr = parser->m_eventPtr;
2302   return parser->m_position.lineNumber + 1;
2306 XML_GetCurrentColumnNumber(XML_Parser parser) {
2307   if (parser == NULL)
2309   if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
2310     XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2311                       parser->m_eventPtr, &parser->m_position);
2312     parser->m_positionPtr = parser->m_eventPtr;
2314   return parser->m_position.columnNumber;
2318 XML_FreeContentModel(XML_Parser parser, XML_Content *model) {
2319   if (parser != NULL)
2320     FREE(parser, model);
2324 XML_MemMalloc(XML_Parser parser, size_t size) {
2325   if (parser == NULL)
2327   return MALLOC(parser, size);
2331 XML_MemRealloc(XML_Parser parser, void *ptr, size_t size) {
2332   if (parser == NULL)
2334   return REALLOC(parser, ptr, size);
2338 XML_MemFree(XML_Parser parser, void *ptr) {
2339   if (parser != NULL)
2340     FREE(parser, ptr);
2344 XML_DefaultCurrent(XML_Parser parser) {
2345   if (parser == NULL)
2347   if (parser->m_defaultHandler) {
2348     if (parser->m_openInternalEntities)
2349       reportDefault(parser, parser->m_internalEncoding,
2350                     parser->m_openInternalEntities->internalEventPtr,
2351                     parser->m_openInternalEntities->internalEventEndPtr);
2353       reportDefault(parser, parser->m_encoding, parser->m_eventPtr,
2354                     parser->m_eventEndPtr);
2408     return XML_L("unexpected parser state - please send a bug report");
2430     return XML_L("parser suspended");
2432     return XML_L("parser not suspended");
2543     XML_Parser parser, float maximumAmplificationFactor) {
2544   if ((parser == NULL) || (parser->m_parentParser != NULL)
2549   parser->m_accounting.maximumAmplificationFactor = maximumAmplificationFactor;
2555     XML_Parser parser, unsigned long long activationThresholdBytes) {
2556   if ((parser == NULL) || (parser->m_parentParser != NULL)) {
2559   parser->m_accounting.activationThresholdBytes = activationThresholdBytes;
2570 storeRawNames(XML_Parser parser) {
2571   TAG *tag = parser->m_tagStack;
2593       char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
2619 contentProcessor(XML_Parser parser, const char *start, const char *end,
2622       parser, 0, parser->m_encoding, start, end, endPtr,
2623       (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_ACCOUNT_DIRECT);
2625     if (! storeRawNames(parser))
2632 externalEntityInitProcessor(XML_Parser parser, const char *start,
2634   enum XML_Error result = initializeEncoding(parser);
2637   parser->m_processor = externalEntityInitProcessor2;
2638   return externalEntityInitProcessor2(parser, start, end, endPtr);
2642 externalEntityInitProcessor2(XML_Parser parser, const char *start,
2645   int tok = XmlContentTok(parser->m_encoding, start, end, &next);
2649     if (! accountingDiffTolerated(parser, tok, start, next, __LINE__,
2651       accountingOnAbort(parser);
2661     if (next == end && ! parser->m_parsingStatus.finalBuffer) {
2668     if (! parser->m_parsingStatus.finalBuffer) {
2672     parser->m_eventPtr = start;
2675     if (! parser->m_parsingStatus.finalBuffer) {
2679     parser->m_eventPtr = start;
2682   parser->m_processor = externalEntityInitProcessor3;
2683   return externalEntityInitProcessor3(parser, start, end, endPtr);
2687 externalEntityInitProcessor3(XML_Parser parser, const char *start,
2691   parser->m_eventPtr = start;
2692   tok = XmlContentTok(parser->m_encoding, start, end, &next);
2697   parser->m_eventEndPtr = next;
2702     result = processXmlDecl(parser, 1, start, next);
2705     switch (parser->m_parsingStatus.parsing) {
2716     if (! parser->m_parsingStatus.finalBuffer) {
2722     if (! parser->m_parsingStatus.finalBuffer) {
2728   parser->m_processor = externalEntityContentProcessor;
2729   parser->m_tagLevel = 1;
2730   return externalEntityContentProcessor(parser, start, end, endPtr);
2734 externalEntityContentProcessor(XML_Parser parser, const char *start,
2737       = doContent(parser, 1, parser->m_encoding, start, end, endPtr,
2738                   (XML_Bool)! parser->m_parsingStatus.finalBuffer,
2741     if (! storeRawNames(parser))
2748 doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
2752   DTD *const dtd = parser->m_dtd;
2756   if (enc == parser->m_encoding) {
2757     eventPP = &parser->m_eventPtr;
2758     eventEndPP = &parser->m_eventEndPtr;
2760     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
2761     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
2773     if (! accountingDiffTolerated(parser, tok, s, accountAfter, __LINE__,
2775       accountingOnAbort(parser);
2787       if (parser->m_characterDataHandler) {
2789         parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
2790       } else if (parser->m_defaultHandler)
2791         reportDefault(parser, enc, s, end);
2797       if (parser->m_tagLevel != startTagLevel)
2807         if (parser->m_tagLevel != startTagLevel)
2838         accountingDiffTolerated(parser, tok, (char *)&ch,
2842         if (parser->m_characterDataHandler)
2843           parser->m_characterDataHandler(parser->m_handlerArg, &ch, 1);
2844         else if (parser->m_defaultHandler)
2845           reportDefault(parser, enc, s, next);
2852       entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
2864         if (parser->m_skippedEntityHandler)
2865           parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
2866         else if (parser->m_defaultHandler)
2867           reportDefault(parser, enc, s, next);
2876         if (! parser->m_defaultExpandInternalEntities) {
2877           if (parser->m_skippedEntityHandler)
2878             parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name,
2880           else if (parser->m_defaultHandler)
2881             reportDefault(parser, enc, s, next);
2884         result = processInternalEntity(parser, entity, XML_FALSE);
2887       } else if (parser->m_externalEntityRefHandler) {
2890         context = getContext(parser);
2894         if (! parser->m_externalEntityRefHandler(
2895                 parser->m_externalEntityRefHandlerArg, context, entity->base,
2898         poolDiscard(&parser->m_tempPool);
2899       } else if (parser->m_defaultHandler)
2900         reportDefault(parser, enc, s, next);
2909       if (parser->m_freeTagList) {
2910         tag = parser->m_freeTagList;
2911         parser->m_freeTagList = parser->m_freeTagList->parent;
2913         tag = (TAG *)MALLOC(parser, sizeof(TAG));
2916         tag->buf = (char *)MALLOC(parser, INIT_TAG_BUF_SIZE);
2918           FREE(parser, tag);
2924       tag->parent = parser->m_tagStack;
2925       parser->m_tagStack = tag;
2930       ++parser->m_tagLevel;
2949             char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
2961           = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings), account);
2964       if (parser->m_startElementHandler)
2965         parser->m_startElementHandler(parser->m_handlerArg, tag->name.str,
2966                                       (const XML_Char **)parser->m_atts);
2967       else if (parser->m_defaultHandler)
2968         reportDefault(parser, enc, s, next);
2969       poolClear(&parser->m_tempPool);
2980       name.str = poolStoreString(&parser->m_tempPool, enc, rawName,
2984       poolFinish(&parser->m_tempPool);
2985       result = storeAtts(parser, enc, s, &name, &bindings,
2988         freeBindings(parser, bindings);
2991       poolFinish(&parser->m_tempPool);
2992       if (parser->m_startElementHandler) {
2993         parser->m_startElementHandler(parser->m_handlerArg, name.str,
2994                                       (const XML_Char **)parser->m_atts);
2997       if (parser->m_endElementHandler) {
2998         if (parser->m_startElementHandler)
3000         parser->m_endElementHandler(parser->m_handlerArg, name.str);
3003       if (noElmHandlers && parser->m_defaultHandler)
3004         reportDefault(parser, enc, s, next);
3005       poolClear(&parser->m_tempPool);
3006       freeBindings(parser, bindings);
3008       if ((parser->m_tagLevel == 0)
3009           && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
3010         if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
3011           parser->m_processor = epilogProcessor;
3013           return epilogProcessor(parser, next, end, nextPtr);
3017       if (parser->m_tagLevel == startTagLevel)
3022         TAG *tag = parser->m_tagStack;
3030         parser->m_tagStack = tag->parent;
3031         tag->parent = parser->m_freeTagList;
3032         parser->m_freeTagList = tag;
3033         --parser->m_tagLevel;
3034         if (parser->m_endElementHandler) {
3039           if (parser->m_ns && localPart) {
3049             if (parser->m_ns_triplets && prefix) {
3050               *uri++ = parser->m_namespaceSeparator;
3056           parser->m_endElementHandler(parser->m_handlerArg, tag->name.str);
3057         } else if (parser->m_defaultHandler)
3058           reportDefault(parser, enc, s, next);
3061           if (parser->m_endNamespaceDeclHandler)
3062             parser->m_endNamespaceDeclHandler(parser->m_handlerArg,
3065           b->nextTagBinding = parser->m_freeBindingList;
3066           parser->m_freeBindingList = b;
3069         if ((parser->m_tagLevel == 0)
3070             && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
3071           if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
3072             parser->m_processor = epilogProcessor;
3074             return epilogProcessor(parser, next, end, nextPtr);
3082       if (parser->m_characterDataHandler) {
3084         parser->m_characterDataHandler(parser->m_handlerArg, buf,
3086       } else if (parser->m_defaultHandler)
3087         reportDefault(parser, enc, s, next);
3092       if (parser->m_characterDataHandler) {
3094         parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
3095       } else if (parser->m_defaultHandler)
3096         reportDefault(parser, enc, s, next);
3100       if (parser->m_startCdataSectionHandler)
3101         parser->m_startCdataSectionHandler(parser->m_handlerArg);
3115       else if (0 && parser->m_characterDataHandler)
3116         parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
3119       else if (parser->m_defaultHandler)
3120         reportDefault(parser, enc, s, next);
3122           = doCdataSection(parser, enc, &next, end, nextPtr, haveMore, account);
3126         parser->m_processor = cdataSectionProcessor;
3135       if (parser->m_characterDataHandler) {
3137           ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
3138           XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
3139           parser->m_characterDataHandler(
3140               parser->m_handlerArg, parser->m_dataBuf,
3141               (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
3143           parser->m_characterDataHandler(
3144               parser->m_handlerArg, (XML_Char *)s,
3146       } else if (parser->m_defaultHandler)
3147         reportDefault(parser, enc, s, end);
3155       if (parser->m_tagLevel != startTagLevel) {
3162       XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
3166             ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
3168                 enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
3170             charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
3171                             (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
3178           charDataHandler(parser->m_handlerArg, (XML_Char *)s,
3180       } else if (parser->m_defaultHandler)
3181         reportDefault(parser, enc, s, next);
3184       if (! reportProcessingInstruction(parser, enc, s, next))
3188       if (! reportComment(parser, enc, s, next))
3199       if (parser->m_defaultHandler)
3200         reportDefault(parser, enc, s, next);
3205     switch (parser->m_parsingStatus.parsing) {
3218  * moving it to the parser's m_freeBindingList where it can be freed or
3222 freeBindings(XML_Parser parser, BINDING *bindings) {
3229     if (parser->m_endNamespaceDeclHandler)
3230       parser->m_endNamespaceDeclHandler(parser->m_handlerArg, b->prefix->name);
3233     b->nextTagBinding = parser->m_freeBindingList;
3234     parser->m_freeBindingList = b;
3250 storeAtts(XML_Parser parser, const ENCODING *enc, const char *attStr,
3253   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
3268       = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str, 0);
3273     elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
3277     if (parser->m_ns && ! setElementTypePrefix(parser, elementType))
3283   n = XmlGetAttributes(enc, attStr, parser->m_attsSize, parser->m_atts);
3290   if (n + nDefaultAtts > parser->m_attsSize) {
3291     int oldAttsSize = parser->m_attsSize;
3303     parser->m_attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
3310     if ((unsigned)parser->m_attsSize > (size_t)(-1) / sizeof(ATTRIBUTE)) {
3311       parser->m_attsSize = oldAttsSize;
3316     temp = (ATTRIBUTE *)REALLOC(parser, (void *)parser->m_atts,
3317                                 parser->m_attsSize * sizeof(ATTRIBUTE));
3319       parser->m_attsSize = oldAttsSize;
3322     parser->m_atts = temp;
3329     if ((unsigned)parser->m_attsSize > (size_t)(-1) / sizeof(XML_AttrInfo)) {
3330       parser->m_attsSize = oldAttsSize;
3335     temp2 = (XML_AttrInfo *)REALLOC(parser, (void *)parser->m_attInfo,
3336                                     parser->m_attsSize * sizeof(XML_AttrInfo));
3338       parser->m_attsSize = oldAttsSize;
3341     parser->m_attInfo = temp2;
3344       XmlGetAttributes(enc, attStr, n, parser->m_atts);
3347   appAtts = (const XML_Char **)parser->m_atts;
3349     ATTRIBUTE *currAtt = &parser->m_atts[i];
3351     XML_AttrInfo *currAttInfo = &parser->m_attInfo[i];
3355         = getAttributeId(parser, enc, currAtt->name,
3361         = parser->m_parseEndByteIndex - (parser->m_parseEndPtr - currAtt->name);
3364     currAttInfo->valueStart = parser->m_parseEndByteIndex
3365                               - (parser->m_parseEndPtr - currAtt->valuePtr);
3366     currAttInfo->valueEnd = parser->m_parseEndByteIndex
3367                             - (parser->m_parseEndPtr - currAtt->valueEnd);
3374       if (enc == parser->m_encoding)
3375         parser->m_eventPtr = parser->m_atts[i].name;
3380     if (! parser->m_atts[i].normalized) {
3397           parser, enc, isCdata, parser->m_atts[i].valuePtr,
3398           parser->m_atts[i].valueEnd, &parser->m_tempPool, account);
3401       appAtts[attIndex] = poolStart(&parser->m_tempPool);
3402       poolFinish(&parser->m_tempPool);
3405       appAtts[attIndex] = poolStoreString(&parser->m_tempPool, enc,
3406                                           parser->m_atts[i].valuePtr,
3407                                           parser->m_atts[i].valueEnd);
3410       poolFinish(&parser->m_tempPool);
3416         enum XML_Error result = addBinding(parser, attId->prefix, attId,
3432   parser->m_nSpecifiedAtts = attIndex;
3436         parser->m_idAttIndex = i;
3440     parser->m_idAttIndex = -1;
3448           enum XML_Error result = addBinding(parser, da->id->prefix, da->id,
3472     unsigned long version = parser->m_nsAttsVersion;
3475     if (parser->m_nsAttsPower >= sizeof(unsigned int) * 8 /* bits per byte */) {
3479     unsigned int nsAttsSize = 1u << parser->m_nsAttsPower;
3480     unsigned char oldNsAttsPower = parser->m_nsAttsPower;
3483         >> parser->m_nsAttsPower) { /* true for m_nsAttsPower = 0 */
3486       while (nPrefixes >> parser->m_nsAttsPower++)
3488       if (parser->m_nsAttsPower < 3)
3489         parser->m_nsAttsPower = 3;
3492       if (parser->m_nsAttsPower >= sizeof(nsAttsSize) * 8 /* bits per byte */) {
3494         parser->m_nsAttsPower = oldNsAttsPower;
3498       nsAttsSize = 1u << parser->m_nsAttsPower;
3507         parser->m_nsAttsPower = oldNsAttsPower;
3512       temp = (NS_ATT *)REALLOC(parser, parser->m_nsAtts,
3516         parser->m_nsAttsPower = oldNsAttsPower;
3519       parser->m_nsAtts = temp;
3526         parser->m_nsAtts[--j].version = version;
3528     parser->m_nsAttsVersion = --version;
3540         copy_salt_to_sipkey(parser, &sip_key);
3544         id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);
3568           if (! poolAppendChar(&parser->m_tempPool, c))
3580           if (! poolAppendChar(&parser->m_tempPool, *s))
3587              Derived from code in lookup(parser, HASH_TABLE *table, ...).
3592           while (parser->m_nsAtts[j].version == version) {
3594             if (uriHash == parser->m_nsAtts[j].hash) {
3595               const XML_Char *s1 = poolStart(&parser->m_tempPool);
3596               const XML_Char *s2 = parser->m_nsAtts[j].uriName;
3604               step = PROBE_STEP(uriHash, mask, parser->m_nsAttsPower);
3609         if (parser->m_ns_triplets) { /* append namespace separator and prefix */
3610           parser->m_tempPool.ptr[-1] = parser->m_namespaceSeparator;
3613             if (! poolAppendChar(&parser->m_tempPool, *s))
3619         s = poolStart(&parser->m_tempPool);
3620         poolFinish(&parser->m_tempPool);
3624         parser->m_nsAtts[j].version = version;
3625         parser->m_nsAtts[j].hash = uriHash;
3626         parser->m_nsAtts[j].uriName = s;
3642   if (! parser->m_ns)
3659   if (parser->m_ns_triplets && binding->prefix->name) {
3694     uri = (XML_Char *)MALLOC(parser, (n + EXPAND_SPARE) * sizeof(XML_Char));
3699     for (p = parser->m_tagStack; p; p = p->parent)
3702     FREE(parser, binding->uri);
3711     *uri = parser->m_namespaceSeparator; /* replace null terminator */
3833 addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
3905     if (parser->m_ns && (uri[len] == parser->m_namespaceSeparator)
3920   if (parser->m_namespaceSeparator)
3922   if (parser->m_freeBindingList) {
3923     b = parser->m_freeBindingList;
3941           parser, b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));
3947     parser->m_freeBindingList = b->nextTagBinding;
3949     b = (BINDING *)MALLOC(parser, sizeof(BINDING));
3968         = (XML_Char *)MALLOC(parser, sizeof(XML_Char) * (len + EXPAND_SPARE));
3970       FREE(parser, b);
3977   if (parser->m_namespaceSeparator)
3978     b->uri[len - 1] = parser->m_namespaceSeparator;
3983   if (*uri == XML_T('\0') && prefix == &parser->m_dtd->defaultPrefix)
3990   if (attId && parser->m_startNamespaceDeclHandler)
3991     parser->m_startNamespaceDeclHandler(parser->m_handlerArg, prefix->name,
4000 cdataSectionProcessor(XML_Parser parser, const char *start, const char *end,
4003       parser, parser->m_encoding, &start, end, endPtr,
4004       (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_ACCOUNT_DIRECT);
4008     if (parser->m_parentParser) { /* we are parsing an external entity */
4009       parser->m_processor = externalEntityContentProcessor;
4010       return externalEntityContentProcessor(parser, start, end, endPtr);
4012       parser->m_processor = contentProcessor;
4013       return contentProcessor(parser, start, end, endPtr);
4023 doCdataSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
4029   if (enc == parser->m_encoding) {
4030     eventPP = &parser->m_eventPtr;
4032     eventEndPP = &parser->m_eventEndPtr;
4034     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
4035     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
4044     if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
4045       accountingOnAbort(parser);
4054       if (parser->m_endCdataSectionHandler)
4055         parser->m_endCdataSectionHandler(parser->m_handlerArg);
4058       else if (0 && parser->m_characterDataHandler)
4059         parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
4062       else if (parser->m_defaultHandler)
4063         reportDefault(parser, enc, s, next);
4066       if (parser->m_parsingStatus.parsing == XML_FINISHED)
4071       if (parser->m_characterDataHandler) {
4073         parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
4074       } else if (parser->m_defaultHandler)
4075         reportDefault(parser, enc, s, next);
4078       XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
4082             ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
4084                 enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
4086             charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
4087                             (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
4094           charDataHandler(parser->m_handlerArg, (XML_Char *)s,
4096       } else if (parser->m_defaultHandler)
4097         reportDefault(parser, enc, s, next);
4129     switch (parser->m_parsingStatus.parsing) {
4147 ignoreSectionProcessor(XML_Parser parser, const char *start, const char *end,
4150       = doIgnoreSection(parser, parser->m_encoding, &start, end, endPtr,
4151                         (XML_Bool)! parser->m_parsingStatus.finalBuffer);
4155     parser->m_processor = prologProcessor;
4156     return prologProcessor(parser, start, end, endPtr);
4165 doIgnoreSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
4172   if (enc == parser->m_encoding) {
4173     eventPP = &parser->m_eventPtr;
4175     eventEndPP = &parser->m_eventEndPtr;
4188     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
4189     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
4196   if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4198     accountingOnAbort(parser);
4205     if (parser->m_defaultHandler)
4206       reportDefault(parser, enc, s, next);
4209     if (parser->m_parsingStatus.parsing == XML_FINISHED)
4247 initializeEncoding(XML_Parser parser) {
4252   if (! parser->m_protocolEncodingName)
4256     for (i = 0; parser->m_protocolEncodingName[i]; i++) {
4258           || (parser->m_protocolEncodingName[i] & ~0x7f) != 0) {
4262       encodingBuf[i] = (char)parser->m_protocolEncodingName[i];
4268   s = parser->m_protocolEncodingName;
4270   if ((parser->m_ns ? XmlInitEncodingNS : XmlInitEncoding)(
4271           &parser->m_initEncoding, &parser->m_encoding, s))
4273   return handleUnknownEncoding(parser, parser->m_protocolEncodingName);
4277 processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *s,
4288   if (! accountingDiffTolerated(parser, XML_TOK_XML_DECL, s, next, __LINE__,
4290     accountingOnAbort(parser);
4295   if (! (parser->m_ns ? XmlParseXmlDeclNS : XmlParseXmlDecl)(
4296           isGeneralTextEntity, parser->m_encoding, s, next, &parser->m_eventPtr,
4304     parser->m_dtd->standalone = XML_TRUE;
4306     if (parser->m_paramEntityParsing
4308       parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
4311   if (parser->m_xmlDeclHandler) {
4314           &parser->m_temp2Pool, parser->m_encoding, encodingName,
4315           encodingName + XmlNameLength(parser->m_encoding, encodingName));
4318       poolFinish(&parser->m_temp2Pool);
4322           = poolStoreString(&parser->m_temp2Pool, parser->m_encoding, version,
4323                             versionend - parser->m_encoding->minBytesPerChar);
4327     parser->m_xmlDeclHandler(parser->m_handlerArg, storedversion, storedEncName,
4329   } else if (parser->m_defaultHandler)
4330     reportDefault(parser, parser->m_encoding, s, next);
4331   if (parser->m_protocolEncodingName == NULL) {
4334        * the parser has already deduced.  Do we have the same number
4338       if (newEncoding->minBytesPerChar != parser->m_encoding->minBytesPerChar
4340               && newEncoding != parser->m_encoding)) {
4341         parser->m_eventPtr = encodingName;
4344       parser->m_encoding = newEncoding;
4349             &parser->m_temp2Pool, parser->m_encoding, encodingName,
4350             encodingName + XmlNameLength(parser->m_encoding, encodingName));
4354       result = handleUnknownEncoding(parser, storedEncName);
4355       poolClear(&parser->m_temp2Pool);
4357         parser->m_eventPtr = encodingName;
4363     poolClear(&parser->m_temp2Pool);
4369 handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName) {
4370   if (parser->m_unknownEncodingHandler) {
4378     if (parser->m_unknownEncodingHandler(parser->m_unknownEncodingHandlerData,
4381       parser->m_unknownEncodingMem = MALLOC(parser, XmlSizeOfUnknownEncoding());
4382       if (! parser->m_unknownEncodingMem) {
4387       enc = (parser->m_ns ? XmlInitUnknownEncodingNS : XmlInitUnknownEncoding)(
4388           parser->m_unknownEncodingMem, info.map, info.convert, info.data);
4390         parser->m_unknownEncodingData = info.data;
4391         parser->m_unknownEncodingRelease = info.release;
4392         parser->m_encoding = enc;
4403 prologInitProcessor(XML_Parser parser, const char *s, const char *end,
4405   enum XML_Error result = initializeEncoding(parser);
4408   parser->m_processor = prologProcessor;
4409   return prologProcessor(parser, s, end, nextPtr);
4415 externalParEntInitProcessor(XML_Parser parser, const char *s, const char *end,
4417   enum XML_Error result = initializeEncoding(parser);
4423   parser->m_dtd->paramEntityRead = XML_TRUE;
4425   if (parser->m_prologState.inEntityValue) {
4426     parser->m_processor = entityValueInitProcessor;
4427     return entityValueInitProcessor(parser, s, end, nextPtr);
4429     parser->m_processor = externalParEntProcessor;
4430     return externalParEntProcessor(parser, s, end, nextPtr);
4435 entityValueInitProcessor(XML_Parser parser, const char *s, const char *end,
4440   parser->m_eventPtr = start;
4443     tok = XmlPrologTok(parser->m_encoding, start, end, &next);
4448     parser->m_eventEndPtr = next;
4450       if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
4466       return storeEntityValue(parser, parser->m_encoding, s, end,
4470       result = processXmlDecl(parser, 0, start, next);
4475        * to suspend the parser, which fails and raises an error.  The parser can
4478       if (parser->m_parsingStatus.parsing == XML_FINISHED)
4482       parser->m_processor = entityValueProcessor;
4483       return entityValueProcessor(parser, next, end, nextPtr);
4493              && ! parser->m_parsingStatus.finalBuffer) {
4495       if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4497         accountingOnAbort(parser);
4514     parser->m_eventPtr = start;
4519 externalParEntProcessor(XML_Parser parser, const char *s, const char *end,
4524   tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4526     if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
4548     if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4550       accountingOnAbort(parser);
4555     tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4558   parser->m_processor = prologProcessor;
4559   return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
4560                   (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
4565 entityValueProcessor(XML_Parser parser, const char *s, const char *end,
4569   const ENCODING *enc = parser->m_encoding;
4578       if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
4594       return storeEntityValue(parser, enc, s, end, XML_ACCOUNT_DIRECT);
4603 prologProcessor(XML_Parser parser, const char *s, const char *end,
4606   int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4607   return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
4608                   (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
4613 doProlog(XML_Parser parser, const ENCODING *enc, const char *s, const char *end,
4647   DTD *const dtd = parser->m_dtd;
4653   if (enc == parser->m_encoding) {
4654     eventPP = &parser->m_eventPtr;
4655     eventEndPP = &parser->m_eventEndPtr;
4657     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
4658     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
4685         if (enc != parser->m_encoding
4686             && ! parser->m_openInternalEntities->betweenDecl) {
4694         if (parser->m_isParamEntity || enc != parser->m_encoding) {
4695           if (XmlTokenRole(&parser->m_prologState, XML_TOK_NONE, end, end, enc)
4709     role = XmlTokenRole(&parser->m_prologState, tok, s, next, enc);
4717       if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
4718         accountingOnAbort(parser);
4725       enum XML_Error result = processXmlDecl(parser, 0, s, next);
4728       enc = parser->m_encoding;
4732       if (parser->m_startDoctypeDeclHandler) {
4733         parser->m_doctypeName
4734             = poolStoreString(&parser->m_tempPool, enc, s, next);
4735         if (! parser->m_doctypeName)
4737         poolFinish(&parser->m_tempPool);
4738         parser->m_doctypePubid = NULL;
4741       parser->m_doctypeSysid = NULL; /* always initialize to NULL */
4744       if (parser->m_startDoctypeDeclHandler) {
4745         parser->m_startDoctypeDeclHandler(
4746             parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
4747             parser->m_doctypePubid, 1);
4748         parser->m_doctypeName = NULL;
4749         poolClear(&parser->m_tempPool);
4755       enum XML_Error result = processXmlDecl(parser, 1, s, next);
4758       enc = parser->m_encoding;
4764       parser->m_useForeignDTD = XML_FALSE;
4765       parser->m_declEntity = (ENTITY *)lookup(
4766           parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
4767       if (! parser->m_declEntity)
4771       if (parser->m_startDoctypeDeclHandler) {
4775         pubId = poolStoreString(&parser->m_tempPool, enc,
4781         poolFinish(&parser->m_tempPool);
4782         parser->m_doctypePubid = pubId;
4791       if (dtd->keepProcessing && parser->m_declEntity) {
4798         parser->m_declEntity->publicId = tem;
4803         if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_PUBLIC_ID)
4813       if (parser->m_doctypeName) {
4814         parser->m_startDoctypeDeclHandler(
4815             parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
4816             parser->m_doctypePubid, 0);
4817         poolClear(&parser->m_tempPool);
4820       /* parser->m_doctypeSysid will be non-NULL in the case of a previous
4821          XML_ROLE_DOCTYPE_SYSTEM_ID, even if parser->m_startDoctypeDeclHandler
4825       if (parser->m_doctypeSysid || parser->m_useForeignDTD) {
4828         if (parser->m_paramEntityParsing
4829             && parser->m_externalEntityRefHandler) {
4830           ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
4840           if (parser->m_useForeignDTD)
4841             entity->base = parser->m_curBase;
4843           if (! parser->m_externalEntityRefHandler(
4844                   parser->m_externalEntityRefHandlerArg, 0, entity->base,
4848             if (! dtd->standalone && parser->m_notStandaloneHandler
4849                 && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
4855           else if (! parser->m_doctypeSysid)
4859         parser->m_useForeignDTD = XML_FALSE;
4862       if (parser->m_endDoctypeDeclHandler) {
4863         parser->m_endDoctypeDeclHandler(parser->m_handlerArg);
4872       if (parser->m_useForeignDTD) {
4875         if (parser->m_paramEntityParsing
4876             && parser->m_externalEntityRefHandler) {
4877           ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
4881           entity->base = parser->m_curBase;
4883           if (! parser->m_externalEntityRefHandler(
4884                   parser->m_externalEntityRefHandlerArg, 0, entity->base,
4888             if (! dtd->standalone && parser->m_notStandaloneHandler
4889                 && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
4901       parser->m_processor = contentProcessor;
4902       return contentProcessor(parser, s, end, nextPtr);
4904       parser->m_declElementType = getElementType(parser, enc, s, next);
4905       if (! parser->m_declElementType)
4909       parser->m_declAttributeId = getAttributeId(parser, enc, s, next);
4910       if (! parser->m_declAttributeId)
4912       parser->m_declAttributeIsCdata = XML_FALSE;
4913       parser->m_declAttributeType = NULL;
4914       parser->m_declAttributeIsId = XML_FALSE;
4917       parser->m_declAttributeIsCdata = XML_TRUE;
4918       parser->m_declAttributeType = atypeCDATA;
4921       parser->m_declAttributeIsId = XML_TRUE;
4922       parser->m_declAttributeType = atypeID;
4925       parser->m_declAttributeType = atypeIDREF;
4928       parser->m_declAttributeType = atypeIDREFS;
4931       parser->m_declAttributeType = atypeENTITY;
4934       parser->m_declAttributeType = atypeENTITIES;
4937       parser->m_declAttributeType = atypeNMTOKEN;
4940       parser->m_declAttributeType = atypeNMTOKENS;
4942       if (dtd->keepProcessing && parser->m_attlistDeclHandler)
4947       if (dtd->keepProcessing && parser->m_attlistDeclHandler) {
4949         if (parser->m_declAttributeType) {
4955         if (! poolAppendString(&parser->m_tempPool, prefix))
4957         if (! poolAppend(&parser->m_tempPool, enc, s, next))
4959         parser->m_declAttributeType = parser->m_tempPool.start;
4966         if (! defineAttribute(parser->m_declElementType,
4967                               parser->m_declAttributeId,
4968                               parser->m_declAttributeIsCdata,
4969                               parser->m_declAttributeIsId, 0, parser))
4971         if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
4972           if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
4973               || (*parser->m_declAttributeType == XML_T(ASCII_N)
4974                   && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
4976             if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
4977                 || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
4979             parser->m_declAttributeType = parser->m_tempPool.start;
4980             poolFinish(&parser->m_tempPool);
4983           parser->m_attlistDeclHandler(
4984               parser->m_handlerArg, parser->m_declElementType->name,
4985               parser->m_declAttributeId->name, parser->m_declAttributeType, 0,
4990       poolClear(&parser->m_tempPool);
4997             parser, enc, parser->m_declAttributeIsCdata,
5006                 parser->m_declElementType, parser->m_declAttributeId,
5007                 parser->m_declAttributeIsCdata, XML_FALSE, attVal, parser))
5009         if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
5010           if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
5011               || (*parser->m_declAttributeType == XML_T(ASCII_N)
5012                   && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
5014             if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
5015                 || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
5017             parser->m_declAttributeType = parser->m_tempPool.start;
5018             poolFinish(&parser->m_tempPool);
5021           parser->m_attlistDeclHandler(
5022               parser->m_handlerArg, parser->m_declElementType->name,
5023               parser->m_declAttributeId->name, parser->m_declAttributeType,
5025           poolClear(&parser->m_tempPool);
5033             = storeEntityValue(parser, enc, s + enc->minBytesPerChar,
5035         if (parser->m_declEntity) {
5036           parser->m_declEntity->textPtr = poolStart(&dtd->entityValuePool);
5037           parser->m_declEntity->textLen
5040           if (parser->m_entityDeclHandler) {
5042             parser->m_entityDeclHandler(
5043                 parser->m_handlerArg, parser->m_declEntity->name,
5044                 parser->m_declEntity->is_param, parser->m_declEntity->textPtr,
5045                 parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);
5056       parser->m_useForeignDTD = XML_FALSE;
5059       if (parser->m_startDoctypeDeclHandler) {
5060         parser->m_doctypeSysid = poolStoreString(&parser->m_tempPool, enc,
5063         if (parser->m_doctypeSysid == NULL)
5065         poolFinish(&parser->m_tempPool);
5070         /* use externalSubsetName to make parser->m_doctypeSysid non-NULL
5071            for the case where no parser->m_startDoctypeDeclHandler is set */
5072         parser->m_doctypeSysid = externalSubsetName;
5076           && ! parser->m_paramEntityParsing
5078           && parser->m_notStandaloneHandler
5079           && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
5084       if (! parser->m_declEntity) {
5085         parser->m_declEntity = (ENTITY *)lookup(
5086             parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
5087         if (! parser->m_declEntity)
5089         parser->m_declEntity->publicId = NULL;
5094       if (dtd->keepProcessing && parser->m_declEntity) {
5095         parser->m_declEntity->systemId
5098         if (! parser->m_declEntity->systemId)
5100         parser->m_declEntity->base = parser->m_curBase;
5105         if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_SYSTEM_ID)
5110       if (dtd->keepProcessing && parser->m_declEntity
5111           && parser->m_entityDeclHandler) {
5113         parser->m_entityDeclHandler(
5114             parser->m_handlerArg, parser->m_declEntity->name,
5115             parser->m_declEntity->is_param, 0, 0, parser->m_declEntity->base,
5116             parser->m_declEntity->systemId, parser->m_declEntity->publicId, 0);
5121       if (dtd->keepProcessing && parser->m_declEntity) {
5122         parser->m_declEntity->notation
5124         if (! parser->m_declEntity->notation)
5127         if (parser->m_unparsedEntityDeclHandler) {
5129           parser->m_unparsedEntityDeclHandler(
5130               parser->m_handlerArg, parser->m_declEntity->name,
5131               parser->m_declEntity->base, parser->m_declEntity->systemId,
5132               parser->m_declEntity->publicId, parser->m_declEntity->notation);
5134         } else if (parser->m_entityDeclHandler) {
5136           parser->m_entityDeclHandler(
5137               parser->m_handlerArg, parser->m_declEntity->name, 0, 0, 0,
5138               parser->m_declEntity->base, parser->m_declEntity->systemId,
5139               parser->m_declEntity->publicId, parser->m_declEntity->notation);
5146         parser->m_declEntity = NULL;
5153         parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities,
5155         if (! parser->m_declEntity)
5157         if (parser->m_declEntity->name != name) {
5159           parser->m_declEntity = NULL;
5162           parser->m_declEntity->publicId = NULL;
5163           parser->m_declEntity->is_param = XML_FALSE;
5164           /* if we have a parent parser or are reading an internal parameter
5167           parser->m_declEntity->is_internal
5168               = ! (parser->m_parentParser || parser->m_openInternalEntities);
5169           if (parser->m_entityDeclHandler)
5174         parser->m_declEntity = NULL;
5183         parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,
5185         if (! parser->m_declEntity)
5187         if (parser->m_declEntity->name != name) {
5189           parser->m_declEntity = NULL;
5192           parser->m_declEntity->publicId = NULL;
5193           parser->m_declEntity->is_param = XML_TRUE;
5194           /* if we have a parent parser or are reading an internal parameter
5197           parser->m_declEntity->is_internal
5198               = ! (parser->m_parentParser || parser->m_openInternalEntities);
5199           if (parser->m_entityDeclHandler)
5204         parser->m_declEntity = NULL;
5207       parser->m_declEntity = NULL;
5211       parser->m_declNotationPublicId = NULL;
5212       parser->m_declNotationName = NULL;
5213       if (parser->m_notationDeclHandler) {
5214         parser->m_declNotationName
5215             = poolStoreString(&parser->m_tempPool, enc, s, next);
5216         if (! parser->m_declNotationName)
5218         poolFinish(&parser->m_tempPool);
5225       if (parser
5227         XML_Char *tem = poolStoreString(&parser->m_tempPool, enc,
5233         parser->m_declNotationPublicId = tem;
5234         poolFinish(&parser->m_tempPool);
5239       if (parser->m_declNotationName && parser->m_notationDeclHandler) {
5240         const XML_Char *systemId = poolStoreString(&parser->m_tempPool, enc,
5246         parser->m_notationDeclHandler(
5247             parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
5248             systemId, parser->m_declNotationPublicId);
5251       poolClear(&parser->m_tempPool);
5254       if (parser->m_declNotationPublicId && parser->m_notationDeclHandler) {
5256         parser->m_notationDeclHandler(
5257             parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
5258             0, parser->m_declNotationPublicId);
5261       poolClear(&parser->m_tempPool);
5277       if (parser->m_defaultHandler)
5278         reportDefault(parser, enc, s, next);
5280       result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
5284         parser->m_processor = ignoreSectionProcessor;
5290       if (parser->m_prologState.level >= parser->m_groupSize) {
5291         if (parser->m_groupSize) {
5294             if (parser->m_groupSize > (unsigned int)(-1) / 2u) {
5299                 parser, parser->m_groupConnector, parser->m_groupSize *= 2);
5301               parser->m_groupSize /= 2;
5304             parser->m_groupConnector = new_connector;
5313             if (parser->m_groupSize > (size_t)(-1) / sizeof(int)) {
5319                 parser, dtd->scaffIndex, parser->m_groupSize * sizeof(int));
5325           parser->m_groupConnector
5326               = (char *)MALLOC(parser, parser->m_groupSize = 32);
5327           if (! parser->m_groupConnector) {
5328             parser->m_groupSize = 0;
5333       parser->m_groupConnector[parser->m_prologState.level] = 0;
5335         int myindex = nextScaffoldPart(parser);
5342         if (parser->m_elementDeclHandler)
5347       if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_PIPE)
5349       parser->m_groupConnector[parser->m_prologState.level] = ASCII_COMMA;
5350       if (dtd->in_eldecl && parser->m_elementDeclHandler)
5354       if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_COMMA)
5357           && ! parser->m_groupConnector[parser->m_prologState.level]
5362         if (parser->m_elementDeclHandler)
5365       parser->m_groupConnector[parser->m_prologState.level] = ASCII_PIPE;
5371       if (! parser->m_paramEntityParsing)
5380         entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
5386         if (parser->m_prologState.documentEntity
5387             && (dtd->standalone ? ! parser->m_openInternalEntities
5418               && parser->m_skippedEntityHandler) {
5419             parser->m_skippedEntityHandler(parser->m_handlerArg, name, 1);
5430           result = processInternalEntity(parser, entity, betweenDecl);
5436         if (parser->m_externalEntityRefHandler) {
5439           entityTrackingOnOpen(parser, entity, __LINE__);
5440           if (! parser->m_externalEntityRefHandler(
5441                   parser->m_externalEntityRefHandlerArg, 0, entity->base,
5443             entityTrackingOnClose(parser, entity, __LINE__);
5447           entityTrackingOnClose(parser, entity, __LINE__);
5460       if (! dtd->standalone && parser->m_notStandaloneHandler
5461           && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
5468       if (parser->m_elementDeclHandler) {
5469         parser->m_declElementType = getElementType(parser, enc, s, next);
5470         if (! parser->m_declElementType)
5482         if (parser->m_elementDeclHandler) {
5484               = (XML_Content *)MALLOC(parser, sizeof(XML_Content));
5494           parser->m_elementDeclHandler(
5495               parser->m_handlerArg, parser->m_declElementType->name, content);
5506         if (parser->m_elementDeclHandler)
5529         int myindex = nextScaffoldPart(parser);
5534         el = getElementType(parser, enc, s, nxt);
5549         if (parser->m_elementDeclHandler)
5567         if (parser->m_elementDeclHandler)
5573             XML_Content *model = build_model(parser);
5577             parser->m_elementDeclHandler(
5578                 parser->m_handlerArg, parser->m_declElementType->name, model);
5588       if (! reportProcessingInstruction(parser, enc, s, next))
5593       if (! reportComment(parser, enc, s, next))
5605       if (parser->m_startDoctypeDeclHandler)
5609       if (dtd->keepProcessing && parser->m_entityDeclHandler)
5613       if (parser->m_notationDeclHandler)
5617       if (dtd->keepProcessing && parser->m_attlistDeclHandler)
5621       if (parser->m_elementDeclHandler)
5626     if (handleDefault && parser->m_defaultHandler)
5627       reportDefault(parser, enc, s, next);
5629     switch (parser->m_parsingStatus.parsing) {
5644 epilogProcessor(XML_Parser parser, const char *s, const char *end,
5646   parser->m_processor = epilogProcessor;
5647   parser->m_eventPtr = s;
5650     int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
5652     if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
5654       accountingOnAbort(parser);
5658     parser->m_eventEndPtr = next;
5662       if (parser->m_defaultHandler) {
5663         reportDefault(parser, parser->m_encoding, s, next);
5664         if (parser->m_parsingStatus.parsing == XML_FINISHED)
5673       if (parser->m_defaultHandler)
5674         reportDefault(parser, parser->m_encoding, s, next);
5677       if (! reportProcessingInstruction(parser, parser->m_encoding, s, next))
5681       if (! reportComment(parser, parser->m_encoding, s, next))
5685       parser->m_eventPtr = next;
5688       if (! parser->m_parsingStatus.finalBuffer) {
5694       if (! parser->m_parsingStatus.finalBuffer) {
5702     parser->m_eventPtr = s = next;
5703     switch (parser->m_parsingStatus.parsing) {
5715 processInternalEntity(XML_Parser parser, ENTITY *entity, XML_Bool betweenDecl) {
5721   if (parser->m_freeInternalEntities) {
5722     openEntity = parser->m_freeInternalEntities;
5723     parser->m_freeInternalEntities = openEntity->next;
5726         = (OPEN_INTERNAL_ENTITY *)MALLOC(parser, sizeof(OPEN_INTERNAL_ENTITY));
5732   entityTrackingOnOpen(parser, entity, __LINE__);
5735   openEntity->next = parser->m_openInternalEntities;
5736   parser->m_openInternalEntities = openEntity;
5738   openEntity->startTagLevel = parser->m_tagLevel;
5750         = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
5751     result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
5756     result = doContent(parser, parser->m_tagLevel, parser->m_internalEncoding,
5761     if (textEnd != next && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
5763       parser->m_processor = internalEntityProcessor;
5766       entityTrackingOnClose(parser, entity, __LINE__);
5769       parser->m_openInternalEntities = openEntity->next;
5771       openEntity->next = parser->m_freeInternalEntities;
5772       parser->m_freeInternalEntities = openEntity;
5779 internalEntityProcessor(XML_Parser parser, const char *s, const char *end,
5785   OPEN_INTERNAL_ENTITY *openEntity = parser->m_openInternalEntities;
5798         = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
5799     result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
5804     result = doContent(parser, openEntity->startTagLevel,
5805                        parser->m_internalEncoding, textStart, textEnd, &next,
5811   if (textEnd != next && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
5817   entityTrackingOnClose(parser, entity, __LINE__);
5820   parser->m_openInternalEntities = openEntity->next;
5822   openEntity->next = parser->m_freeInternalEntities;
5823   parser->m_freeInternalEntities = openEntity;
5828   if (parser->m_openInternalEntities != NULL
5829       && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
5836     parser->m_processor = prologProcessor;
5837     tok = XmlPrologTok(parser->m_encoding, s, end, &next);
5838     return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
5839                     (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
5844     parser->m_processor = contentProcessor;
5846     result = doContent(parser, parser->m_parentParser ? 1 : 0,
5847                        parser->m_encoding, s, end, nextPtr,
5848                        (XML_Bool)! parser->m_parsingStatus.finalBuffer,
5851       if (! storeRawNames(parser))
5859 errorProcessor(XML_Parser parser, const char *s, const char *end,
5864   return parser->m_errorCode;
5868 storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
5872       = appendAttributeValue(parser, enc, isCdata, ptr, end, pool, account);
5883 appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
5886   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
5896     if (! accountingDiffTolerated(parser, tok, ptr, next, __LINE__, account)) {
5897       accountingOnAbort(parser);
5905       if (enc == parser->m_encoding)
5906         parser->m_eventPtr = next;
5909       if (enc == parser->m_encoding)
5910         parser->m_eventPtr = ptr;
5917         if (enc == parser->m_encoding)
5918           parser->m_eventPtr = ptr;
5964         accountingDiffTolerated(parser, tok, (char *)&ch,
5972       name = poolStoreString(&parser->m_temp2Pool, enc,
5977       entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
5978       poolDiscard(&parser->m_temp2Pool);
5985             parser->m_prologState.documentEntity &&
5987             (dtd->standalone ? ! parser->m_openInternalEntities
5989       else /* if (pool == &parser->m_tempPool): we are called from content */
5998            parser->m_skippedEntityHandler.
5999         if (parser->m_skippedEntityHandler)
6000           parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
6004         if ((pool == &parser->m_tempPool) && parser->m_defaultHandler)
6005           reportDefault(parser, enc, ptr, next);
6010         if (enc == parser->m_encoding) {
6018            * sets the local encoding ("enc") to the parser's
6028           parser->m_eventPtr = ptr; /* LCOV_EXCL_LINE */
6033         if (enc == parser->m_encoding)
6034           parser->m_eventPtr = ptr;
6038         if (enc == parser->m_encoding)
6039           parser->m_eventPtr = ptr;
6046         entityTrackingOnOpen(parser, entity, __LINE__);
6048         result = appendAttributeValue(parser, parser->m_internalEncoding,
6053         entityTrackingOnClose(parser, entity, __LINE__);
6072       if (enc == parser->m_encoding)
6073         parser->m_eventPtr = ptr;
6083 storeEntityValue(XML_Parser parser, const ENCODING *enc,
6086   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6090   int oldInEntityValue = parser->m_prologState.inEntityValue;
6091   parser->m_prologState.inEntityValue = 1;
6109     if (! accountingDiffTolerated(parser, tok, entityTextPtr, next, __LINE__,
6111       accountingOnAbort(parser);
6120       if (parser->m_isParamEntity || enc != parser->m_encoding) {
6123         name = poolStoreString(&parser->m_tempPool, enc,
6130         entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
6131         poolDiscard(&parser->m_tempPool);
6135              parser->m_skippedEntityHandler
6136           if (parser->m_skippedEntityHandler)
6137             parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
6143           if (enc == parser->m_encoding)
6144             parser->m_eventPtr = entityTextPtr;
6149           if (parser->m_externalEntityRefHandler) {
6152             entityTrackingOnOpen(parser, entity, __LINE__);
6153             if (! parser->m_externalEntityRefHandler(
6154                     parser->m_externalEntityRefHandlerArg, 0, entity->base,
6156               entityTrackingOnClose(parser, entity, __LINE__);
6161             entityTrackingOnClose(parser, entity, __LINE__);
6169           entityTrackingOnOpen(parser, entity, __LINE__);
6171               parser, parser->m_internalEncoding, (const char *)entity->textPtr,
6174           entityTrackingOnClose(parser, entity, __LINE__);
6184       parser->m_eventPtr = entityTextPtr;
6212         if (enc == parser->m_encoding)
6213           parser->m_eventPtr = entityTextPtr;
6236       if (enc == parser->m_encoding)
6237         parser->m_eventPtr = entityTextPtr;
6241       if (enc == parser->m_encoding)
6242         parser->m_eventPtr = next;
6253       if (enc == parser->m_encoding)
6254         parser->m_eventPtr = entityTextPtr;
6263   parser->m_prologState.inEntityValue = oldInEntityValue;
6290 reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
6295   if (! parser->m_processingInstructionHandler) {
6296     if (parser->m_defaultHandler)
6297       reportDefault(parser, enc, start, end);
6302   target = poolStoreString(&parser->m_tempPool, enc, start, tem);
6305   poolFinish(&parser->m_tempPool);
6306   data = poolStoreString(&parser->m_tempPool, enc, XmlSkipS(enc, tem),
6311   parser->m_processingInstructionHandler(parser->m_handlerArg, target, data);
6312   poolClear(&parser->m_tempPool);
6317 reportComment(XML_Parser parser, const ENCODING *enc, const char *start,
6320   if (! parser->m_commentHandler) {
6321     if (parser->m_defaultHandler)
6322       reportDefault(parser, enc, start, end);
6325   data = poolStoreString(&parser->m_tempPool, enc,
6331   parser->m_commentHandler(parser->m_handlerArg, data);
6332   poolClear(&parser->m_tempPool);
6337 reportDefault(XML_Parser parser, const ENCODING *enc, const char *s,
6343     if (enc == parser->m_encoding) {
6344       eventPP = &parser->m_eventPtr;
6345       eventEndPP = &parser->m_eventEndPtr;
6347       /* To get here, two things must be true; the parser must be
6352        * in is not the same as the parser's encoding are when it is
6363       eventPP = &(parser->m_openInternalEntities->internalEventPtr);
6364       eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
6368       ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
6370           = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
6372       parser->m_defaultHandler(parser->m_handlerArg, parser->m_dataBuf,
6373                                (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
6378     parser->m_defaultHandler(parser->m_handlerArg, (XML_Char *)s,
6384                 XML_Bool isId, const XML_Char *value, XML_Parser parser) {
6400           parser, type->allocDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
6425       temp = (DEFAULT_ATTRIBUTE *)REALLOC(parser, type->defaultAtts,
6444 setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType) {
6445   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6457       prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
6473 getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,
6475   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6485   id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name,
6493     if (! parser->m_ns)
6502         id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6,
6517           id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes,
6536 getContext(XML_Parser parser) {
6537   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6544     if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
6547     if (parser->m_namespaceSeparator)
6550       if (! poolAppendChar(&parser->m_tempPool,
6556          * URI into the parser's temporary string pool.  Previously,
6594     if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
6597       if (! poolAppendChar(&parser->m_tempPool, *s))
6599     if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
6602     if (parser->m_namespaceSeparator)
6605       if (! poolAppendChar(&parser->m_tempPool, prefix->binding->uri[i]))
6618     if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
6621       if (! poolAppendChar(&parser->m_tempPool, *s))
6626   if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
6628   return parser->m_tempPool.start;
6632 setContext(XML_Parser parser, const XML_Char *context) {
6633   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6639       if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
6641       e = (ENTITY *)lookup(parser, &dtd->generalEntities,
6642                            poolStart(&parser->m_tempPool), 0);
6648       poolDiscard(&parser->m_tempPool);
6651       if (poolLength(&parser->m_tempPool) == 0)
6654         if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
6657             = (PREFIX *)lookup(parser, &dtd->prefixes,
6658                                poolStart(&parser->m_tempPool), sizeof(PREFIX));
6661         if (prefix->name == poolStart(&parser->m_tempPool)) {
6666         poolDiscard(&parser->m_tempPool);
6670         if (! poolAppendChar(&parser->m_tempPool, *context))
6672       if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
6674       if (addBinding(parser, prefix, NULL, poolStart(&parser->m_tempPool),
6675                      &parser->m_inheritedBindings)
6678       poolDiscard(&parser->m_tempPool);
6683       if (! poolAppendChar(&parser->m_tempPool, *s))
7023 copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key) {
7025   key->k[1] = get_hash_secret_salt(parser);
7029 hash(XML_Parser parser, KEY s) {
7033   copy_salt_to_sipkey(parser, &key);
7040 lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize) {
7056     i = hash(parser, name) & ((unsigned long)table->size - 1);
7058     unsigned long h = hash(parser, name);
7096           unsigned long newHash = hash(parser, table->v[i]->name);
7423 nextScaffoldPart(XML_Parser parser) {
7424   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
7429     dtd->scaffIndex = (int *)MALLOC(parser, parser->m_groupSize * sizeof(int));
7453           parser, dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
7458       temp = (CONTENT_SCAFFOLD *)MALLOC(parser, INIT_SCAFFOLD_ELEMENTS
7484 build_model(XML_Parser parser) {
7485   /* Function build_model transforms the existing parser->m_dtd->scaffold
7489   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
7513   ret = (XML_Content *)MALLOC(parser, allocsize);
7611 getElementType(XML_Parser parser, const ENCODING *enc, const char *ptr,
7613   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
7619   ret = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
7627     if (! setElementTypePrefix(parser, ret))
7787 testingAccountingGetCountBytesDirect(XML_Parser parser) {
7788   if (! parser)
7790   return parser->m_accounting.countBytesDirect;
7794 testingAccountingGetCountBytesIndirect(XML_Parser parser) {
7795   if (! parser)
7797   return parser->m_accounting.countBytesIndirect;
7849 getRootParserOf(XML_Parser parser, unsigned int *outLevelDiff) {
7850   XML_Parser rootParser = parser;

Indexes created Thu Nov 07 10:32:03 CST 2024