7                                  |_| XML parser
217 static void copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key);
280    A parser re-uses these structures, maintaining a list of allocated
403   XML_ACCOUNT_DIRECT,           /* bytes directly passed to the Expat parser */
427 typedef enum XML_Error PTRCALL Processor(XML_Parser parser, const char *start,
449 static enum XML_Error handleUnknownEncoding(XML_Parser parser,
451 static enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
453 static enum XML_Error initializeEncoding(XML_Parser parser);
454 static enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc,
459 static enum XML_Error processInternalEntity(XML_Parser parser, ENTITY *entity,
461 static enum XML_Error doContent(XML_Parser parser, int startTagLevel,
465 static enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *,
470 static enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *,
475 static void freeBindings(XML_Parser parser, BINDING *bindings);
476 static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *,
480 static enum XML_Error addBinding(XML_Parser parser, PREFIX *prefix,
485                            XML_Parser parser);
486 static enum XML_Error storeAttributeValue(XML_Parser parser, const ENCODING *,
490 static enum XML_Error appendAttributeValue(XML_Parser parser, const ENCODING *,
494 static ATTRIBUTE_ID *getAttributeId(XML_Parser parser, const ENCODING *enc,
496 static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
497 static enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc,
500 static int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
502 static int reportComment(XML_Parser parser, const ENCODING *enc,
504 static void reportDefault(XML_Parser parser, const ENCODING *enc,
507 static const XML_Char *getContext(XML_Parser parser);
508 static XML_Bool setContext(XML_Parser parser, const XML_Char *context);
521 static NAMED *lookup(XML_Parser parser, HASH_TABLE *table, KEY name,
546 static int FASTCALL nextScaffoldPart(XML_Parser parser);
547 static XML_Content *build_model(XML_Parser parser);
548 static ELEMENT_TYPE *getElementType(XML_Parser parser, const ENCODING *enc,
554 static unsigned long generate_hash_secret_salt(XML_Parser parser);
555 static XML_Bool startParsing(XML_Parser parser);
561 static void parserInit(XML_Parser parser, const XML_Char *encodingName);
577 static void entityTrackingReportStats(XML_Parser parser, ENTITY *entity,
579 static void entityTrackingOnOpen(XML_Parser parser, ENTITY *entity,
581 static void entityTrackingOnClose(XML_Parser parser, ENTITY *entity,
584 static XML_Parser getRootParserOf(XML_Parser parser,
710 #define MALLOC(parser, s) (parser->m_mem.malloc_fcn((s)))
711 #define REALLOC(parser, p, s) (parser->m_mem.realloc_fcn((p), (s)))
712 #define FREE(parser, p) (parser->m_mem.free_fcn((p)))
899 generate_hash_secret_salt(XML_Parser parser) {
901   (void)parser;
942 get_hash_secret_salt(XML_Parser parser) {
943   if (parser->m_parentParser != NULL)
944     return get_hash_secret_salt(parser->m_parentParser);
945   return parser->m_hash_secret_salt;
948 static XML_Bool /* only valid for root parser */
949 startParsing(XML_Parser parser) {
951   if (parser->m_hash_secret_salt == 0)
952     parser->m_hash_secret_salt = generate_hash_secret_salt(parser);
953   if (parser->m_ns) {
954     /* implicit context only set for root parser, since child
957     return setContext(parser, implicitContext);
973   XML_Parser parser;
977     parser = memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));
978     if (parser != NULL) {
979       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
986     parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));
987     if (parser != NULL) {
988       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
995   if (! parser)
996     return parser;
998   parser->m_buffer = NULL;
999   parser->m_bufferLim = NULL;
1001   parser->m_attsSize = INIT_ATTS_SIZE;
1002   parser->m_atts
1003       = (ATTRIBUTE *)MALLOC(parser, parser->m_attsSize * sizeof(ATTRIBUTE));
1004   if (parser->m_atts == NULL) {
1005     FREE(parser, parser);
1009   parser->m_attInfo = (XML_AttrInfo *)MALLOC(
1010       parser, parser->m_attsSize * sizeof(XML_AttrInfo));
1011   if (parser->m_attInfo == NULL) {
1012     FREE(parser, parser->m_atts);
1013     FREE(parser, parser);
1017   parser->m_dataBuf
1018       = (XML_Char *)MALLOC(parser, INIT_DATA_BUF_SIZE * sizeof(XML_Char));
1019   if (parser->m_dataBuf == NULL) {
1020     FREE(parser, parser->m_atts);
1022     FREE(parser, parser->m_attInfo);
1024     FREE(parser, parser);
1027   parser->m_dataBufEnd = parser->m_dataBuf + INIT_DATA_BUF_SIZE;
1030     parser->m_dtd = dtd;
1032     parser->m_dtd = dtdCreate(&parser->m_mem);
1033     if (parser->m_dtd == NULL) {
1034       FREE(parser, parser->m_dataBuf);
1035       FREE(parser, parser->m_atts);
1037       FREE(parser, parser->m_attInfo);
1039       FREE(parser, parser);
1044   parser->m_freeBindingList = NULL;
1045   parser->m_freeTagList = NULL;
1046   parser->m_freeInternalEntities = NULL;
1048   parser->m_groupSize = 0;
1049   parser->m_groupConnector = NULL;
1051   parser->m_unknownEncodingHandler = NULL;
1052   parser->m_unknownEncodingHandlerData = NULL;
1054   parser->m_namespaceSeparator = ASCII_EXCL;
1055   parser->m_ns = XML_FALSE;
1056   parser->m_ns_triplets = XML_FALSE;
1058   parser->m_nsAtts = NULL;
1059   parser->m_nsAttsVersion = 0;
1060   parser->m_nsAttsPower = 0;
1062   parser->m_protocolEncodingName = NULL;
1064   poolInit(&parser->m_tempPool, &(parser->m_mem));
1065   poolInit(&parser->m_temp2Pool, &(parser->m_mem));
1066   parserInit(parser, encodingName);
1068   if (encodingName && ! parser->m_protocolEncodingName) {
1069     XML_ParserFree(parser);
1074     parser->m_ns = XML_TRUE;
1075     parser->m_internalEncoding = XmlGetInternalEncodingNS();
1076     parser->m_namespaceSeparator = *nameSep;
1078     parser->m_internalEncoding = XmlGetInternalEncoding();
1081   return parser;
1085 parserInit(XML_Parser parser, const XML_Char *encodingName) {
1086   parser->m_processor = prologInitProcessor;
1087   XmlPrologStateInit(&parser->m_prologState);
1089     parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
1091   parser->m_curBase = NULL;
1092   XmlInitEncoding(&parser->m_initEncoding, &parser->m_encoding, 0);
1093   parser->m_userData = NULL;
1094   parser->m_handlerArg = NULL;
1095   parser->m_startElementHandler = NULL;
1096   parser->m_endElementHandler = NULL;
1097   parser->m_characterDataHandler = NULL;
1098   parser->m_processingInstructionHandler = NULL;
1099   parser->m_commentHandler = NULL;
1100   parser->m_startCdataSectionHandler = NULL;
1101   parser->m_endCdataSectionHandler = NULL;
1102   parser->m_defaultHandler = NULL;
1103   parser->m_startDoctypeDeclHandler = NULL;
1104   parser->m_endDoctypeDeclHandler = NULL;
1105   parser->m_unparsedEntityDeclHandler = NULL;
1106   parser->m_notationDeclHandler = NULL;
1107   parser->m_startNamespaceDeclHandler = NULL;
1108   parser->m_endNamespaceDeclHandler = NULL;
1109   parser->m_notStandaloneHandler = NULL;
1110   parser->m_externalEntityRefHandler = NULL;
1111   parser->m_externalEntityRefHandlerArg = parser;
1112   parser->m_skippedEntityHandler = NULL;
1113   parser->m_elementDeclHandler = NULL;
1114   parser->m_attlistDeclHandler = NULL;
1115   parser->m_entityDeclHandler = NULL;
1116   parser->m_xmlDeclHandler = NULL;
1117   parser->m_bufferPtr = parser->m_buffer;
1118   parser->m_bufferEnd = parser->m_buffer;
1119   parser->m_parseEndByteIndex = 0;
1120   parser->m_parseEndPtr = NULL;
1121   parser->m_declElementType = NULL;
1122   parser->m_declAttributeId = NULL;
1123   parser->m_declEntity = NULL;
1124   parser->m_doctypeName = NULL;
1125   parser->m_doctypeSysid = NULL;
1126   parser->m_doctypePubid = NULL;
1127   parser->m_declAttributeType = NULL;
1128   parser->m_declNotationName = NULL;
1129   parser->m_declNotationPublicId = NULL;
1130   parser->m_declAttributeIsCdata = XML_FALSE;
1131   parser->m_declAttributeIsId = XML_FALSE;
1132   memset(&parser->m_position, 0, sizeof(POSITION));
1133   parser->m_errorCode = XML_ERROR_NONE;
1134   parser->m_eventPtr = NULL;
1135   parser->m_eventEndPtr = NULL;
1136   parser->m_positionPtr = NULL;
1137   parser->m_openInternalEntities = NULL;
1138   parser->m_defaultExpandInternalEntities = XML_TRUE;
1139   parser->m_tagLevel = 0;
1140   parser->m_tagStack = NULL;
1141   parser->m_inheritedBindings = NULL;
1142   parser->m_nSpecifiedAtts = 0;
1143   parser->m_unknownEncodingMem = NULL;
1144   parser->m_unknownEncodingRelease = NULL;
1145   parser->m_unknownEncodingData = NULL;
1146   parser->m_parentParser = NULL;
1147   parser->m_parsingStatus.parsing = XML_INITIALIZED;
1149   parser->m_isParamEntity = XML_FALSE;
1150   parser->m_useForeignDTD = XML_FALSE;
1151   parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
1153   parser->m_hash_secret_salt = 0;
1156   memset(&parser->m_accounting, 0, sizeof(ACCOUNTING));
1157   parser->m_accounting.debugLevel = getDebugLevel("EXPAT_ACCOUNTING_DEBUG", 0u);
1158   parser->m_accounting.maximumAmplificationFactor
1160   parser->m_accounting.activationThresholdBytes
1163   memset(&parser->m_entity_stats, 0, sizeof(ENTITY_STATS));
1164   parser->m_entity_stats.debugLevel = getDebugLevel("EXPAT_ENTITY_DEBUG", 0u);
1170 moveToFreeBindingList(XML_Parser parser, BINDING *bindings) {
1174     b->nextTagBinding = parser->m_freeBindingList;
1175     parser->m_freeBindingList = b;
1180 XML_ParserReset(XML_Parser parser, const XML_Char *encodingName) {
1184   if (parser == NULL)
1187   if (parser->m_parentParser)
1190   tStk = parser->m_tagStack;
1194     tag->parent = parser->m_freeTagList;
1195     moveToFreeBindingList(parser, tag->bindings);
1197     parser->m_freeTagList = tag;
1200   openEntityList = parser->m_openInternalEntities;
1204     openEntity->next = parser->m_freeInternalEntities;
1205     parser->m_freeInternalEntities = openEntity;
1207   moveToFreeBindingList(parser, parser->m_inheritedBindings);
1208   FREE(parser, parser->m_unknownEncodingMem);
1209   if (parser->m_unknownEncodingRelease)
1210     parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
1211   poolClear(&parser->m_tempPool);
1212   poolClear(&parser->m_temp2Pool);
1213   FREE(parser, (void *)parser->m_protocolEncodingName);
1214   parser->m_protocolEncodingName = NULL;
1215   parserInit(parser, encodingName);
1216   dtdReset(parser->m_dtd, &parser->m_mem);
1221 XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName) {
1222   if (parser == NULL)
1228   if (parser->m_parsingStatus.parsing == XML_PARSING
1229       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1233   FREE(parser, (void *)parser->m_protocolEncodingName);
1237     parser->m_protocolEncodingName = NULL;
1240     parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
1241     if (! parser->m_protocolEncodingName)
1250   XML_Parser parser = oldParser;
1284   /* Note that the new parser shares the same hash secret as the old
1285      parser, so that dtdCopy and copyEntityTable can lookup values
1286      from hash tables associated with either parser without us having
1295   /* Stash the original parser contents on the stack */
1296   oldDtd = parser->m_dtd;
1297   oldStartElementHandler = parser->m_startElementHandler;
1298   oldEndElementHandler = parser->m_endElementHandler;
1299   oldCharacterDataHandler = parser->m_characterDataHandler;
1300   oldProcessingInstructionHandler = parser->m_processingInstructionHandler;
1301   oldCommentHandler = parser->m_commentHandler;
1302   oldStartCdataSectionHandler = parser->m_startCdataSectionHandler;
1303   oldEndCdataSectionHandler = parser->m_endCdataSectionHandler;
1304   oldDefaultHandler = parser->m_defaultHandler;
1305   oldUnparsedEntityDeclHandler = parser->m_unparsedEntityDeclHandler;
1306   oldNotationDeclHandler = parser->m_notationDeclHandler;
1307   oldStartNamespaceDeclHandler = parser->m_startNamespaceDeclHandler;
1308   oldEndNamespaceDeclHandler = parser->m_endNamespaceDeclHandler;
1309   oldNotStandaloneHandler = parser->m_notStandaloneHandler;
1310   oldExternalEntityRefHandler = parser->m_externalEntityRefHandler;
1311   oldSkippedEntityHandler = parser->m_skippedEntityHandler;
1312   oldUnknownEncodingHandler = parser->m_unknownEncodingHandler;
1313   oldElementDeclHandler = parser->m_elementDeclHandler;
1314   oldAttlistDeclHandler = parser->m_attlistDeclHandler;
1315   oldEntityDeclHandler = parser->m_entityDeclHandler;
1316   oldXmlDeclHandler = parser->m_xmlDeclHandler;
1317   oldDeclElementType = parser->m_declElementType;
1319   oldUserData = parser->m_userData;
1320   oldHandlerArg = parser->m_handlerArg;
1321   oldDefaultExpandInternalEntities = parser->m_defaultExpandInternalEntities;
1322   oldExternalEntityRefHandlerArg = parser->m_externalEntityRefHandlerArg;
1324   oldParamEntityParsing = parser->m_paramEntityParsing;
1325   oldInEntityValue = parser->m_prologState.inEntityValue;
1327   oldns_triplets = parser->m_ns_triplets;
1328   /* Note that the new parser shares the same hash secret as the old
1329      parser, so that dtdCopy and copyEntityTable can lookup values
1330      from hash tables associated with either parser without us having
1333   oldhash_secret_salt = parser->m_hash_secret_salt;
1341      access look more like C++ require that `parser' be overwritten
1345   if (parser->m_ns) {
1346     XML_Char tmp[2] = {parser->m_namespaceSeparator, 0};
1347     parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);
1349     parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);
1352   if (! parser)
1355   parser->m_startElementHandler = oldStartElementHandler;
1356   parser->m_endElementHandler = oldEndElementHandler;
1357   parser->m_characterDataHandler = oldCharacterDataHandler;
1358   parser->m_processingInstructionHandler = oldProcessingInstructionHandler;
1359   parser->m_commentHandler = oldCommentHandler;
1360   parser->m_startCdataSectionHandler = oldStartCdataSectionHandler;
1361   parser->m_endCdataSectionHandler = oldEndCdataSectionHandler;
1362   parser->m_defaultHandler = oldDefaultHandler;
1363   parser->m_unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;
1364   parser->m_notationDeclHandler = oldNotationDeclHandler;
1365   parser->m_startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
1366   parser->m_endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
1367   parser->m_notStandaloneHandler = oldNotStandaloneHandler;
1368   parser->m_externalEntityRefHandler = oldExternalEntityRefHandler;
1369   parser->m_skippedEntityHandler = oldSkippedEntityHandler;
1370   parser->m_unknownEncodingHandler = oldUnknownEncodingHandler;
1371   parser->m_elementDeclHandler = oldElementDeclHandler;
1372   parser->m_attlistDeclHandler = oldAttlistDeclHandler;
1373   parser->m_entityDeclHandler = oldEntityDeclHandler;
1374   parser->m_xmlDeclHandler = oldXmlDeclHandler;
1375   parser->m_declElementType = oldDeclElementType;
1376   parser->m_userData = oldUserData;
1378     parser->m_handlerArg = parser->m_userData;
1380     parser->m_handlerArg = parser;
1382     parser->m_externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
1383   parser->m_defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
1384   parser->m_ns_triplets = oldns_triplets;
1385   parser->m_hash_secret_salt = oldhash_secret_salt;
1386   parser->m_parentParser = oldParser;
1388   parser->m_paramEntityParsing = oldParamEntityParsing;
1389   parser->m_prologState.inEntityValue = oldInEntityValue;
1392     if (! dtdCopy(oldParser, parser->m_dtd, oldDtd, &parser->m_mem)
1393         || ! setContext(parser, context)) {
1394       XML_ParserFree(parser);
1397     parser->m_processor = externalEntityInitProcessor;
1400     /* The DTD instance referenced by parser->m_dtd is shared between the
1401        document's root parser and external PE parsers, therefore one does not
1404        pointers in parser->m_dtd with ones that get destroyed with the external
1405        PE parser. This would leave those prefixes with dangling pointers.
1407     parser->m_isParamEntity = XML_TRUE;
1408     XmlPrologStateInitExternalEntity(&parser->m_prologState);
1409     parser->m_processor = externalParEntInitProcessor;
1412   return parser;
1416 destroyBindings(BINDING *bindings, XML_Parser parser) {
1422     FREE(parser, b->uri);
1423     FREE(parser, b);
1428 XML_ParserFree(XML_Parser parser) {
1431   if (parser == NULL)
1434   tagList = parser->m_tagStack;
1438       if (parser->m_freeTagList == NULL)
1440       tagList = parser->m_freeTagList;
1441       parser->m_freeTagList = NULL;
1445     FREE(parser, p->buf);
1446     destroyBindings(p->bindings, parser);
1447     FREE(parser, p);
1450   entityList = parser->m_openInternalEntities;
1454       if (parser->m_freeInternalEntities == NULL)
1456       entityList = parser->m_freeInternalEntities;
1457       parser->m_freeInternalEntities = NULL;
1461     FREE(parser, openEntity);
1464   destroyBindings(parser->m_freeBindingList, parser);
1465   destroyBindings(parser->m_inheritedBindings, parser);
1466   poolDestroy(&parser->m_tempPool);
1467   poolDestroy(&parser->m_temp2Pool);
1468   FREE(parser, (void *)parser->m_protocolEncodingName);
1471      parser->m_dtd with the root parser, so we must not destroy it
1473   if (! parser->m_isParamEntity && parser->m_dtd)
1475   if (parser->m_dtd)
1477     dtdDestroy(parser->m_dtd, (XML_Bool)! parser->m_parentParser,
1478                &parser->m_mem);
1479   FREE(parser, (void *)parser->m_atts);
1481   FREE(parser, (void *)parser->m_attInfo);
1483   FREE(parser, parser->m_groupConnector);
1484   FREE(parser, parser->m_buffer);
1485   FREE(parser, parser->m_dataBuf);
1486   FREE(parser, parser->m_nsAtts);
1487   FREE(parser, parser->m_unknownEncodingMem);
1488   if (parser->m_unknownEncodingRelease)
1489     parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
1490   FREE(parser, parser);
1494 XML_UseParserAsHandlerArg(XML_Parser parser) {
1495   if (parser != NULL)
1496     parser->m_handlerArg = parser;
1500 XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD) {
1501   if (parser == NULL)
1505   if (parser->m_parsingStatus.parsing == XML_PARSING
1506       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1508   parser->m_useForeignDTD = useDTD;
1517 XML_SetReturnNSTriplet(XML_Parser parser, int do_nst) {
1518   if (parser == NULL)
1521   if (parser->m_parsingStatus.parsing == XML_PARSING
1522       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1524   parser->m_ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
1528 XML_SetUserData(XML_Parser parser, void *p) {
1529   if (parser == NULL)
1531   if (parser->m_handlerArg == parser->m_userData)
1532     parser->m_handlerArg = parser->m_userData = p;
1534     parser->m_userData = p;
1538 XML_SetBase(XML_Parser parser, const XML_Char *p) {
1539   if (parser == NULL)
1542     p = poolCopyString(&parser->m_dtd->pool, p);
1545     parser->m_curBase = p;
1547     parser->m_curBase = NULL;
1552 XML_GetBase(XML_Parser parser) {
1553   if (parser == NULL)
1555   return parser->m_curBase;
1559 XML_GetSpecifiedAttributeCount(XML_Parser parser) {
1560   if (parser == NULL)
1562   return parser->m_nSpecifiedAtts;
1566 XML_GetIdAttributeIndex(XML_Parser parser) {
1567   if (parser == NULL)
1569   return parser->m_idAttIndex;
1574 XML_GetAttributeInfo(XML_Parser parser) {
1575   if (parser == NULL)
1577   return parser->m_attInfo;
1582 XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
1584   if (parser == NULL)
1586   parser->m_startElementHandler = start;
1587   parser->m_endElementHandler = end;
1591 XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler start) {
1592   if (parser != NULL)
1593     parser->m_startElementHandler = start;
1597 XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler end) {
1598   if (parser != NULL)
1599     parser->m_endElementHandler = end;
1603 XML_SetCharacterDataHandler(XML_Parser parser,
1605   if (parser != NULL)
1606     parser->m_characterDataHandler = handler;
1610 XML_SetProcessingInstructionHandler(XML_Parser parser,
1612   if (parser != NULL)
1613     parser->m_processingInstructionHandler = handler;
1617 XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler) {
1618   if (parser != NULL)
1619     parser->m_commentHandler = handler;
1623 XML_SetCdataSectionHandler(XML_Parser parser,
1626   if (parser == NULL)
1628   parser->m_startCdataSectionHandler = start;
1629   parser->m_endCdataSectionHandler = end;
1633 XML_SetStartCdataSectionHandler(XML_Parser parser,
1635   if (parser != NULL)
1636     parser->m_startCdataSectionHandler = start;
1640 XML_SetEndCdataSectionHandler(XML_Parser parser,
1642   if (parser != NULL)
1643     parser->m_endCdataSectionHandler = end;
1647 XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler) {
1648   if (parser == NULL)
1650   parser->m_defaultHandler = handler;
1651   parser->m_defaultExpandInternalEntities = XML_FALSE;
1655 XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler) {
1656   if (parser == NULL)
1658   parser->m_defaultHandler = handler;
1659   parser->m_defaultExpandInternalEntities = XML_TRUE;
1663 XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,
1665   if (parser == NULL)
1667   parser->m_startDoctypeDeclHandler = start;
1668   parser->m_endDoctypeDeclHandler = end;
1672 XML_SetStartDoctypeDeclHandler(XML_Parser parser,
1674   if (parser != NULL)
1675     parser->m_startDoctypeDeclHandler = start;
1679 XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end) {
1680   if (parser != NULL)
1681     parser->m_endDoctypeDeclHandler = end;
1685 XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
1687   if (parser != NULL)
1688     parser->m_unparsedEntityDeclHandler = handler;
1692 XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler) {
1693   if (parser != NULL)
1694     parser->m_notationDeclHandler = handler;
1698 XML_SetNamespaceDeclHandler(XML_Parser parser,
1701   if (parser == NULL)
1703   parser->m_startNamespaceDeclHandler = start;
1704   parser->m_endNamespaceDeclHandler = end;
1708 XML_SetStartNamespaceDeclHandler(XML_Parser parser,
1710   if (parser != NULL)
1711     parser->m_startNamespaceDeclHandler = start;
1715 XML_SetEndNamespaceDeclHandler(XML_Parser parser,
1717   if (parser != NULL)
1718     parser->m_endNamespaceDeclHandler = end;
1722 XML_SetNotStandaloneHandler(XML_Parser parser,
1724   if (parser != NULL)
1725     parser->m_notStandaloneHandler = handler;
1729 XML_SetExternalEntityRefHandler(XML_Parser parser,
1731   if (parser != NULL)
1732     parser->m_externalEntityRefHandler = handler;
1736 XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg) {
1737   if (parser == NULL)
1740     parser->m_externalEntityRefHandlerArg = (XML_Parser)arg;
1742     parser->m_externalEntityRefHandlerArg = parser;
1746 XML_SetSkippedEntityHandler(XML_Parser parser,
1748   if (parser != NULL)
1749     parser->m_skippedEntityHandler = handler;
1753 XML_SetUnknownEncodingHandler(XML_Parser parser,
1755   if (parser == NULL)
1757   parser->m_unknownEncodingHandler = handler;
1758   parser->m_unknownEncodingHandlerData = data;
1762 XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl) {
1763   if (parser != NULL)
1764     parser->m_elementDeclHandler = eldecl;
1768 XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl) {
1769   if (parser != NULL)
1770     parser->m_attlistDeclHandler = attdecl;
1774 XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler) {
1775   if (parser != NULL)
1776     parser->m_entityDeclHandler = handler;
1780 XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler handler) {
1781   if (parser != NULL)
1782     parser->m_xmlDeclHandler = handler;
1786 XML_SetParamEntityParsing(XML_Parser parser,
1788   if (parser == NULL)
1791   if (parser->m_parsingStatus.parsing == XML_PARSING
1792       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1795   parser->m_paramEntityParsing = peParsing;
1803 XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt) {
1804   if (parser == NULL)
1806   if (parser->m_parentParser)
1807     return XML_SetHashSalt(parser->m_parentParser, hash_salt);
1809   if (parser->m_parsingStatus.parsing == XML_PARSING
1810       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1812   parser->m_hash_secret_salt = hash_salt;
1817 XML_Parse(XML_Parser parser, const char *s, int len, int isFinal) {
1818   if ((parser == NULL) || (len < 0) || ((s == NULL) && (len != 0))) {
1819     if (parser != NULL)
1820       parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;
1823   switch (parser->m_parsingStatus.parsing) {
1825     parser->m_errorCode = XML_ERROR_SUSPENDED;
1828     parser->m_errorCode = XML_ERROR_FINISHED;
1831     if (parser->m_parentParser == NULL && ! startParsing(parser)) {
1832       parser->m_errorCode = XML_ERROR_NO_MEMORY;
1837     parser->m_parsingStatus.parsing = XML_PARSING;
1841     parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
1844     parser->m_positionPtr = parser->m_bufferPtr;
1845     parser->m_parseEndPtr = parser->m_bufferEnd;
1851     parser->m_errorCode
1852         = parser->m_processor(parser, parser->m_bufferPtr,
1853                               parser->m_parseEndPtr, &parser->m_bufferPtr);
1855     if (parser->m_errorCode == XML_ERROR_NONE) {
1856       switch (parser->m_parsingStatus.parsing) {
1870         XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
1871                           parser->m_bufferPtr, &parser->m_position);
1872         parser->m_positionPtr = parser->m_bufferPtr;
1877         parser->m_parsingStatus.parsing = XML_FINISHED;
1883     parser->m_eventEndPtr = parser->m_eventPtr;
1884     parser->m_processor = errorProcessor;
1888   else if (parser->m_bufferPtr == parser->m_bufferEnd) {
1893     if ((XML_Size)len > ((XML_Size)-1) / 2 - parser->m_parseEndByteIndex) {
1894       parser->m_errorCode = XML_ERROR_NO_MEMORY;
1895       parser->m_eventPtr = parser->m_eventEndPtr = NULL;
1896       parser->m_processor = errorProcessor;
1899     parser->m_parseEndByteIndex += len;
1900     parser->m_positionPtr = s;
1901     parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
1903     parser->m_errorCode
1904         = parser->m_processor(parser, s, parser->m_parseEndPtr = s + len, &end);
1906     if (parser->m_errorCode != XML_ERROR_NONE) {
1907       parser->m_eventEndPtr = parser->m_eventPtr;
1908       parser->m_processor = errorProcessor;
1911       switch (parser->m_parsingStatus.parsing) {
1918           parser->m_parsingStatus.parsing = XML_FINISHED;
1927     XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, end,
1928                       &parser->m_position);
1931       if (parser->m_buffer == NULL
1932           || nLeftOver > parser->m_bufferLim - parser->m_buffer) {
1937           temp = (char *)REALLOC(parser, parser->m_buffer, bytesToAllocate);
1940           parser->m_errorCode = XML_ERROR_NO_MEMORY;
1941           parser->m_eventPtr = parser->m_eventEndPtr = NULL;
1942           parser->m_processor = errorProcessor;
1945         parser->m_buffer = temp;
1946         parser->m_bufferLim = parser->m_buffer + bytesToAllocate;
1948       memcpy(parser->m_buffer, end, nLeftOver);
1950     parser->m_bufferPtr = parser->m_buffer;
1951     parser->m_bufferEnd = parser->m_buffer + nLeftOver;
1952     parser->m_positionPtr = parser->m_bufferPtr;
1953     parser->m_parseEndPtr = parser->m_bufferEnd;
1954     parser->m_eventPtr = parser->m_bufferPtr;
1955     parser->m_eventEndPtr = parser->m_bufferPtr;
1960     void *buff = XML_GetBuffer(parser, len);
1965       return XML_ParseBuffer(parser, len, isFinal);
1971 XML_ParseBuffer(XML_Parser parser, int len, int isFinal) {
1975   if (parser == NULL)
1977   switch (parser->m_parsingStatus.parsing) {
1979     parser->m_errorCode = XML_ERROR_SUSPENDED;
1982     parser->m_errorCode = XML_ERROR_FINISHED;
1986     if (! parser->m_bufferPtr) {
1987       parser->m_errorCode = XML_ERROR_NO_BUFFER;
1991     if (parser->m_parentParser == NULL && ! startParsing(parser)) {
1992       parser->m_errorCode = XML_ERROR_NO_MEMORY;
1997     parser->m_parsingStatus.parsing = XML_PARSING;
2000   start = parser->m_bufferPtr;
2001   parser->m_positionPtr = start;
2002   parser->m_bufferEnd += len;
2003   parser->m_parseEndPtr = parser->m_bufferEnd;
2004   parser->m_parseEndByteIndex += len;
2005   parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
2007   parser->m_errorCode = parser->m_processor(
2008       parser, start, parser->m_parseEndPtr, &parser->m_bufferPtr);
2010   if (parser->m_errorCode != XML_ERROR_NONE) {
2011     parser->m_eventEndPtr = parser->m_eventPtr;
2012     parser->m_processor = errorProcessor;
2015     switch (parser->m_parsingStatus.parsing) {
2022         parser->m_parsingStatus.parsing = XML_FINISHED;
2029   XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2030                     parser->m_bufferPtr, &parser->m_position);
2031   parser->m_positionPtr = parser->m_bufferPtr;
2036 XML_GetBuffer(XML_Parser parser, int len) {
2037   if (parser == NULL)
2040     parser->m_errorCode = XML_ERROR_NO_MEMORY;
2043   switch (parser->m_parsingStatus.parsing) {
2045     parser->m_errorCode = XML_ERROR_SUSPENDED;
2048     parser->m_errorCode = XML_ERROR_FINISHED;
2053   if (len > EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd)) {
2060                                parser->m_bufferEnd, parser->m_bufferPtr));
2062       parser->m_errorCode = XML_ERROR_NO_MEMORY;
2066     keep = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);
2071       parser->m_errorCode = XML_ERROR_NO_MEMORY;
2077         <= EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer)) {
2079       if (keep < EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)) {
2081             = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)
2085         memmove(parser->m_buffer, &parser->m_buffer[offset],
2086                 parser->m_bufferEnd - parser->m_bufferPtr + keep);
2087         parser->m_bufferEnd -= offset;
2088         parser->m_bufferPtr -= offset;
2091       if (parser->m_buffer && parser->m_bufferPtr) {
2092         memmove(parser->m_buffer, parser->m_bufferPtr,
2093                 EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
2094         parser->m_bufferEnd
2095             = parser->m_buffer
2096               + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
2097         parser->m_bufferPtr = parser->m_buffer;
2103           = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferPtr);
2111         parser->m_errorCode = XML_ERROR_NO_MEMORY;
2114       newBuf = (char *)MALLOC(parser, bufferSize);
2116         parser->m_errorCode = XML_ERROR_NO_MEMORY;
2119       parser->m_bufferLim = newBuf + bufferSize;
2121       if (parser->m_bufferPtr) {
2122         memcpy(newBuf, &parser->m_bufferPtr[-keep],
2123                EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
2125         FREE(parser, parser->m_buffer);
2126         parser->m_buffer = newBuf;
2127         parser->m_bufferEnd
2128             = parser->m_buffer
2129               + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
2131         parser->m_bufferPtr = parser->m_buffer + keep;
2134         parser->m_bufferEnd = newBuf;
2135         parser->m_bufferPtr = parser->m_buffer = newBuf;
2138       if (parser->m_bufferPtr) {
2139         memcpy(newBuf, parser->m_bufferPtr,
2140                EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
2141         FREE(parser, parser->m_buffer);
2142         parser->m_bufferEnd
2144               + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
2147         parser->m_bufferEnd = newBuf;
2149       parser->m_bufferPtr = parser->m_buffer = newBuf;
2152     parser->m_eventPtr = parser->m_eventEndPtr = NULL;
2153     parser->m_positionPtr = NULL;
2155   return parser->m_bufferEnd;
2159 XML_StopParser(XML_Parser parser, XML_Bool resumable) {
2160   if (parser == NULL)
2162   switch (parser->m_parsingStatus.parsing) {
2165       parser->m_errorCode = XML_ERROR_SUSPENDED;
2168     parser->m_parsingStatus.parsing = XML_FINISHED;
2171     parser->m_errorCode = XML_ERROR_FINISHED;
2176       if (parser->m_isParamEntity) {
2177         parser->m_errorCode = XML_ERROR_SUSPEND_PE;
2181       parser->m_parsingStatus.parsing = XML_SUSPENDED;
2183       parser->m_parsingStatus.parsing = XML_FINISHED;
2189 XML_ResumeParser(XML_Parser parser) {
2192   if (parser == NULL)
2194   if (parser->m_parsingStatus.parsing != XML_SUSPENDED) {
2195     parser->m_errorCode = XML_ERROR_NOT_SUSPENDED;
2198   parser->m_parsingStatus.parsing = XML_PARSING;
2200   parser->m_errorCode = parser->m_processor(
2201       parser, parser->m_bufferPtr, parser->m_parseEndPtr, &parser->m_bufferPtr);
2203   if (parser->m_errorCode != XML_ERROR_NONE) {
2204     parser->m_eventEndPtr = parser->m_eventPtr;
2205     parser->m_processor = errorProcessor;
2208     switch (parser->m_parsingStatus.parsing) {
2214       if (parser->m_parsingStatus.finalBuffer) {
2215         parser->m_parsingStatus.parsing = XML_FINISHED;
2222   XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2223                     parser->m_bufferPtr, &parser->m_position);
2224   parser->m_positionPtr = parser->m_bufferPtr;
2229 XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status) {
2230   if (parser == NULL)
2233   *status = parser->m_parsingStatus;
2237 XML_GetErrorCode(XML_Parser parser) {
2238   if (parser == NULL)
2240   return parser->m_errorCode;
2244 XML_GetCurrentByteIndex(XML_Parser parser) {
2245   if (parser == NULL)
2247   if (parser->m_eventPtr)
2248     return (XML_Index)(parser->m_parseEndByteIndex
2249                        - (parser->m_parseEndPtr - parser->m_eventPtr));
2254 XML_GetCurrentByteCount(XML_Parser parser) {
2255   if (parser == NULL)
2257   if (parser->m_eventEndPtr && parser->m_eventPtr)
2258     return (int)(parser->m_eventEndPtr - parser->m_eventPtr);
2263 XML_GetInputContext(XML_Parser parser, int *offset, int *size) {
2265   if (parser == NULL)
2267   if (parser->m_eventPtr && parser->m_buffer) {
2269       *offset = (int)(parser->m_eventPtr - parser->m_buffer);
2271       *size = (int)(parser->m_bufferEnd - parser->m_buffer);
2272     return parser->m_buffer;
2275   (void)parser;
2283 XML_GetCurrentLineNumber(XML_Parser parser) {
2284   if (parser == NULL)
2286   if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
2287     XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2288                       parser->m_eventPtr, &parser->m_position);
2289     parser->m_positionPtr = parser->m_eventPtr;
2291   return parser->m_position.lineNumber + 1;
2295 XML_GetCurrentColumnNumber(XML_Parser parser) {
2296   if (parser == NULL)
2298   if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
2299     XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2300                       parser->m_eventPtr, &parser->m_position);
2301     parser->m_positionPtr = parser->m_eventPtr;
2303   return parser->m_position.columnNumber;
2307 XML_FreeContentModel(XML_Parser parser, XML_Content *model) {
2308   if (parser != NULL)
2309     FREE(parser, model);
2313 XML_MemMalloc(XML_Parser parser, size_t size) {
2314   if (parser == NULL)
2316   return MALLOC(parser, size);
2320 XML_MemRealloc(XML_Parser parser, void *ptr, size_t size) {
2321   if (parser == NULL)
2323   return REALLOC(parser, ptr, size);
2327 XML_MemFree(XML_Parser parser, void *ptr) {
2328   if (parser != NULL)
2329     FREE(parser, ptr);
2333 XML_DefaultCurrent(XML_Parser parser) {
2334   if (parser == NULL)
2336   if (parser->m_defaultHandler) {
2337     if (parser->m_openInternalEntities)
2338       reportDefault(parser, parser->m_internalEncoding,
2339                     parser->m_openInternalEntities->internalEventPtr,
2340                     parser->m_openInternalEntities->internalEventEndPtr);
2342       reportDefault(parser, parser->m_encoding, parser->m_eventPtr,
2343                     parser->m_eventEndPtr);
2397     return XML_L("unexpected parser state - please send a bug report");
2419     return XML_L("parser suspended");
2421     return XML_L("parser not suspended");
2532     XML_Parser parser, float maximumAmplificationFactor) {
2533   if ((parser == NULL) || (parser->m_parentParser != NULL)
2538   parser->m_accounting.maximumAmplificationFactor = maximumAmplificationFactor;
2544     XML_Parser parser, unsigned long long activationThresholdBytes) {
2545   if ((parser == NULL) || (parser->m_parentParser != NULL)) {
2548   parser->m_accounting.activationThresholdBytes = activationThresholdBytes;
2559 storeRawNames(XML_Parser parser) {
2560   TAG *tag = parser->m_tagStack;
2582       char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
2608 contentProcessor(XML_Parser parser, const char *start, const char *end,
2611       parser, 0, parser->m_encoding, start, end, endPtr,
2612       (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_ACCOUNT_DIRECT);
2614     if (! storeRawNames(parser))
2621 externalEntityInitProcessor(XML_Parser parser, const char *start,
2623   enum XML_Error result = initializeEncoding(parser);
2626   parser->m_processor = externalEntityInitProcessor2;
2627   return externalEntityInitProcessor2(parser, start, end, endPtr);
2631 externalEntityInitProcessor2(XML_Parser parser, const char *start,
2634   int tok = XmlContentTok(parser->m_encoding, start, end, &next);
2638     if (! accountingDiffTolerated(parser, tok, start, next, __LINE__,
2640       accountingOnAbort(parser);
2650     if (next == end && ! parser->m_parsingStatus.finalBuffer) {
2657     if (! parser->m_parsingStatus.finalBuffer) {
2661     parser->m_eventPtr = start;
2664     if (! parser->m_parsingStatus.finalBuffer) {
2668     parser->m_eventPtr = start;
2671   parser->m_processor = externalEntityInitProcessor3;
2672   return externalEntityInitProcessor3(parser, start, end, endPtr);
2676 externalEntityInitProcessor3(XML_Parser parser, const char *start,
2680   parser->m_eventPtr = start;
2681   tok = XmlContentTok(parser->m_encoding, start, end, &next);
2686   parser->m_eventEndPtr = next;
2691     result = processXmlDecl(parser, 1, start, next);
2694     switch (parser->m_parsingStatus.parsing) {
2705     if (! parser->m_parsingStatus.finalBuffer) {
2711     if (! parser->m_parsingStatus.finalBuffer) {
2717   parser->m_processor = externalEntityContentProcessor;
2718   parser->m_tagLevel = 1;
2719   return externalEntityContentProcessor(parser, start, end, endPtr);
2723 externalEntityContentProcessor(XML_Parser parser, const char *start,
2726       = doContent(parser, 1, parser->m_encoding, start, end, endPtr,
2727                   (XML_Bool)! parser->m_parsingStatus.finalBuffer,
2730     if (! storeRawNames(parser))
2737 doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
2741   DTD *const dtd = parser->m_dtd;
2745   if (enc == parser->m_encoding) {
2746     eventPP = &parser->m_eventPtr;
2747     eventEndPP = &parser->m_eventEndPtr;
2749     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
2750     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
2762     if (! accountingDiffTolerated(parser, tok, s, accountAfter, __LINE__,
2764       accountingOnAbort(parser);
2776       if (parser->m_characterDataHandler) {
2778         parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
2779       } else if (parser->m_defaultHandler)
2780         reportDefault(parser, enc, s, end);
2786       if (parser->m_tagLevel != startTagLevel)
2796         if (parser->m_tagLevel != startTagLevel)
2827         accountingDiffTolerated(parser, tok, (char *)&ch,
2831         if (parser->m_characterDataHandler)
2832           parser->m_characterDataHandler(parser->m_handlerArg, &ch, 1);
2833         else if (parser->m_defaultHandler)
2834           reportDefault(parser, enc, s, next);
2841       entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
2853         if (parser->m_skippedEntityHandler)
2854           parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
2855         else if (parser->m_defaultHandler)
2856           reportDefault(parser, enc, s, next);
2865         if (! parser->m_defaultExpandInternalEntities) {
2866           if (parser->m_skippedEntityHandler)
2867             parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name,
2869           else if (parser->m_defaultHandler)
2870             reportDefault(parser, enc, s, next);
2873         result = processInternalEntity(parser, entity, XML_FALSE);
2876       } else if (parser->m_externalEntityRefHandler) {
2879         context = getContext(parser);
2883         if (! parser->m_externalEntityRefHandler(
2884                 parser->m_externalEntityRefHandlerArg, context, entity->base,
2887         poolDiscard(&parser->m_tempPool);
2888       } else if (parser->m_defaultHandler)
2889         reportDefault(parser, enc, s, next);
2898       if (parser->m_freeTagList) {
2899         tag = parser->m_freeTagList;
2900         parser->m_freeTagList = parser->m_freeTagList->parent;
2902         tag = (TAG *)MALLOC(parser, sizeof(TAG));
2905         tag->buf = (char *)MALLOC(parser, INIT_TAG_BUF_SIZE);
2907           FREE(parser, tag);
2913       tag->parent = parser->m_tagStack;
2914       parser->m_tagStack = tag;
2919       ++parser->m_tagLevel;
2938             char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
2950           = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings), account);
2953       if (parser->m_startElementHandler)
2954         parser->m_startElementHandler(parser->m_handlerArg, tag->name.str,
2955                                       (const XML_Char **)parser->m_atts);
2956       else if (parser->m_defaultHandler)
2957         reportDefault(parser, enc, s, next);
2958       poolClear(&parser->m_tempPool);
2969       name.str = poolStoreString(&parser->m_tempPool, enc, rawName,
2973       poolFinish(&parser->m_tempPool);
2974       result = storeAtts(parser, enc, s, &name, &bindings,
2977         freeBindings(parser, bindings);
2980       poolFinish(&parser->m_tempPool);
2981       if (parser->m_startElementHandler) {
2982         parser->m_startElementHandler(parser->m_handlerArg, name.str,
2983                                       (const XML_Char **)parser->m_atts);
2986       if (parser->m_endElementHandler) {
2987         if (parser->m_startElementHandler)
2989         parser->m_endElementHandler(parser->m_handlerArg, name.str);
2992       if (noElmHandlers && parser->m_defaultHandler)
2993         reportDefault(parser, enc, s, next);
2994       poolClear(&parser->m_tempPool);
2995       freeBindings(parser, bindings);
2997       if ((parser->m_tagLevel == 0)
2998           && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
2999         if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
3000           parser->m_processor = epilogProcessor;
3002           return epilogProcessor(parser, next, end, nextPtr);
3006       if (parser->m_tagLevel == startTagLevel)
3011         TAG *tag = parser->m_tagStack;
3012         parser->m_tagStack = tag->parent;
3013         tag->parent = parser->m_freeTagList;
3014         parser->m_freeTagList = tag;
3022         --parser->m_tagLevel;
3023         if (parser->m_endElementHandler) {
3028           if (parser->m_ns && localPart) {
3038             if (parser->m_ns_triplets && prefix) {
3039               *uri++ = parser->m_namespaceSeparator;
3045           parser->m_endElementHandler(parser->m_handlerArg, tag->name.str);
3046         } else if (parser->m_defaultHandler)
3047           reportDefault(parser, enc, s, next);
3050           if (parser->m_endNamespaceDeclHandler)
3051             parser->m_endNamespaceDeclHandler(parser->m_handlerArg,
3054           b->nextTagBinding = parser->m_freeBindingList;
3055           parser->m_freeBindingList = b;
3058         if ((parser->m_tagLevel == 0)
3059             && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
3060           if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
3061             parser->m_processor = epilogProcessor;
3063             return epilogProcessor(parser, next, end, nextPtr);
3071       if (parser->m_characterDataHandler) {
3073         parser->m_characterDataHandler(parser->m_handlerArg, buf,
3075       } else if (parser->m_defaultHandler)
3076         reportDefault(parser, enc, s, next);
3081       if (parser->m_characterDataHandler) {
3083         parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
3084       } else if (parser->m_defaultHandler)
3085         reportDefault(parser, enc, s, next);
3089       if (parser->m_startCdataSectionHandler)
3090         parser->m_startCdataSectionHandler(parser->m_handlerArg);
3104       else if (0 && parser->m_characterDataHandler)
3105         parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
3108       else if (parser->m_defaultHandler)
3109         reportDefault(parser, enc, s, next);
3111           = doCdataSection(parser, enc, &next, end, nextPtr, haveMore, account);
3115         parser->m_processor = cdataSectionProcessor;
3124       if (parser->m_characterDataHandler) {
3126           ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
3127           XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
3128           parser->m_characterDataHandler(
3129               parser->m_handlerArg, parser->m_dataBuf,
3130               (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
3132           parser->m_characterDataHandler(
3133               parser->m_handlerArg, (XML_Char *)s,
3135       } else if (parser->m_defaultHandler)
3136         reportDefault(parser, enc, s, end);
3144       if (parser->m_tagLevel != startTagLevel) {
3151       XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
3155             ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
3157                 enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
3159             charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
3160                             (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
3167           charDataHandler(parser->m_handlerArg, (XML_Char *)s,
3169       } else if (parser->m_defaultHandler)
3170         reportDefault(parser, enc, s, next);
3173       if (! reportProcessingInstruction(parser, enc, s, next))
3177       if (! reportComment(parser, enc, s, next))
3188       if (parser->m_defaultHandler)
3189         reportDefault(parser, enc, s, next);
3194     switch (parser->m_parsingStatus.parsing) {
3207  * moving it to the parser's m_freeBindingList where it can be freed or
3211 freeBindings(XML_Parser parser, BINDING *bindings) {
3218     if (parser->m_endNamespaceDeclHandler)
3219       parser->m_endNamespaceDeclHandler(parser->m_handlerArg, b->prefix->name);
3222     b->nextTagBinding = parser->m_freeBindingList;
3223     parser->m_freeBindingList = b;
3239 storeAtts(XML_Parser parser, const ENCODING *enc, const char *attStr,
3242   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
3257       = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str, 0);
3262     elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
3266     if (parser->m_ns && ! setElementTypePrefix(parser, elementType))
3272   n = XmlGetAttributes(enc, attStr, parser->m_attsSize, parser->m_atts);
3279   if (n + nDefaultAtts > parser->m_attsSize) {
3280     int oldAttsSize = parser->m_attsSize;
3292     parser->m_attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
3299     if ((unsigned)parser->m_attsSize > (size_t)(-1) / sizeof(ATTRIBUTE)) {
3300       parser->m_attsSize = oldAttsSize;
3305     temp = (ATTRIBUTE *)REALLOC(parser, (void *)parser->m_atts,
3306                                 parser->m_attsSize * sizeof(ATTRIBUTE));
3308       parser->m_attsSize = oldAttsSize;
3311     parser->m_atts = temp;
3318     if ((unsigned)parser->m_attsSize > (size_t)(-1) / sizeof(XML_AttrInfo)) {
3319       parser->m_attsSize = oldAttsSize;
3324     temp2 = (XML_AttrInfo *)REALLOC(parser, (void *)parser->m_attInfo,
3325                                     parser->m_attsSize * sizeof(XML_AttrInfo));
3327       parser->m_attsSize = oldAttsSize;
3330     parser->m_attInfo = temp2;
3333       XmlGetAttributes(enc, attStr, n, parser->m_atts);
3336   appAtts = (const XML_Char **)parser->m_atts;
3338     ATTRIBUTE *currAtt = &parser->m_atts[i];
3340     XML_AttrInfo *currAttInfo = &parser->m_attInfo[i];
3344         = getAttributeId(parser, enc, currAtt->name,
3350         = parser->m_parseEndByteIndex - (parser->m_parseEndPtr - currAtt->name);
3353     currAttInfo->valueStart = parser->m_parseEndByteIndex
3354                               - (parser->m_parseEndPtr - currAtt->valuePtr);
3355     currAttInfo->valueEnd = parser->m_parseEndByteIndex
3356                             - (parser->m_parseEndPtr - currAtt->valueEnd);
3363       if (enc == parser->m_encoding)
3364         parser->m_eventPtr = parser->m_atts[i].name;
3369     if (! parser->m_atts[i].normalized) {
3386           parser, enc, isCdata, parser->m_atts[i].valuePtr,
3387           parser->m_atts[i].valueEnd, &parser->m_tempPool, account);
3390       appAtts[attIndex] = poolStart(&parser->m_tempPool);
3391       poolFinish(&parser->m_tempPool);
3394       appAtts[attIndex] = poolStoreString(&parser->m_tempPool, enc,
3395                                           parser->m_atts[i].valuePtr,
3396                                           parser->m_atts[i].valueEnd);
3399       poolFinish(&parser->m_tempPool);
3405         enum XML_Error result = addBinding(parser, attId->prefix, attId,
3421   parser->m_nSpecifiedAtts = attIndex;
3425         parser->m_idAttIndex = i;
3429     parser->m_idAttIndex = -1;
3437           enum XML_Error result = addBinding(parser, da->id->prefix, da->id,
3461     unsigned long version = parser->m_nsAttsVersion;
3464     if (parser->m_nsAttsPower >= sizeof(unsigned int) * 8 /* bits per byte */) {
3468     unsigned int nsAttsSize = 1u << parser->m_nsAttsPower;
3469     unsigned char oldNsAttsPower = parser->m_nsAttsPower;
3472         >> parser->m_nsAttsPower) { /* true for m_nsAttsPower = 0 */
3475       while (nPrefixes >> parser->m_nsAttsPower++)
3477       if (parser->m_nsAttsPower < 3)
3478         parser->m_nsAttsPower = 3;
3481       if (parser->m_nsAttsPower >= sizeof(nsAttsSize) * 8 /* bits per byte */) {
3483         parser->m_nsAttsPower = oldNsAttsPower;
3487       nsAttsSize = 1u << parser->m_nsAttsPower;
3496         parser->m_nsAttsPower = oldNsAttsPower;
3501       temp = (NS_ATT *)REALLOC(parser, parser->m_nsAtts,
3505         parser->m_nsAttsPower = oldNsAttsPower;
3508       parser->m_nsAtts = temp;
3515         parser->m_nsAtts[--j].version = version;
3517     parser->m_nsAttsVersion = --version;
3529         copy_salt_to_sipkey(parser, &sip_key);
3533         id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);
3557           if (! poolAppendChar(&parser->m_tempPool, c))
3569           if (! poolAppendChar(&parser->m_tempPool, *s))
3576              Derived from code in lookup(parser, HASH_TABLE *table, ...).
3581           while (parser->m_nsAtts[j].version == version) {
3583             if (uriHash == parser->m_nsAtts[j].hash) {
3584               const XML_Char *s1 = poolStart(&parser->m_tempPool);
3585               const XML_Char *s2 = parser->m_nsAtts[j].uriName;
3593               step = PROBE_STEP(uriHash, mask, parser->m_nsAttsPower);
3598         if (parser->m_ns_triplets) { /* append namespace separator and prefix */
3599           parser->m_tempPool.ptr[-1] = parser->m_namespaceSeparator;
3602             if (! poolAppendChar(&parser->m_tempPool, *s))
3608         s = poolStart(&parser->m_tempPool);
3609         poolFinish(&parser->m_tempPool);
3613         parser->m_nsAtts[j].version = version;
3614         parser->m_nsAtts[j].hash = uriHash;
3615         parser->m_nsAtts[j].uriName = s;
3631   if (! parser->m_ns)
3648   if (parser->m_ns_triplets && binding->prefix->name) {
3683     uri = (XML_Char *)MALLOC(parser, (n + EXPAND_SPARE) * sizeof(XML_Char));
3688     for (p = parser->m_tagStack; p; p = p->parent)
3691     FREE(parser, binding->uri);
3700     *uri = parser->m_namespaceSeparator; /* replace null terminator */
3711 addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
3770     if (parser->m_ns && (uri[len] == parser->m_namespaceSeparator)) {
3784   if (parser->m_namespaceSeparator)
3786   if (parser->m_freeBindingList) {
3787     b = parser->m_freeBindingList;
3805           parser, b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));
3811     parser->m_freeBindingList = b->nextTagBinding;
3813     b = (BINDING *)MALLOC(parser, sizeof(BINDING));
3832         = (XML_Char *)MALLOC(parser, sizeof(XML_Char) * (len + EXPAND_SPARE));
3834       FREE(parser, b);
3841   if (parser->m_namespaceSeparator)
3842     b->uri[len - 1] = parser->m_namespaceSeparator;
3847   if (*uri == XML_T('\0') && prefix == &parser->m_dtd->defaultPrefix)
3854   if (attId && parser->m_startNamespaceDeclHandler)
3855     parser->m_startNamespaceDeclHandler(parser->m_handlerArg, prefix->name,
3864 cdataSectionProcessor(XML_Parser parser, const char *start, const char *end,
3867       parser, parser->m_encoding, &start, end, endPtr,
3868       (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_ACCOUNT_DIRECT);
3872     if (parser->m_parentParser) { /* we are parsing an external entity */
3873       parser->m_processor = externalEntityContentProcessor;
3874       return externalEntityContentProcessor(parser, start, end, endPtr);
3876       parser->m_processor = contentProcessor;
3877       return contentProcessor(parser, start, end, endPtr);
3887 doCdataSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
3893   if (enc == parser->m_encoding) {
3894     eventPP = &parser->m_eventPtr;
3896     eventEndPP = &parser->m_eventEndPtr;
3898     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
3899     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
3908     if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
3909       accountingOnAbort(parser);
3918       if (parser->m_endCdataSectionHandler)
3919         parser->m_endCdataSectionHandler(parser->m_handlerArg);
3922       else if (0 && parser->m_characterDataHandler)
3923         parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
3926       else if (parser->m_defaultHandler)
3927         reportDefault(parser, enc, s, next);
3930       if (parser->m_parsingStatus.parsing == XML_FINISHED)
3935       if (parser->m_characterDataHandler) {
3937         parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
3938       } else if (parser->m_defaultHandler)
3939         reportDefault(parser, enc, s, next);
3942       XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
3946             ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
3948                 enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
3950             charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
3951                             (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
3958           charDataHandler(parser->m_handlerArg, (XML_Char *)s,
3960       } else if (parser->m_defaultHandler)
3961         reportDefault(parser, enc, s, next);
3993     switch (parser->m_parsingStatus.parsing) {
4011 ignoreSectionProcessor(XML_Parser parser, const char *start, const char *end,
4014       = doIgnoreSection(parser, parser->m_encoding, &start, end, endPtr,
4015                         (XML_Bool)! parser->m_parsingStatus.finalBuffer);
4019     parser->m_processor = prologProcessor;
4020     return prologProcessor(parser, start, end, endPtr);
4029 doIgnoreSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
4036   if (enc == parser->m_encoding) {
4037     eventPP = &parser->m_eventPtr;
4039     eventEndPP = &parser->m_eventEndPtr;
4052     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
4053     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
4060   if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4062     accountingOnAbort(parser);
4069     if (parser->m_defaultHandler)
4070       reportDefault(parser, enc, s, next);
4073     if (parser->m_parsingStatus.parsing == XML_FINISHED)
4111 initializeEncoding(XML_Parser parser) {
4116   if (! parser->m_protocolEncodingName)
4120     for (i = 0; parser->m_protocolEncodingName[i]; i++) {
4122           || (parser->m_protocolEncodingName[i] & ~0x7f) != 0) {
4126       encodingBuf[i] = (char)parser->m_protocolEncodingName[i];
4132   s = parser->m_protocolEncodingName;
4134   if ((parser->m_ns ? XmlInitEncodingNS : XmlInitEncoding)(
4135           &parser->m_initEncoding, &parser->m_encoding, s))
4137   return handleUnknownEncoding(parser, parser->m_protocolEncodingName);
4141 processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *s,
4152   if (! accountingDiffTolerated(parser, XML_TOK_XML_DECL, s, next, __LINE__,
4154     accountingOnAbort(parser);
4159   if (! (parser->m_ns ? XmlParseXmlDeclNS : XmlParseXmlDecl)(
4160           isGeneralTextEntity, parser->m_encoding, s, next, &parser->m_eventPtr,
4168     parser->m_dtd->standalone = XML_TRUE;
4170     if (parser->m_paramEntityParsing
4172       parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
4175   if (parser->m_xmlDeclHandler) {
4178           &parser->m_temp2Pool, parser->m_encoding, encodingName,
4179           encodingName + XmlNameLength(parser->m_encoding, encodingName));
4182       poolFinish(&parser->m_temp2Pool);
4186           = poolStoreString(&parser->m_temp2Pool, parser->m_encoding, version,
4187                             versionend - parser->m_encoding->minBytesPerChar);
4191     parser->m_xmlDeclHandler(parser->m_handlerArg, storedversion, storedEncName,
4193   } else if (parser->m_defaultHandler)
4194     reportDefault(parser, parser->m_encoding, s, next);
4195   if (parser->m_protocolEncodingName == NULL) {
4198        * the parser has already deduced.  Do we have the same number
4202       if (newEncoding->minBytesPerChar != parser->m_encoding->minBytesPerChar
4204               && newEncoding != parser->m_encoding)) {
4205         parser->m_eventPtr = encodingName;
4208       parser->m_encoding = newEncoding;
4213             &parser->m_temp2Pool, parser->m_encoding, encodingName,
4214             encodingName + XmlNameLength(parser->m_encoding, encodingName));
4218       result = handleUnknownEncoding(parser, storedEncName);
4219       poolClear(&parser->m_temp2Pool);
4221         parser->m_eventPtr = encodingName;
4227     poolClear(&parser->m_temp2Pool);
4233 handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName) {
4234   if (parser->m_unknownEncodingHandler) {
4242     if (parser->m_unknownEncodingHandler(parser->m_unknownEncodingHandlerData,
4245       parser->m_unknownEncodingMem = MALLOC(parser, XmlSizeOfUnknownEncoding());
4246       if (! parser->m_unknownEncodingMem) {
4251       enc = (parser->m_ns ? XmlInitUnknownEncodingNS : XmlInitUnknownEncoding)(
4252           parser->m_unknownEncodingMem, info.map, info.convert, info.data);
4254         parser->m_unknownEncodingData = info.data;
4255         parser->m_unknownEncodingRelease = info.release;
4256         parser->m_encoding = enc;
4267 prologInitProcessor(XML_Parser parser, const char *s, const char *end,
4269   enum XML_Error result = initializeEncoding(parser);
4272   parser->m_processor = prologProcessor;
4273   return prologProcessor(parser, s, end, nextPtr);
4279 externalParEntInitProcessor(XML_Parser parser, const char *s, const char *end,
4281   enum XML_Error result = initializeEncoding(parser);
4287   parser->m_dtd->paramEntityRead = XML_TRUE;
4289   if (parser->m_prologState.inEntityValue) {
4290     parser->m_processor = entityValueInitProcessor;
4291     return entityValueInitProcessor(parser, s, end, nextPtr);
4293     parser->m_processor = externalParEntProcessor;
4294     return externalParEntProcessor(parser, s, end, nextPtr);
4299 entityValueInitProcessor(XML_Parser parser, const char *s, const char *end,
4304   parser->m_eventPtr = start;
4307     tok = XmlPrologTok(parser->m_encoding, start, end, &next);
4312     parser->m_eventEndPtr = next;
4314       if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
4330       return storeEntityValue(parser, parser->m_encoding, s, end,
4334       result = processXmlDecl(parser, 0, start, next);
4339        * to suspend the parser, which fails and raises an error.  The parser can
4342       if (parser->m_parsingStatus.parsing == XML_FINISHED)
4346       parser->m_processor = entityValueProcessor;
4347       return entityValueProcessor(parser, next, end, nextPtr);
4357              && ! parser->m_parsingStatus.finalBuffer) {
4359       if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4361         accountingOnAbort(parser);
4378     parser->m_eventPtr = start;
4383 externalParEntProcessor(XML_Parser parser, const char *s, const char *end,
4388   tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4390     if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
4412     if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4414       accountingOnAbort(parser);
4419     tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4422   parser->m_processor = prologProcessor;
4423   return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
4424                   (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
4429 entityValueProcessor(XML_Parser parser, const char *s, const char *end,
4433   const ENCODING *enc = parser->m_encoding;
4442       if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
4458       return storeEntityValue(parser, enc, s, end, XML_ACCOUNT_DIRECT);
4467 prologProcessor(XML_Parser parser, const char *s, const char *end,
4470   int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4471   return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
4472                   (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
4477 doProlog(XML_Parser parser, const ENCODING *enc, const char *s, const char *end,
4511   DTD *const dtd = parser->m_dtd;
4517   if (enc == parser->m_encoding) {
4518     eventPP = &parser->m_eventPtr;
4519     eventEndPP = &parser->m_eventEndPtr;
4521     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
4522     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
4549         if (enc != parser->m_encoding
4550             && ! parser->m_openInternalEntities->betweenDecl) {
4558         if (parser->m_isParamEntity || enc != parser->m_encoding) {
4559           if (XmlTokenRole(&parser->m_prologState, XML_TOK_NONE, end, end, enc)
4573     role = XmlTokenRole(&parser->m_prologState, tok, s, next, enc);
4581       if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
4582         accountingOnAbort(parser);
4589       enum XML_Error result = processXmlDecl(parser, 0, s, next);
4592       enc = parser->m_encoding;
4596       if (parser->m_startDoctypeDeclHandler) {
4597         parser->m_doctypeName
4598             = poolStoreString(&parser->m_tempPool, enc, s, next);
4599         if (! parser->m_doctypeName)
4601         poolFinish(&parser->m_tempPool);
4602         parser->m_doctypePubid = NULL;
4605       parser->m_doctypeSysid = NULL; /* always initialize to NULL */
4608       if (parser->m_startDoctypeDeclHandler) {
4609         parser->m_startDoctypeDeclHandler(
4610             parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
4611             parser->m_doctypePubid, 1);
4612         parser->m_doctypeName = NULL;
4613         poolClear(&parser->m_tempPool);
4619       enum XML_Error result = processXmlDecl(parser, 1, s, next);
4622       enc = parser->m_encoding;
4628       parser->m_useForeignDTD = XML_FALSE;
4629       parser->m_declEntity = (ENTITY *)lookup(
4630           parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
4631       if (! parser->m_declEntity)
4635       if (parser->m_startDoctypeDeclHandler) {
4639         pubId = poolStoreString(&parser->m_tempPool, enc,
4645         poolFinish(&parser->m_tempPool);
4646         parser->m_doctypePubid = pubId;
4655       if (dtd->keepProcessing && parser->m_declEntity) {
4662         parser->m_declEntity->publicId = tem;
4667         if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_PUBLIC_ID)
4677       if (parser->m_doctypeName) {
4678         parser->m_startDoctypeDeclHandler(
4679             parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
4680             parser->m_doctypePubid, 0);
4681         poolClear(&parser->m_tempPool);
4684       /* parser->m_doctypeSysid will be non-NULL in the case of a previous
4685          XML_ROLE_DOCTYPE_SYSTEM_ID, even if parser->m_startDoctypeDeclHandler
4689       if (parser->m_doctypeSysid || parser->m_useForeignDTD) {
4692         if (parser->m_paramEntityParsing
4693             && parser->m_externalEntityRefHandler) {
4694           ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
4704           if (parser->m_useForeignDTD)
4705             entity->base = parser->m_curBase;
4707           if (! parser->m_externalEntityRefHandler(
4708                   parser->m_externalEntityRefHandlerArg, 0, entity->base,
4712             if (! dtd->standalone && parser->m_notStandaloneHandler
4713                 && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
4719           else if (! parser->m_doctypeSysid)
4723         parser->m_useForeignDTD = XML_FALSE;
4726       if (parser->m_endDoctypeDeclHandler) {
4727         parser->m_endDoctypeDeclHandler(parser->m_handlerArg);
4736       if (parser->m_useForeignDTD) {
4739         if (parser->m_paramEntityParsing
4740             && parser->m_externalEntityRefHandler) {
4741           ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
4745           entity->base = parser->m_curBase;
4747           if (! parser->m_externalEntityRefHandler(
4748                   parser->m_externalEntityRefHandlerArg, 0, entity->base,
4752             if (! dtd->standalone && parser->m_notStandaloneHandler
4753                 && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
4765       parser->m_processor = contentProcessor;
4766       return contentProcessor(parser, s, end, nextPtr);
4768       parser->m_declElementType = getElementType(parser, enc, s, next);
4769       if (! parser->m_declElementType)
4773       parser->m_declAttributeId = getAttributeId(parser, enc, s, next);
4774       if (! parser->m_declAttributeId)
4776       parser->m_declAttributeIsCdata = XML_FALSE;
4777       parser->m_declAttributeType = NULL;
4778       parser->m_declAttributeIsId = XML_FALSE;
4781       parser->m_declAttributeIsCdata = XML_TRUE;
4782       parser->m_declAttributeType = atypeCDATA;
4785       parser->m_declAttributeIsId = XML_TRUE;
4786       parser->m_declAttributeType = atypeID;
4789       parser->m_declAttributeType = atypeIDREF;
4792       parser->m_declAttributeType = atypeIDREFS;
4795       parser->m_declAttributeType = atypeENTITY;
4798       parser->m_declAttributeType = atypeENTITIES;
4801       parser->m_declAttributeType = atypeNMTOKEN;
4804       parser->m_declAttributeType = atypeNMTOKENS;
4806       if (dtd->keepProcessing && parser->m_attlistDeclHandler)
4811       if (dtd->keepProcessing && parser->m_attlistDeclHandler) {
4813         if (parser->m_declAttributeType) {
4819         if (! poolAppendString(&parser->m_tempPool, prefix))
4821         if (! poolAppend(&parser->m_tempPool, enc, s, next))
4823         parser->m_declAttributeType = parser->m_tempPool.start;
4830         if (! defineAttribute(parser->m_declElementType,
4831                               parser->m_declAttributeId,
4832                               parser->m_declAttributeIsCdata,
4833                               parser->m_declAttributeIsId, 0, parser))
4835         if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
4836           if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
4837               || (*parser->m_declAttributeType == XML_T(ASCII_N)
4838                   && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
4840             if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
4841                 || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
4843             parser->m_declAttributeType = parser->m_tempPool.start;
4844             poolFinish(&parser->m_tempPool);
4847           parser->m_attlistDeclHandler(
4848               parser->m_handlerArg, parser->m_declElementType->name,
4849               parser->m_declAttributeId->name, parser->m_declAttributeType, 0,
4851           poolClear(&parser->m_tempPool);
4861             parser, enc, parser->m_declAttributeIsCdata,
4870                 parser->m_declElementType, parser->m_declAttributeId,
4871                 parser->m_declAttributeIsCdata, XML_FALSE, attVal, parser))
4873         if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
4874           if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
4875               || (*parser->m_declAttributeType == XML_T(ASCII_N)
4876                   && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
4878             if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
4879                 || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
4881             parser->m_declAttributeType = parser->m_tempPool.start;
4882             poolFinish(&parser->m_tempPool);
4885           parser->m_attlistDeclHandler(
4886               parser->m_handlerArg, parser->m_declElementType->name,
4887               parser->m_declAttributeId->name, parser->m_declAttributeType,
4889           poolClear(&parser->m_tempPool);
4897             = storeEntityValue(parser, enc, s + enc->minBytesPerChar,
4899         if (parser->m_declEntity) {
4900           parser->m_declEntity->textPtr = poolStart(&dtd->entityValuePool);
4901           parser->m_declEntity->textLen
4904           if (parser->m_entityDeclHandler) {
4906             parser->m_entityDeclHandler(
4907                 parser->m_handlerArg, parser->m_declEntity->name,
4908                 parser->m_declEntity->is_param, parser->m_declEntity->textPtr,
4909                 parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);
4920       parser->m_useForeignDTD = XML_FALSE;
4923       if (parser->m_startDoctypeDeclHandler) {
4924         parser->m_doctypeSysid = poolStoreString(&parser->m_tempPool, enc,
4927         if (parser->m_doctypeSysid == NULL)
4929         poolFinish(&parser->m_tempPool);
4934         /* use externalSubsetName to make parser->m_doctypeSysid non-NULL
4935            for the case where no parser->m_startDoctypeDeclHandler is set */
4936         parser->m_doctypeSysid = externalSubsetName;
4940           && ! parser->m_paramEntityParsing
4942           && parser->m_notStandaloneHandler
4943           && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
4948       if (! parser->m_declEntity) {
4949         parser->m_declEntity = (ENTITY *)lookup(
4950             parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
4951         if (! parser->m_declEntity)
4953         parser->m_declEntity->publicId = NULL;
4958       if (dtd->keepProcessing && parser->m_declEntity) {
4959         parser->m_declEntity->systemId
4962         if (! parser->m_declEntity->systemId)
4964         parser->m_declEntity->base = parser->m_curBase;
4969         if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_SYSTEM_ID)
4974       if (dtd->keepProcessing && parser->m_declEntity
4975           && parser->m_entityDeclHandler) {
4977         parser->m_entityDeclHandler(
4978             parser->m_handlerArg, parser->m_declEntity->name,
4979             parser->m_declEntity->is_param, 0, 0, parser->m_declEntity->base,
4980             parser->m_declEntity->systemId, parser->m_declEntity->publicId, 0);
4985       if (dtd->keepProcessing && parser->m_declEntity) {
4986         parser->m_declEntity->notation
4988         if (! parser->m_declEntity->notation)
4991         if (parser->m_unparsedEntityDeclHandler) {
4993           parser->m_unparsedEntityDeclHandler(
4994               parser->m_handlerArg, parser->m_declEntity->name,
4995               parser->m_declEntity->base, parser->m_declEntity->systemId,
4996               parser->m_declEntity->publicId, parser->m_declEntity->notation);
4998         } else if (parser->m_entityDeclHandler) {
5000           parser->m_entityDeclHandler(
5001               parser->m_handlerArg, parser->m_declEntity->name, 0, 0, 0,
5002               parser->m_declEntity->base, parser->m_declEntity->systemId,
5003               parser->m_declEntity->publicId, parser->m_declEntity->notation);
5010         parser->m_declEntity = NULL;
5017         parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities,
5019         if (! parser->m_declEntity)
5021         if (parser->m_declEntity->name != name) {
5023           parser->m_declEntity = NULL;
5026           parser->m_declEntity->publicId = NULL;
5027           parser->m_declEntity->is_param = XML_FALSE;
5028           /* if we have a parent parser or are reading an internal parameter
5031           parser->m_declEntity->is_internal
5032               = ! (parser->m_parentParser || parser->m_openInternalEntities);
5033           if (parser->m_entityDeclHandler)
5038         parser->m_declEntity = NULL;
5047         parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,
5049         if (! parser->m_declEntity)
5051         if (parser->m_declEntity->name != name) {
5053           parser->m_declEntity = NULL;
5056           parser->m_declEntity->publicId = NULL;
5057           parser->m_declEntity->is_param = XML_TRUE;
5058           /* if we have a parent parser or are reading an internal parameter
5061           parser->m_declEntity->is_internal
5062               = ! (parser->m_parentParser || parser->m_openInternalEntities);
5063           if (parser->m_entityDeclHandler)
5068         parser->m_declEntity = NULL;
5071       parser->m_declEntity = NULL;
5075       parser->m_declNotationPublicId = NULL;
5076       parser->m_declNotationName = NULL;
5077       if (parser->m_notationDeclHandler) {
5078         parser->m_declNotationName
5079             = poolStoreString(&parser->m_tempPool, enc, s, next);
5080         if (! parser->m_declNotationName)
5082         poolFinish(&parser->m_tempPool);
5089       if (parser
5091         XML_Char *tem = poolStoreString(&parser->m_tempPool, enc,
5097         parser->m_declNotationPublicId = tem;
5098         poolFinish(&parser->m_tempPool);
5103       if (parser->m_declNotationName && parser->m_notationDeclHandler) {
5104         const XML_Char *systemId = poolStoreString(&parser->m_tempPool, enc,
5110         parser->m_notationDeclHandler(
5111             parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
5112             systemId, parser->m_declNotationPublicId);
5115       poolClear(&parser->m_tempPool);
5118       if (parser->m_declNotationPublicId && parser->m_notationDeclHandler) {
5120         parser->m_notationDeclHandler(
5121             parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
5122             0, parser->m_declNotationPublicId);
5125       poolClear(&parser->m_tempPool);
5141       if (parser->m_defaultHandler)
5142         reportDefault(parser, enc, s, next);
5144       result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
5148         parser->m_processor = ignoreSectionProcessor;
5154       if (parser->m_prologState.level >= parser->m_groupSize) {
5155         if (parser->m_groupSize) {
5158             if (parser->m_groupSize > (unsigned int)(-1) / 2u) {
5163                 parser, parser->m_groupConnector, parser->m_groupSize *= 2);
5165               parser->m_groupSize /= 2;
5168             parser->m_groupConnector = new_connector;
5177             if (parser->m_groupSize > (size_t)(-1) / sizeof(int)) {
5183                 parser, dtd->scaffIndex, parser->m_groupSize * sizeof(int));
5189           parser->m_groupConnector
5190               = (char *)MALLOC(parser, parser->m_groupSize = 32);
5191           if (! parser->m_groupConnector) {
5192             parser->m_groupSize = 0;
5197       parser->m_groupConnector[parser->m_prologState.level] = 0;
5199         int myindex = nextScaffoldPart(parser);
5206         if (parser->m_elementDeclHandler)
5211       if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_PIPE)
5213       parser->m_groupConnector[parser->m_prologState.level] = ASCII_COMMA;
5214       if (dtd->in_eldecl && parser->m_elementDeclHandler)
5218       if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_COMMA)
5221           && ! parser->m_groupConnector[parser->m_prologState.level]
5226         if (parser->m_elementDeclHandler)
5229       parser->m_groupConnector[parser->m_prologState.level] = ASCII_PIPE;
5235       if (! parser->m_paramEntityParsing)
5244         entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
5250         if (parser->m_prologState.documentEntity
5251             && (dtd->standalone ? ! parser->m_openInternalEntities
5282               && parser->m_skippedEntityHandler) {
5283             parser->m_skippedEntityHandler(parser->m_handlerArg, name, 1);
5294           result = processInternalEntity(parser, entity, betweenDecl);
5300         if (parser->m_externalEntityRefHandler) {
5303           entityTrackingOnOpen(parser, entity, __LINE__);
5304           if (! parser->m_externalEntityRefHandler(
5305                   parser->m_externalEntityRefHandlerArg, 0, entity->base,
5307             entityTrackingOnClose(parser, entity, __LINE__);
5311           entityTrackingOnClose(parser, entity, __LINE__);
5324       if (! dtd->standalone && parser->m_notStandaloneHandler
5325           && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
5332       if (parser->m_elementDeclHandler) {
5333         parser->m_declElementType = getElementType(parser, enc, s, next);
5334         if (! parser->m_declElementType)
5346         if (parser->m_elementDeclHandler) {
5348               = (XML_Content *)MALLOC(parser, sizeof(XML_Content));
5358           parser->m_elementDeclHandler(
5359               parser->m_handlerArg, parser->m_declElementType->name, content);
5370         if (parser->m_elementDeclHandler)
5393         int myindex = nextScaffoldPart(parser);
5398         el = getElementType(parser, enc, s, nxt);
5413         if (parser->m_elementDeclHandler)
5431         if (parser->m_elementDeclHandler)
5437             XML_Content *model = build_model(parser);
5441             parser->m_elementDeclHandler(
5442                 parser->m_handlerArg, parser->m_declElementType->name, model);
5452       if (! reportProcessingInstruction(parser, enc, s, next))
5457       if (! reportComment(parser, enc, s, next))
5469       if (parser->m_startDoctypeDeclHandler)
5473       if (dtd->keepProcessing && parser->m_entityDeclHandler)
5477       if (parser->m_notationDeclHandler)
5481       if (dtd->keepProcessing && parser->m_attlistDeclHandler)
5485       if (parser->m_elementDeclHandler)
5490     if (handleDefault && parser->m_defaultHandler)
5491       reportDefault(parser, enc, s, next);
5493     switch (parser->m_parsingStatus.parsing) {
5508 epilogProcessor(XML_Parser parser, const char *s, const char *end,
5510   parser->m_processor = epilogProcessor;
5511   parser->m_eventPtr = s;
5514     int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
5516     if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
5518       accountingOnAbort(parser);
5522     parser->m_eventEndPtr = next;
5526       if (parser->m_defaultHandler) {
5527         reportDefault(parser, parser->m_encoding, s, next);
5528         if (parser->m_parsingStatus.parsing == XML_FINISHED)
5537       if (parser->m_defaultHandler)
5538         reportDefault(parser, parser->m_encoding, s, next);
5541       if (! reportProcessingInstruction(parser, parser->m_encoding, s, next))
5545       if (! reportComment(parser, parser->m_encoding, s, next))
5549       parser->m_eventPtr = next;
5552       if (! parser->m_parsingStatus.finalBuffer) {
5558       if (! parser->m_parsingStatus.finalBuffer) {
5566     parser->m_eventPtr = s = next;
5567     switch (parser->m_parsingStatus.parsing) {
5579 processInternalEntity(XML_Parser parser, ENTITY *entity, XML_Bool betweenDecl) {
5585   if (parser->m_freeInternalEntities) {
5586     openEntity = parser->m_freeInternalEntities;
5587     parser->m_freeInternalEntities = openEntity->next;
5590         = (OPEN_INTERNAL_ENTITY *)MALLOC(parser, sizeof(OPEN_INTERNAL_ENTITY));
5596   entityTrackingOnOpen(parser, entity, __LINE__);
5599   openEntity->next = parser->m_openInternalEntities;
5600   parser->m_openInternalEntities = openEntity;
5602   openEntity->startTagLevel = parser->m_tagLevel;
5614         = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
5615     result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
5620     result = doContent(parser, parser->m_tagLevel, parser->m_internalEncoding,
5625     if (textEnd != next && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
5627       parser->m_processor = internalEntityProcessor;
5630       entityTrackingOnClose(parser, entity, __LINE__);
5633       parser->m_openInternalEntities = openEntity->next;
5635       openEntity->next = parser->m_freeInternalEntities;
5636       parser->m_freeInternalEntities = openEntity;
5643 internalEntityProcessor(XML_Parser parser, const char *s, const char *end,
5649   OPEN_INTERNAL_ENTITY *openEntity = parser->m_openInternalEntities;
5662         = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
5663     result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
5668     result = doContent(parser, openEntity->startTagLevel,
5669                        parser->m_internalEncoding, textStart, textEnd, &next,
5675            && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
5680     entityTrackingOnClose(parser, entity, __LINE__);
5683     parser->m_openInternalEntities = openEntity->next;
5685     openEntity->next = parser->m_freeInternalEntities;
5686     parser->m_freeInternalEntities = openEntity;
5692     parser->m_processor = prologProcessor;
5693     tok = XmlPrologTok(parser->m_encoding, s, end, &next);
5694     return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
5695                     (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
5700     parser->m_processor = contentProcessor;
5702     return doContent(parser, parser->m_parentParser ? 1 : 0, parser->m_encoding,
5704                      (XML_Bool)! parser->m_parsingStatus.finalBuffer,
5710 errorProcessor(XML_Parser parser, const char *s, const char *end,
5715   return parser->m_errorCode;
5719 storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
5723       = appendAttributeValue(parser, enc, isCdata, ptr, end, pool, account);
5734 appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
5737   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
5747     if (! accountingDiffTolerated(parser, tok, ptr, next, __LINE__, account)) {
5748       accountingOnAbort(parser);
5756       if (enc == parser->m_encoding)
5757         parser->m_eventPtr = next;
5760       if (enc == parser->m_encoding)
5761         parser->m_eventPtr = ptr;
5768         if (enc == parser->m_encoding)
5769           parser->m_eventPtr = ptr;
5815         accountingDiffTolerated(parser, tok, (char *)&ch,
5823       name = poolStoreString(&parser->m_temp2Pool, enc,
5828       entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
5829       poolDiscard(&parser->m_temp2Pool);
5836             parser->m_prologState.documentEntity &&
5838             (dtd->standalone ? ! parser->m_openInternalEntities
5840       else /* if (pool == &parser->m_tempPool): we are called from content */
5849            parser->m_skippedEntityHandler.
5850         if (parser->m_skippedEntityHandler)
5851           parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
5855         if ((pool == &parser->m_tempPool) && parser->m_defaultHandler)
5856           reportDefault(parser, enc, ptr, next);
5861         if (enc == parser->m_encoding) {
5869            * sets the local encoding ("enc") to the parser's
5879           parser->m_eventPtr = ptr; /* LCOV_EXCL_LINE */
5884         if (enc == parser->m_encoding)
5885           parser->m_eventPtr = ptr;
5889         if (enc == parser->m_encoding)
5890           parser->m_eventPtr = ptr;
5897         entityTrackingOnOpen(parser, entity, __LINE__);
5899         result = appendAttributeValue(parser, parser->m_internalEncoding,
5904         entityTrackingOnClose(parser, entity, __LINE__);
5923       if (enc == parser->m_encoding)
5924         parser->m_eventPtr = ptr;
5934 storeEntityValue(XML_Parser parser, const ENCODING *enc,
5937   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
5941   int oldInEntityValue = parser->m_prologState.inEntityValue;
5942   parser->m_prologState.inEntityValue = 1;
5960     if (! accountingDiffTolerated(parser, tok, entityTextPtr, next, __LINE__,
5962       accountingOnAbort(parser);
5971       if (parser->m_isParamEntity || enc != parser->m_encoding) {
5974         name = poolStoreString(&parser->m_tempPool, enc,
5981         entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
5982         poolDiscard(&parser->m_tempPool);
5986              parser->m_skippedEntityHandler
5987           if (parser->m_skippedEntityHandler)
5988             parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
5994           if (enc == parser->m_encoding)
5995             parser->m_eventPtr = entityTextPtr;
6000           if (parser->m_externalEntityRefHandler) {
6003             entityTrackingOnOpen(parser, entity, __LINE__);
6004             if (! parser->m_externalEntityRefHandler(
6005                     parser->m_externalEntityRefHandlerArg, 0, entity->base,
6007               entityTrackingOnClose(parser, entity, __LINE__);
6012             entityTrackingOnClose(parser, entity, __LINE__);
6020           entityTrackingOnOpen(parser, entity, __LINE__);
6022               parser, parser->m_internalEncoding, (const char *)entity->textPtr,
6025           entityTrackingOnClose(parser, entity, __LINE__);
6035       parser->m_eventPtr = entityTextPtr;
6063         if (enc == parser->m_encoding)
6064           parser->m_eventPtr = entityTextPtr;
6087       if (enc == parser->m_encoding)
6088         parser->m_eventPtr = entityTextPtr;
6092       if (enc == parser->m_encoding)
6093         parser->m_eventPtr = next;
6104       if (enc == parser->m_encoding)
6105         parser->m_eventPtr = entityTextPtr;
6114   parser->m_prologState.inEntityValue = oldInEntityValue;
6141 reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
6146   if (! parser->m_processingInstructionHandler) {
6147     if (parser->m_defaultHandler)
6148       reportDefault(parser, enc, start, end);
6153   target = poolStoreString(&parser->m_tempPool, enc, start, tem);
6156   poolFinish(&parser->m_tempPool);
6157   data = poolStoreString(&parser->m_tempPool, enc, XmlSkipS(enc, tem),
6162   parser->m_processingInstructionHandler(parser->m_handlerArg, target, data);
6163   poolClear(&parser->m_tempPool);
6168 reportComment(XML_Parser parser, const ENCODING *enc, const char *start,
6171   if (! parser->m_commentHandler) {
6172     if (parser->m_defaultHandler)
6173       reportDefault(parser, enc, start, end);
6176   data = poolStoreString(&parser->m_tempPool, enc,
6182   parser->m_commentHandler(parser->m_handlerArg, data);
6183   poolClear(&parser->m_tempPool);
6188 reportDefault(XML_Parser parser, const ENCODING *enc, const char *s,
6194     if (enc == parser->m_encoding) {
6195       eventPP = &parser->m_eventPtr;
6196       eventEndPP = &parser->m_eventEndPtr;
6198       /* To get here, two things must be true; the parser must be
6203        * in is not the same as the parser's encoding are when it is
6214       eventPP = &(parser->m_openInternalEntities->internalEventPtr);
6215       eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
6219       ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
6221           = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
6223       parser->m_defaultHandler(parser->m_handlerArg, parser->m_dataBuf,
6224                                (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
6229     parser->m_defaultHandler(parser->m_handlerArg, (XML_Char *)s,
6235                 XML_Bool isId, const XML_Char *value, XML_Parser parser) {
6251           parser, type->allocDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
6276       temp = (DEFAULT_ATTRIBUTE *)REALLOC(parser, type->defaultAtts,
6295 setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType) {
6296   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6308       prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
6324 getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,
6326   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6336   id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name,
6344     if (! parser->m_ns)
6353         id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6,
6368           id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes,
6387 getContext(XML_Parser parser) {
6388   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6395     if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
6398     if (parser->m_namespaceSeparator)
6401       if (! poolAppendChar(&parser->m_tempPool,
6407          * URI into the parser's temporary string pool.  Previously,
6445     if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
6448       if (! poolAppendChar(&parser->m_tempPool, *s))
6450     if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
6453     if (parser->m_namespaceSeparator)
6456       if (! poolAppendChar(&parser->m_tempPool, prefix->binding->uri[i]))
6469     if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
6472       if (! poolAppendChar(&parser->m_tempPool, *s))
6477   if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
6479   return parser->m_tempPool.start;
6483 setContext(XML_Parser parser, const XML_Char *context) {
6484   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6490       if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
6492       e = (ENTITY *)lookup(parser, &dtd->generalEntities,
6493                            poolStart(&parser->m_tempPool), 0);
6499       poolDiscard(&parser->m_tempPool);
6502       if (poolLength(&parser->m_tempPool) == 0)
6505         if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
6508             = (PREFIX *)lookup(parser, &dtd->prefixes,
6509                                poolStart(&parser->m_tempPool), sizeof(PREFIX));
6512         if (prefix->name == poolStart(&parser->m_tempPool)) {
6517         poolDiscard(&parser->m_tempPool);
6521         if (! poolAppendChar(&parser->m_tempPool, *context))
6523       if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
6525       if (addBinding(parser, prefix, NULL, poolStart(&parser->m_tempPool),
6526                      &parser->m_inheritedBindings)
6529       poolDiscard(&parser->m_tempPool);
6534       if (! poolAppendChar(&parser->m_tempPool, *s))
6874 copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key) {
6876   key->k[1] = get_hash_secret_salt(parser);
6880 hash(XML_Parser parser, KEY s) {
6884   copy_salt_to_sipkey(parser, &key);
6891 lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize) {
6907     i = hash(parser, name) & ((unsigned long)table->size - 1);
6909     unsigned long h = hash(parser, name);
6947           unsigned long newHash = hash(parser, table->v[i]->name);
7274 nextScaffoldPart(XML_Parser parser) {
7275   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
7280     dtd->scaffIndex = (int *)MALLOC(parser, parser->m_groupSize * sizeof(int));
7304           parser, dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
7309       temp = (CONTENT_SCAFFOLD *)MALLOC(parser, INIT_SCAFFOLD_ELEMENTS
7335 build_model(XML_Parser parser) {
7336   /* Function build_model transforms the existing parser->m_dtd->scaffold
7340   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
7364   ret = (XML_Content *)MALLOC(parser, allocsize);
7462 getElementType(XML_Parser parser, const ENCODING *enc, const char *ptr,
7464   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
7470   ret = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
7478     if (! setElementTypePrefix(parser, ret))
7638 testingAccountingGetCountBytesDirect(XML_Parser parser) {
7639   if (! parser)
7641   return parser->m_accounting.countBytesDirect;
7645 testingAccountingGetCountBytesIndirect(XML_Parser parser) {
7646   if (! parser)
7648   return parser->m_accounting.countBytesIndirect;
7700 getRootParserOf(XML_Parser parser, unsigned int *outLevelDiff) {
7701   XML_Parser rootParser = parser;

Indexes created Fri Jul 05 22:58:02 MDT 2024