--- /dev/null
+/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd\r
+ See the file COPYING for copying permission.\r
+*/\r
+\r
+#define XML_BUILDING_EXPAT 1\r
+\r
+#ifdef COMPILED_FROM_DSP\r
+#include "winconfig.h"\r
+#elif defined(MACOS_CLASSIC)\r
+#include "macconfig.h"\r
+#elif defined(__amigaos4__)\r
+#include "amigaconfig.h"\r
+#elif defined(HAVE_EXPAT_CONFIG_H)\r
+#include <expat_config.h>\r
+#endif /* ndef COMPILED_FROM_DSP */\r
+\r
+#include <stddef.h>\r
+#include <string.h> /* memset(), memcpy() */\r
+#include <assert.h>\r
+\r
+#if defined(UEFI_C_SOURCE)\r
+ #include <expat/expat.h>\r
+#else\r
+ #include "expat.h"\r
+#endif\r
+\r
+#ifdef XML_UNICODE\r
+#define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX\r
+#define XmlConvert XmlUtf16Convert\r
+#define XmlGetInternalEncoding XmlGetUtf16InternalEncoding\r
+#define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS\r
+#define XmlEncode XmlUtf16Encode\r
+#define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((unsigned long)s) & 1))\r
+typedef unsigned short ICHAR;\r
+#else\r
+#define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX\r
+#define XmlConvert XmlUtf8Convert\r
+#define XmlGetInternalEncoding XmlGetUtf8InternalEncoding\r
+#define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS\r
+#define XmlEncode XmlUtf8Encode\r
+#define MUST_CONVERT(enc, s) (!(enc)->isUtf8)\r
+typedef char ICHAR;\r
+#endif\r
+\r
+\r
+#ifndef XML_NS\r
+\r
+#define XmlInitEncodingNS XmlInitEncoding\r
+#define XmlInitUnknownEncodingNS XmlInitUnknownEncoding\r
+#undef XmlGetInternalEncodingNS\r
+#define XmlGetInternalEncodingNS XmlGetInternalEncoding\r
+#define XmlParseXmlDeclNS XmlParseXmlDecl\r
+\r
+#endif\r
+\r
+#ifdef XML_UNICODE\r
+\r
+#ifdef XML_UNICODE_WCHAR_T\r
+#define XML_T(x) (const wchar_t)x\r
+#define XML_L(x) L ## x\r
+#else\r
+#define XML_T(x) (const unsigned short)x\r
+#define XML_L(x) x\r
+#endif\r
+\r
+#else\r
+\r
+#define XML_T(x) x\r
+#define XML_L(x) x\r
+\r
+#endif\r
+\r
+/* Round up n to be a multiple of sz, where sz is a power of 2. */\r
+#define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1))\r
+\r
+/* Handle the case where memmove() doesn't exist. */\r
+#ifndef HAVE_MEMMOVE\r
+#ifdef HAVE_BCOPY\r
+#define memmove(d,s,l) bcopy((s),(d),(l))\r
+#else\r
+#error memmove does not exist on this platform, nor is a substitute available\r
+#endif /* HAVE_BCOPY */\r
+#endif /* HAVE_MEMMOVE */\r
+\r
+#include "internal.h"\r
+#include "xmltok.h"\r
+#include "xmlrole.h"\r
+\r
+typedef const XML_Char *KEY;\r
+\r
+typedef struct {\r
+ KEY name;\r
+} NAMED;\r
+\r
+typedef struct {\r
+ NAMED **v;\r
+ unsigned char power;\r
+ size_t size;\r
+ size_t used;\r
+ const XML_Memory_Handling_Suite *mem;\r
+} HASH_TABLE;\r
+\r
+/* Basic character hash algorithm, taken from Python's string hash:\r
+ h = h * 1000003 ^ character, the constant being a prime number.\r
+\r
+*/\r
+#ifdef XML_UNICODE\r
+#define CHAR_HASH(h, c) \\r
+ (((h) * 0xF4243) ^ (unsigned short)(c))\r
+#else\r
+#define CHAR_HASH(h, c) \\r
+ (((h) * 0xF4243) ^ (unsigned char)(c))\r
+#endif\r
+\r
+/* For probing (after a collision) we need a step size relative prime\r
+ to the hash table size, which is a power of 2. We use double-hashing,\r
+ since we can calculate a second hash value cheaply by taking those bits\r
+ of the first hash value that were discarded (masked out) when the table\r
+ index was calculated: index = hash & mask, where mask = table->size - 1.\r
+ We limit the maximum step size to table->size / 4 (mask >> 2) and make\r
+ it odd, since odd numbers are always relative prime to a power of 2.\r
+*/\r
+#define SECOND_HASH(hash, mask, power) \\r
+ ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2))\r
+#define PROBE_STEP(hash, mask, power) \\r
+ ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))\r
+\r
+typedef struct {\r
+ NAMED **p;\r
+ NAMED **end;\r
+} HASH_TABLE_ITER;\r
+\r
+#define INIT_TAG_BUF_SIZE 32 /* must be a multiple of sizeof(XML_Char) */\r
+#define INIT_DATA_BUF_SIZE 1024\r
+#define INIT_ATTS_SIZE 16\r
+#define INIT_ATTS_VERSION 0xFFFFFFFF\r
+#define INIT_BLOCK_SIZE 1024\r
+#define INIT_BUFFER_SIZE 1024\r
+\r
+#define EXPAND_SPARE 24\r
+\r
+typedef struct binding {\r
+ struct prefix *prefix;\r
+ struct binding *nextTagBinding;\r
+ struct binding *prevPrefixBinding;\r
+ const struct attribute_id *attId;\r
+ XML_Char *uri;\r
+ int uriLen;\r
+ int uriAlloc;\r
+} BINDING;\r
+\r
+typedef struct prefix {\r
+ const XML_Char *name;\r
+ BINDING *binding;\r
+} PREFIX;\r
+\r
+typedef struct {\r
+ const XML_Char *str;\r
+ const XML_Char *localPart;\r
+ const XML_Char *prefix;\r
+ int strLen;\r
+ int uriLen;\r
+ int prefixLen;\r
+} TAG_NAME;\r
+\r
+/* TAG represents an open element.\r
+ The name of the element is stored in both the document and API\r
+ encodings. The memory buffer 'buf' is a separately-allocated\r
+ memory area which stores the name. During the XML_Parse()/\r
+ XMLParseBuffer() when the element is open, the memory for the 'raw'\r
+ version of the name (in the document encoding) is shared with the\r
+ document buffer. If the element is open across calls to\r
+ XML_Parse()/XML_ParseBuffer(), the buffer is re-allocated to\r
+ contain the 'raw' name as well.\r
+\r
+ A parser re-uses these structures, maintaining a list of allocated\r
+ TAG objects in a free list.\r
+*/\r
+typedef struct tag {\r
+ struct tag *parent; /* parent of this element */\r
+ const char *rawName; /* tagName in the original encoding */\r
+ int rawNameLength;\r
+ TAG_NAME name; /* tagName in the API encoding */\r
+ char *buf; /* buffer for name components */\r
+ char *bufEnd; /* end of the buffer */\r
+ BINDING *bindings;\r
+} TAG;\r
+\r
+typedef struct {\r
+ const XML_Char *name;\r
+ const XML_Char *textPtr;\r
+ int textLen; /* length in XML_Chars */\r
+ int processed; /* # of processed bytes - when suspended */\r
+ const XML_Char *systemId;\r
+ const XML_Char *base;\r
+ const XML_Char *publicId;\r
+ const XML_Char *notation;\r
+ XML_Bool open;\r
+ XML_Bool is_param;\r
+ XML_Bool is_internal; /* true if declared in internal subset outside PE */\r
+} ENTITY;\r
+\r
+typedef struct {\r
+ enum XML_Content_Type type;\r
+ enum XML_Content_Quant quant;\r
+ const XML_Char * name;\r
+ int firstchild;\r
+ int lastchild;\r
+ int childcnt;\r
+ int nextsib;\r
+} CONTENT_SCAFFOLD;\r
+\r
+#define INIT_SCAFFOLD_ELEMENTS 32\r
+\r
+typedef struct block {\r
+ struct block *next;\r
+ int size;\r
+ XML_Char s[1];\r
+} BLOCK;\r
+\r
+typedef struct {\r
+ BLOCK *blocks;\r
+ BLOCK *freeBlocks;\r
+ const XML_Char *end;\r
+ XML_Char *ptr;\r
+ XML_Char *start;\r
+ const XML_Memory_Handling_Suite *mem;\r
+} STRING_POOL;\r
+\r
+/* The XML_Char before the name is used to determine whether\r
+ an attribute has been specified. */\r
+typedef struct attribute_id {\r
+ XML_Char *name;\r
+ PREFIX *prefix;\r
+ XML_Bool maybeTokenized;\r
+ XML_Bool xmlns;\r
+} ATTRIBUTE_ID;\r
+\r
+typedef struct {\r
+ const ATTRIBUTE_ID *id;\r
+ XML_Bool isCdata;\r
+ const XML_Char *value;\r
+} DEFAULT_ATTRIBUTE;\r
+\r
+typedef struct {\r
+ unsigned long version;\r
+ unsigned long hash;\r
+ const XML_Char *uriName;\r
+} NS_ATT;\r
+\r
+typedef struct {\r
+ const XML_Char *name;\r
+ PREFIX *prefix;\r
+ const ATTRIBUTE_ID *idAtt;\r
+ int nDefaultAtts;\r
+ int allocDefaultAtts;\r
+ DEFAULT_ATTRIBUTE *defaultAtts;\r
+} ELEMENT_TYPE;\r
+\r
+typedef struct {\r
+ HASH_TABLE generalEntities;\r
+ HASH_TABLE elementTypes;\r
+ HASH_TABLE attributeIds;\r
+ HASH_TABLE prefixes;\r
+ STRING_POOL pool;\r
+ STRING_POOL entityValuePool;\r
+ /* false once a parameter entity reference has been skipped */\r
+ XML_Bool keepProcessing;\r
+ /* true once an internal or external PE reference has been encountered;\r
+ this includes the reference to an external subset */\r
+ XML_Bool hasParamEntityRefs;\r
+ XML_Bool standalone;\r
+#ifdef XML_DTD\r
+ /* indicates if external PE has been read */\r
+ XML_Bool paramEntityRead;\r
+ HASH_TABLE paramEntities;\r
+#endif /* XML_DTD */\r
+ PREFIX defaultPrefix;\r
+ /* === scaffolding for building content model === */\r
+ XML_Bool in_eldecl;\r
+ CONTENT_SCAFFOLD *scaffold;\r
+ unsigned contentStringLen;\r
+ unsigned scaffSize;\r
+ unsigned scaffCount;\r
+ int scaffLevel;\r
+ int *scaffIndex;\r
+} DTD;\r
+\r
+typedef struct open_internal_entity {\r
+ const char *internalEventPtr;\r
+ const char *internalEventEndPtr;\r
+ struct open_internal_entity *next;\r
+ ENTITY *entity;\r
+ int startTagLevel;\r
+ XML_Bool betweenDecl; /* WFC: PE Between Declarations */\r
+} OPEN_INTERNAL_ENTITY;\r
+\r
+typedef enum XML_Error PTRCALL Processor(XML_Parser parser,\r
+ const char *start,\r
+ const char *end,\r
+ const char **endPtr);\r
+\r
+static Processor prologProcessor;\r
+static Processor prologInitProcessor;\r
+static Processor contentProcessor;\r
+static Processor cdataSectionProcessor;\r
+#ifdef XML_DTD\r
+static Processor ignoreSectionProcessor;\r
+static Processor externalParEntProcessor;\r
+static Processor externalParEntInitProcessor;\r
+static Processor entityValueProcessor;\r
+static Processor entityValueInitProcessor;\r
+#endif /* XML_DTD */\r
+static Processor epilogProcessor;\r
+static Processor errorProcessor;\r
+static Processor externalEntityInitProcessor;\r
+static Processor externalEntityInitProcessor2;\r
+static Processor externalEntityInitProcessor3;\r
+static Processor externalEntityContentProcessor;\r
+static Processor internalEntityProcessor;\r
+\r
+static enum XML_Error\r
+handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);\r
+static enum XML_Error\r
+processXmlDecl(XML_Parser parser, int isGeneralTextEntity,\r
+ const char *s, const char *next);\r
+static enum XML_Error\r
+initializeEncoding(XML_Parser parser);\r
+static enum XML_Error\r
+doProlog(XML_Parser parser, const ENCODING *enc, const char *s,\r
+ const char *end, int tok, const char *next, const char **nextPtr,\r
+ XML_Bool haveMore);\r
+static enum XML_Error\r
+processInternalEntity(XML_Parser parser, ENTITY *entity,\r
+ XML_Bool betweenDecl);\r
+static enum XML_Error\r
+doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,\r
+ const char *start, const char *end, const char **endPtr,\r
+ XML_Bool haveMore);\r
+static enum XML_Error\r
+doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr,\r
+ const char *end, const char **nextPtr, XML_Bool haveMore);\r
+#ifdef XML_DTD\r
+static enum XML_Error\r
+doIgnoreSection(XML_Parser parser, const ENCODING *, const char **startPtr,\r
+ const char *end, const char **nextPtr, XML_Bool haveMore);\r
+#endif /* XML_DTD */\r
+\r
+static enum XML_Error\r
+storeAtts(XML_Parser parser, const ENCODING *, const char *s,\r
+ TAG_NAME *tagNamePtr, BINDING **bindingsPtr);\r
+static enum XML_Error\r
+addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,\r
+ const XML_Char *uri, BINDING **bindingsPtr);\r
+static int\r
+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,\r
+ XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser);\r
+static enum XML_Error\r
+storeAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,\r
+ const char *, const char *, STRING_POOL *);\r
+static enum XML_Error\r
+appendAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,\r
+ const char *, const char *, STRING_POOL *);\r
+static ATTRIBUTE_ID *\r
+getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,\r
+ const char *end);\r
+static int\r
+setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);\r
+static enum XML_Error\r
+storeEntityValue(XML_Parser parser, const ENCODING *enc, const char *start,\r
+ const char *end);\r
+static int\r
+reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,\r
+ const char *start, const char *end);\r
+static int\r
+reportComment(XML_Parser parser, const ENCODING *enc, const char *start,\r
+ const char *end);\r
+static void\r
+reportDefault(XML_Parser parser, const ENCODING *enc, const char *start,\r
+ const char *end);\r
+\r
+static const XML_Char * getContext(XML_Parser parser);\r
+static XML_Bool\r
+setContext(XML_Parser parser, const XML_Char *context);\r
+\r
+static void FASTCALL normalizePublicId(XML_Char *s);\r
+\r
+static DTD * dtdCreate(const XML_Memory_Handling_Suite *ms);\r
+/* do not call if parentParser != NULL */\r
+static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms);\r
+static void\r
+dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms);\r
+static int\r
+dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms);\r
+static int\r
+copyEntityTable(HASH_TABLE *, STRING_POOL *, const HASH_TABLE *);\r
+\r
+static NAMED *\r
+lookup(HASH_TABLE *table, KEY name, size_t createSize);\r
+static void FASTCALL\r
+hashTableInit(HASH_TABLE *, const XML_Memory_Handling_Suite *ms);\r
+static void FASTCALL hashTableClear(HASH_TABLE *);\r
+static void FASTCALL hashTableDestroy(HASH_TABLE *);\r
+static void FASTCALL\r
+hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);\r
+static NAMED * FASTCALL hashTableIterNext(HASH_TABLE_ITER *);\r
+\r
+static void FASTCALL\r
+poolInit(STRING_POOL *, const XML_Memory_Handling_Suite *ms);\r
+static void FASTCALL poolClear(STRING_POOL *);\r
+static void FASTCALL poolDestroy(STRING_POOL *);\r
+static XML_Char *\r
+poolAppend(STRING_POOL *pool, const ENCODING *enc,\r
+ const char *ptr, const char *end);\r
+static XML_Char *\r
+poolStoreString(STRING_POOL *pool, const ENCODING *enc,\r
+ const char *ptr, const char *end);\r
+static XML_Bool FASTCALL poolGrow(STRING_POOL *pool);\r
+static const XML_Char * FASTCALL\r
+poolCopyString(STRING_POOL *pool, const XML_Char *s);\r
+static const XML_Char *\r
+poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n);\r
+static const XML_Char * FASTCALL\r
+poolAppendString(STRING_POOL *pool, const XML_Char *s);\r
+\r
+static int FASTCALL nextScaffoldPart(XML_Parser parser);\r
+static XML_Content * build_model(XML_Parser parser);\r
+static ELEMENT_TYPE *\r
+getElementType(XML_Parser parser, const ENCODING *enc,\r
+ const char *ptr, const char *end);\r
+\r
+static XML_Parser\r
+parserCreate(const XML_Char *encodingName,\r
+ const XML_Memory_Handling_Suite *memsuite,\r
+ const XML_Char *nameSep,\r
+ DTD *dtd);\r
+static void\r
+parserInit(XML_Parser parser, const XML_Char *encodingName);\r
+\r
+#define poolStart(pool) ((pool)->start)\r
+#define poolEnd(pool) ((pool)->ptr)\r
+#define poolLength(pool) ((pool)->ptr - (pool)->start)\r
+#define poolChop(pool) ((void)--(pool->ptr))\r
+#define poolLastChar(pool) (((pool)->ptr)[-1])\r
+#define poolDiscard(pool) ((pool)->ptr = (pool)->start)\r
+#define poolFinish(pool) ((pool)->start = (pool)->ptr)\r
+#define poolAppendChar(pool, c) \\r
+ (((pool)->ptr == (pool)->end && !poolGrow(pool)) \\r
+ ? 0 \\r
+ : ((*((pool)->ptr)++ = c), 1))\r
+\r
+struct XML_ParserStruct {\r
+ /* The first member must be userData so that the XML_GetUserData\r
+ macro works. */\r
+ void *m_userData;\r
+ void *m_handlerArg;\r
+ char *m_buffer;\r
+ const XML_Memory_Handling_Suite m_mem;\r
+ /* first character to be parsed */\r
+ const char *m_bufferPtr;\r
+ /* past last character to be parsed */\r
+ char *m_bufferEnd;\r
+ /* allocated end of buffer */\r
+ const char *m_bufferLim;\r
+ XML_Index m_parseEndByteIndex;\r
+ const char *m_parseEndPtr;\r
+ XML_Char *m_dataBuf;\r
+ XML_Char *m_dataBufEnd;\r
+ XML_StartElementHandler m_startElementHandler;\r
+ XML_EndElementHandler m_endElementHandler;\r
+ XML_CharacterDataHandler m_characterDataHandler;\r
+ XML_ProcessingInstructionHandler m_processingInstructionHandler;\r
+ XML_CommentHandler m_commentHandler;\r
+ XML_StartCdataSectionHandler m_startCdataSectionHandler;\r
+ XML_EndCdataSectionHandler m_endCdataSectionHandler;\r
+ XML_DefaultHandler m_defaultHandler;\r
+ XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;\r
+ XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;\r
+ XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;\r
+ XML_NotationDeclHandler m_notationDeclHandler;\r
+ XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;\r
+ XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;\r
+ XML_NotStandaloneHandler m_notStandaloneHandler;\r
+ XML_ExternalEntityRefHandler m_externalEntityRefHandler;\r
+ XML_Parser m_externalEntityRefHandlerArg;\r
+ XML_SkippedEntityHandler m_skippedEntityHandler;\r
+ XML_UnknownEncodingHandler m_unknownEncodingHandler;\r
+ XML_ElementDeclHandler m_elementDeclHandler;\r
+ XML_AttlistDeclHandler m_attlistDeclHandler;\r
+ XML_EntityDeclHandler m_entityDeclHandler;\r
+ XML_XmlDeclHandler m_xmlDeclHandler;\r
+ const ENCODING *m_encoding;\r
+ INIT_ENCODING m_initEncoding;\r
+ const ENCODING *m_internalEncoding;\r
+ const XML_Char *m_protocolEncodingName;\r
+ XML_Bool m_ns;\r
+ XML_Bool m_ns_triplets;\r
+ void *m_unknownEncodingMem;\r
+ void *m_unknownEncodingData;\r
+ void *m_unknownEncodingHandlerData;\r
+ void (XMLCALL *m_unknownEncodingRelease)(void *);\r
+ PROLOG_STATE m_prologState;\r
+ Processor *m_processor;\r
+ enum XML_Error m_errorCode;\r
+ const char *m_eventPtr;\r
+ const char *m_eventEndPtr;\r
+ const char *m_positionPtr;\r
+ OPEN_INTERNAL_ENTITY *m_openInternalEntities;\r
+ OPEN_INTERNAL_ENTITY *m_freeInternalEntities;\r
+ XML_Bool m_defaultExpandInternalEntities;\r
+ int m_tagLevel;\r
+ ENTITY *m_declEntity;\r
+ const XML_Char *m_doctypeName;\r
+ const XML_Char *m_doctypeSysid;\r
+ const XML_Char *m_doctypePubid;\r
+ const XML_Char *m_declAttributeType;\r
+ const XML_Char *m_declNotationName;\r
+ const XML_Char *m_declNotationPublicId;\r
+ ELEMENT_TYPE *m_declElementType;\r
+ ATTRIBUTE_ID *m_declAttributeId;\r
+ XML_Bool m_declAttributeIsCdata;\r
+ XML_Bool m_declAttributeIsId;\r
+ DTD *m_dtd;\r
+ const XML_Char *m_curBase;\r
+ TAG *m_tagStack;\r
+ TAG *m_freeTagList;\r
+ BINDING *m_inheritedBindings;\r
+ BINDING *m_freeBindingList;\r
+ int m_attsSize;\r
+ int m_nSpecifiedAtts;\r
+ int m_idAttIndex;\r
+ ATTRIBUTE *m_atts;\r
+ NS_ATT *m_nsAtts;\r
+ unsigned long m_nsAttsVersion;\r
+ unsigned char m_nsAttsPower;\r
+ POSITION m_position;\r
+ STRING_POOL m_tempPool;\r
+ STRING_POOL m_temp2Pool;\r
+ char *m_groupConnector;\r
+ unsigned int m_groupSize;\r
+ XML_Char m_namespaceSeparator;\r
+ XML_Parser m_parentParser;\r
+ XML_ParsingStatus m_parsingStatus;\r
+#ifdef XML_DTD\r
+ XML_Bool m_isParamEntity;\r
+ XML_Bool m_useForeignDTD;\r
+ enum XML_ParamEntityParsing m_paramEntityParsing;\r
+#endif\r
+};\r
+\r
+#define MALLOC(s) (parser->m_mem.malloc_fcn((s)))\r
+#define REALLOC(p,s) (parser->m_mem.realloc_fcn((p),(s)))\r
+#define FREE(p) (parser->m_mem.free_fcn((p)))\r
+\r
+#define userData (parser->m_userData)\r
+#define handlerArg (parser->m_handlerArg)\r
+#define startElementHandler (parser->m_startElementHandler)\r
+#define endElementHandler (parser->m_endElementHandler)\r
+#define characterDataHandler (parser->m_characterDataHandler)\r
+#define processingInstructionHandler \\r
+ (parser->m_processingInstructionHandler)\r
+#define commentHandler (parser->m_commentHandler)\r
+#define startCdataSectionHandler \\r
+ (parser->m_startCdataSectionHandler)\r
+#define endCdataSectionHandler (parser->m_endCdataSectionHandler)\r
+#define defaultHandler (parser->m_defaultHandler)\r
+#define startDoctypeDeclHandler (parser->m_startDoctypeDeclHandler)\r
+#define endDoctypeDeclHandler (parser->m_endDoctypeDeclHandler)\r
+#define unparsedEntityDeclHandler \\r
+ (parser->m_unparsedEntityDeclHandler)\r
+#define notationDeclHandler (parser->m_notationDeclHandler)\r
+#define startNamespaceDeclHandler \\r
+ (parser->m_startNamespaceDeclHandler)\r
+#define endNamespaceDeclHandler (parser->m_endNamespaceDeclHandler)\r
+#define notStandaloneHandler (parser->m_notStandaloneHandler)\r
+#define externalEntityRefHandler \\r
+ (parser->m_externalEntityRefHandler)\r
+#define externalEntityRefHandlerArg \\r
+ (parser->m_externalEntityRefHandlerArg)\r
+#define internalEntityRefHandler \\r
+ (parser->m_internalEntityRefHandler)\r
+#define skippedEntityHandler (parser->m_skippedEntityHandler)\r
+#define unknownEncodingHandler (parser->m_unknownEncodingHandler)\r
+#define elementDeclHandler (parser->m_elementDeclHandler)\r
+#define attlistDeclHandler (parser->m_attlistDeclHandler)\r
+#define entityDeclHandler (parser->m_entityDeclHandler)\r
+#define xmlDeclHandler (parser->m_xmlDeclHandler)\r
+#define encoding (parser->m_encoding)\r
+#define initEncoding (parser->m_initEncoding)\r
+#define internalEncoding (parser->m_internalEncoding)\r
+#define unknownEncodingMem (parser->m_unknownEncodingMem)\r
+#define unknownEncodingData (parser->m_unknownEncodingData)\r
+#define unknownEncodingHandlerData \\r
+ (parser->m_unknownEncodingHandlerData)\r
+#define unknownEncodingRelease (parser->m_unknownEncodingRelease)\r
+#define protocolEncodingName (parser->m_protocolEncodingName)\r
+#define ns (parser->m_ns)\r
+#define ns_triplets (parser->m_ns_triplets)\r
+#define prologState (parser->m_prologState)\r
+#define processor (parser->m_processor)\r
+#define errorCode (parser->m_errorCode)\r
+#define eventPtr (parser->m_eventPtr)\r
+#define eventEndPtr (parser->m_eventEndPtr)\r
+#define positionPtr (parser->m_positionPtr)\r
+#define position (parser->m_position)\r
+#define openInternalEntities (parser->m_openInternalEntities)\r
+#define freeInternalEntities (parser->m_freeInternalEntities)\r
+#define defaultExpandInternalEntities \\r
+ (parser->m_defaultExpandInternalEntities)\r
+#define tagLevel (parser->m_tagLevel)\r
+#define buffer (parser->m_buffer)\r
+#define bufferPtr (parser->m_bufferPtr)\r
+#define bufferEnd (parser->m_bufferEnd)\r
+#define parseEndByteIndex (parser->m_parseEndByteIndex)\r
+#define parseEndPtr (parser->m_parseEndPtr)\r
+#define bufferLim (parser->m_bufferLim)\r
+#define dataBuf (parser->m_dataBuf)\r
+#define dataBufEnd (parser->m_dataBufEnd)\r
+#define _dtd (parser->m_dtd)\r
+#define curBase (parser->m_curBase)\r
+#define declEntity (parser->m_declEntity)\r
+#define doctypeName (parser->m_doctypeName)\r
+#define doctypeSysid (parser->m_doctypeSysid)\r
+#define doctypePubid (parser->m_doctypePubid)\r
+#define declAttributeType (parser->m_declAttributeType)\r
+#define declNotationName (parser->m_declNotationName)\r
+#define declNotationPublicId (parser->m_declNotationPublicId)\r
+#define declElementType (parser->m_declElementType)\r
+#define declAttributeId (parser->m_declAttributeId)\r
+#define declAttributeIsCdata (parser->m_declAttributeIsCdata)\r
+#define declAttributeIsId (parser->m_declAttributeIsId)\r
+#define freeTagList (parser->m_freeTagList)\r
+#define freeBindingList (parser->m_freeBindingList)\r
+#define inheritedBindings (parser->m_inheritedBindings)\r
+#define tagStack (parser->m_tagStack)\r
+#define atts (parser->m_atts)\r
+#define attsSize (parser->m_attsSize)\r
+#define nSpecifiedAtts (parser->m_nSpecifiedAtts)\r
+#define idAttIndex (parser->m_idAttIndex)\r
+#define nsAtts (parser->m_nsAtts)\r
+#define nsAttsVersion (parser->m_nsAttsVersion)\r
+#define nsAttsPower (parser->m_nsAttsPower)\r
+#define tempPool (parser->m_tempPool)\r
+#define temp2Pool (parser->m_temp2Pool)\r
+#define groupConnector (parser->m_groupConnector)\r
+#define groupSize (parser->m_groupSize)\r
+#define namespaceSeparator (parser->m_namespaceSeparator)\r
+#define parentParser (parser->m_parentParser)\r
+#define ps_parsing (parser->m_parsingStatus.parsing)\r
+#define ps_finalBuffer (parser->m_parsingStatus.finalBuffer)\r
+#ifdef XML_DTD\r
+#define isParamEntity (parser->m_isParamEntity)\r
+#define useForeignDTD (parser->m_useForeignDTD)\r
+#define paramEntityParsing (parser->m_paramEntityParsing)\r
+#endif /* XML_DTD */\r
+\r
+XML_Parser XMLCALL\r
+XML_ParserCreate(const XML_Char *encodingName)\r
+{\r
+ return XML_ParserCreate_MM(encodingName, NULL, NULL);\r
+}\r
+\r
+XML_Parser XMLCALL\r
+XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)\r
+{\r
+ XML_Char tmp[2];\r
+ *tmp = nsSep;\r
+ return XML_ParserCreate_MM(encodingName, NULL, tmp);\r
+}\r
+\r
+static const XML_Char implicitContext[] = {\r
+ 'x', 'm', 'l', '=', 'h', 't', 't', 'p', ':', '/', '/',\r
+ 'w', 'w', 'w', '.', 'w', '3', '.', 'o', 'r', 'g', '/',\r
+ 'X', 'M', 'L', '/', '1', '9', '9', '8', '/',\r
+ 'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', '\0'\r
+};\r
+\r
+XML_Parser XMLCALL\r
+XML_ParserCreate_MM(const XML_Char *encodingName,\r
+ const XML_Memory_Handling_Suite *memsuite,\r
+ const XML_Char *nameSep)\r
+{\r
+ XML_Parser parser = parserCreate(encodingName, memsuite, nameSep, NULL);\r
+ if (parser != NULL && ns) {\r
+ /* implicit context only set for root parser, since child\r
+ parsers (i.e. external entity parsers) will inherit it\r
+ */\r
+ if (!setContext(parser, implicitContext)) {\r
+ XML_ParserFree(parser);\r
+ return NULL;\r
+ }\r
+ }\r
+ return parser;\r
+}\r
+\r
+static XML_Parser\r
+parserCreate(const XML_Char *encodingName,\r
+ const XML_Memory_Handling_Suite *memsuite,\r
+ const XML_Char *nameSep,\r
+ DTD *dtd)\r
+{\r
+ XML_Parser parser;\r
+\r
+ if (memsuite) {\r
+ XML_Memory_Handling_Suite *mtemp;\r
+ parser = (XML_Parser)\r
+ memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));\r
+ if (parser != NULL) {\r
+ mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);\r
+ mtemp->malloc_fcn = memsuite->malloc_fcn;\r
+ mtemp->realloc_fcn = memsuite->realloc_fcn;\r
+ mtemp->free_fcn = memsuite->free_fcn;\r
+ }\r
+ }\r
+ else {\r
+ XML_Memory_Handling_Suite *mtemp;\r
+ parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));\r
+ if (parser != NULL) {\r
+ mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);\r
+ mtemp->malloc_fcn = malloc;\r
+ mtemp->realloc_fcn = realloc;\r
+ mtemp->free_fcn = free;\r
+ }\r
+ }\r
+\r
+ if (!parser)\r
+ return parser;\r
+\r
+ buffer = NULL;\r
+ bufferLim = NULL;\r
+\r
+ attsSize = INIT_ATTS_SIZE;\r
+ atts = (ATTRIBUTE *)MALLOC(attsSize * sizeof(ATTRIBUTE));\r
+ if (atts == NULL) {\r
+ FREE(parser);\r
+ return NULL;\r
+ }\r
+ dataBuf = (XML_Char *)MALLOC(INIT_DATA_BUF_SIZE * sizeof(XML_Char));\r
+ if (dataBuf == NULL) {\r
+ FREE(atts);\r
+ FREE(parser);\r
+ return NULL;\r
+ }\r
+ dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;\r
+\r
+ if (dtd)\r
+ _dtd = dtd;\r
+ else {\r
+ _dtd = dtdCreate(&parser->m_mem);\r
+ if (_dtd == NULL) {\r
+ FREE(dataBuf);\r
+ FREE(atts);\r
+ FREE(parser);\r
+ return NULL;\r
+ }\r
+ }\r
+\r
+ freeBindingList = NULL;\r
+ freeTagList = NULL;\r
+ freeInternalEntities = NULL;\r
+\r
+ groupSize = 0;\r
+ groupConnector = NULL;\r
+\r
+ unknownEncodingHandler = NULL;\r
+ unknownEncodingHandlerData = NULL;\r
+\r
+ namespaceSeparator = '!';\r
+ ns = XML_FALSE;\r
+ ns_triplets = XML_FALSE;\r
+\r
+ nsAtts = NULL;\r
+ nsAttsVersion = 0;\r
+ nsAttsPower = 0;\r
+\r
+ poolInit(&tempPool, &(parser->m_mem));\r
+ poolInit(&temp2Pool, &(parser->m_mem));\r
+ parserInit(parser, encodingName);\r
+\r
+ if (encodingName && !protocolEncodingName) {\r
+ XML_ParserFree(parser);\r
+ return NULL;\r
+ }\r
+\r
+ if (nameSep) {\r
+ ns = XML_TRUE;\r
+ internalEncoding = XmlGetInternalEncodingNS();\r
+ namespaceSeparator = *nameSep;\r
+ }\r
+ else {\r
+ internalEncoding = XmlGetInternalEncoding();\r
+ }\r
+\r
+ return parser;\r
+}\r
+\r
+static void\r
+parserInit(XML_Parser parser, const XML_Char *encodingName)\r
+{\r
+ processor = prologInitProcessor;\r
+ XmlPrologStateInit(&prologState);\r
+ protocolEncodingName = (encodingName != NULL\r
+ ? poolCopyString(&tempPool, encodingName)\r
+ : NULL);\r
+ curBase = NULL;\r
+ XmlInitEncoding(&initEncoding, &encoding, 0);\r
+ userData = NULL;\r
+ handlerArg = NULL;\r
+ startElementHandler = NULL;\r
+ endElementHandler = NULL;\r
+ characterDataHandler = NULL;\r
+ processingInstructionHandler = NULL;\r
+ commentHandler = NULL;\r
+ startCdataSectionHandler = NULL;\r
+ endCdataSectionHandler = NULL;\r
+ defaultHandler = NULL;\r
+ startDoctypeDeclHandler = NULL;\r
+ endDoctypeDeclHandler = NULL;\r
+ unparsedEntityDeclHandler = NULL;\r
+ notationDeclHandler = NULL;\r
+ startNamespaceDeclHandler = NULL;\r
+ endNamespaceDeclHandler = NULL;\r
+ notStandaloneHandler = NULL;\r
+ externalEntityRefHandler = NULL;\r
+ externalEntityRefHandlerArg = parser;\r
+ skippedEntityHandler = NULL;\r
+ elementDeclHandler = NULL;\r
+ attlistDeclHandler = NULL;\r
+ entityDeclHandler = NULL;\r
+ xmlDeclHandler = NULL;\r
+ bufferPtr = buffer;\r
+ bufferEnd = buffer;\r
+ parseEndByteIndex = 0;\r
+ parseEndPtr = NULL;\r
+ declElementType = NULL;\r
+ declAttributeId = NULL;\r
+ declEntity = NULL;\r
+ doctypeName = NULL;\r
+ doctypeSysid = NULL;\r
+ doctypePubid = NULL;\r
+ declAttributeType = NULL;\r
+ declNotationName = NULL;\r
+ declNotationPublicId = NULL;\r
+ declAttributeIsCdata = XML_FALSE;\r
+ declAttributeIsId = XML_FALSE;\r
+ memset(&position, 0, sizeof(POSITION));\r
+ errorCode = XML_ERROR_NONE;\r
+ eventPtr = NULL;\r
+ eventEndPtr = NULL;\r
+ positionPtr = NULL;\r
+ openInternalEntities = NULL;\r
+ defaultExpandInternalEntities = XML_TRUE;\r
+ tagLevel = 0;\r
+ tagStack = NULL;\r
+ inheritedBindings = NULL;\r
+ nSpecifiedAtts = 0;\r
+ unknownEncodingMem = NULL;\r
+ unknownEncodingRelease = NULL;\r
+ unknownEncodingData = NULL;\r
+ parentParser = NULL;\r
+ ps_parsing = XML_INITIALIZED;\r
+#ifdef XML_DTD\r
+ isParamEntity = XML_FALSE;\r
+ useForeignDTD = XML_FALSE;\r
+ paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;\r
+#endif\r
+}\r
+\r
+/* moves list of bindings to freeBindingList */\r
+static void FASTCALL\r
+moveToFreeBindingList(XML_Parser parser, BINDING *bindings)\r
+{\r
+ while (bindings) {\r
+ BINDING *b = bindings;\r
+ bindings = bindings->nextTagBinding;\r
+ b->nextTagBinding = freeBindingList;\r
+ freeBindingList = b;\r
+ }\r
+}\r
+\r
+XML_Bool XMLCALL\r
+XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)\r
+{\r
+ TAG *tStk;\r
+ OPEN_INTERNAL_ENTITY *openEntityList;\r
+ if (parentParser)\r
+ return XML_FALSE;\r
+ /* move tagStack to freeTagList */\r
+ tStk = tagStack;\r
+ while (tStk) {\r
+ TAG *tag = tStk;\r
+ tStk = tStk->parent;\r
+ tag->parent = freeTagList;\r
+ moveToFreeBindingList(parser, tag->bindings);\r
+ tag->bindings = NULL;\r
+ freeTagList = tag;\r
+ }\r
+ /* move openInternalEntities to freeInternalEntities */\r
+ openEntityList = openInternalEntities;\r
+ while (openEntityList) {\r
+ OPEN_INTERNAL_ENTITY *openEntity = openEntityList;\r
+ openEntityList = openEntity->next;\r
+ openEntity->next = freeInternalEntities;\r
+ freeInternalEntities = openEntity;\r
+ }\r
+ moveToFreeBindingList(parser, inheritedBindings);\r
+ FREE(unknownEncodingMem);\r
+ if (unknownEncodingRelease)\r
+ unknownEncodingRelease(unknownEncodingData);\r
+ poolClear(&tempPool);\r
+ poolClear(&temp2Pool);\r
+ parserInit(parser, encodingName);\r
+ dtdReset(_dtd, &parser->m_mem);\r
+ return setContext(parser, implicitContext);\r
+}\r
+\r
+enum XML_Status XMLCALL\r
+XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)\r
+{\r
+ /* Block after XML_Parse()/XML_ParseBuffer() has been called.\r
+ XXX There's no way for the caller to determine which of the\r
+ XXX possible error cases caused the XML_STATUS_ERROR return.\r
+ */\r
+ if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)\r
+ return XML_STATUS_ERROR;\r
+ if (encodingName == NULL)\r
+ protocolEncodingName = NULL;\r
+ else {\r
+ protocolEncodingName = poolCopyString(&tempPool, encodingName);\r
+ if (!protocolEncodingName)\r
+ return XML_STATUS_ERROR;\r
+ }\r
+ return XML_STATUS_OK;\r
+}\r
+\r
+XML_Parser XMLCALL\r
+XML_ExternalEntityParserCreate(XML_Parser oldParser,\r
+ const XML_Char *context,\r
+ const XML_Char *encodingName)\r
+{\r
+ XML_Parser parser = oldParser;\r
+ DTD *newDtd = NULL;\r
+ DTD *oldDtd = _dtd;\r
+ XML_StartElementHandler oldStartElementHandler = startElementHandler;\r
+ XML_EndElementHandler oldEndElementHandler = endElementHandler;\r
+ XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;\r
+ XML_ProcessingInstructionHandler oldProcessingInstructionHandler\r
+ = processingInstructionHandler;\r
+ XML_CommentHandler oldCommentHandler = commentHandler;\r
+ XML_StartCdataSectionHandler oldStartCdataSectionHandler\r
+ = startCdataSectionHandler;\r
+ XML_EndCdataSectionHandler oldEndCdataSectionHandler\r
+ = endCdataSectionHandler;\r
+ XML_DefaultHandler oldDefaultHandler = defaultHandler;\r
+ XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler\r
+ = unparsedEntityDeclHandler;\r
+ XML_NotationDeclHandler oldNotationDeclHandler = notationDeclHandler;\r
+ XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler\r
+ = startNamespaceDeclHandler;\r
+ XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler\r
+ = endNamespaceDeclHandler;\r
+ XML_NotStandaloneHandler oldNotStandaloneHandler = notStandaloneHandler;\r
+ XML_ExternalEntityRefHandler oldExternalEntityRefHandler\r
+ = externalEntityRefHandler;\r
+ XML_SkippedEntityHandler oldSkippedEntityHandler = skippedEntityHandler;\r
+ XML_UnknownEncodingHandler oldUnknownEncodingHandler\r
+ = unknownEncodingHandler;\r
+ XML_ElementDeclHandler oldElementDeclHandler = elementDeclHandler;\r
+ XML_AttlistDeclHandler oldAttlistDeclHandler = attlistDeclHandler;\r
+ XML_EntityDeclHandler oldEntityDeclHandler = entityDeclHandler;\r
+ XML_XmlDeclHandler oldXmlDeclHandler = xmlDeclHandler;\r
+ ELEMENT_TYPE * oldDeclElementType = declElementType;\r
+\r
+ void *oldUserData = userData;\r
+ void *oldHandlerArg = handlerArg;\r
+ XML_Bool oldDefaultExpandInternalEntities = defaultExpandInternalEntities;\r
+ XML_Parser oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;\r
+#ifdef XML_DTD\r
+ enum XML_ParamEntityParsing oldParamEntityParsing = paramEntityParsing;\r
+ int oldInEntityValue = prologState.inEntityValue;\r
+#endif\r
+ XML_Bool oldns_triplets = ns_triplets;\r
+\r
+#ifdef XML_DTD\r
+ if (!context)\r
+ newDtd = oldDtd;\r
+#endif /* XML_DTD */\r
+\r
+ /* Note that the magical uses of the pre-processor to make field\r
+ access look more like C++ require that `parser' be overwritten\r
+ here. This makes this function more painful to follow than it\r
+ would be otherwise.\r
+ */\r
+ if (ns) {\r
+ XML_Char tmp[2];\r
+ *tmp = namespaceSeparator;\r
+ parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);\r
+ }\r
+ else {\r
+ parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);\r
+ }\r
+\r
+ if (!parser)\r
+ return NULL;\r
+\r
+ startElementHandler = oldStartElementHandler;\r
+ endElementHandler = oldEndElementHandler;\r
+ characterDataHandler = oldCharacterDataHandler;\r
+ processingInstructionHandler = oldProcessingInstructionHandler;\r
+ commentHandler = oldCommentHandler;\r
+ startCdataSectionHandler = oldStartCdataSectionHandler;\r
+ endCdataSectionHandler = oldEndCdataSectionHandler;\r
+ defaultHandler = oldDefaultHandler;\r
+ unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;\r
+ notationDeclHandler = oldNotationDeclHandler;\r
+ startNamespaceDeclHandler = oldStartNamespaceDeclHandler;\r
+ endNamespaceDeclHandler = oldEndNamespaceDeclHandler;\r
+ notStandaloneHandler = oldNotStandaloneHandler;\r
+ externalEntityRefHandler = oldExternalEntityRefHandler;\r
+ skippedEntityHandler = oldSkippedEntityHandler;\r
+ unknownEncodingHandler = oldUnknownEncodingHandler;\r
+ elementDeclHandler = oldElementDeclHandler;\r
+ attlistDeclHandler = oldAttlistDeclHandler;\r
+ entityDeclHandler = oldEntityDeclHandler;\r
+ xmlDeclHandler = oldXmlDeclHandler;\r
+ declElementType = oldDeclElementType;\r
+ userData = oldUserData;\r
+ if (oldUserData == oldHandlerArg)\r
+ handlerArg = userData;\r
+ else\r
+ handlerArg = parser;\r
+ if (oldExternalEntityRefHandlerArg != oldParser)\r
+ externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;\r
+ defaultExpandInternalEntities = oldDefaultExpandInternalEntities;\r
+ ns_triplets = oldns_triplets;\r
+ parentParser = oldParser;\r
+#ifdef XML_DTD\r
+ paramEntityParsing = oldParamEntityParsing;\r
+ prologState.inEntityValue = oldInEntityValue;\r
+ if (context) {\r
+#endif /* XML_DTD */\r
+ if (!dtdCopy(_dtd, oldDtd, &parser->m_mem)\r
+ || !setContext(parser, context)) {\r
+ XML_ParserFree(parser);\r
+ return NULL;\r
+ }\r
+ processor = externalEntityInitProcessor;\r
+#ifdef XML_DTD\r
+ }\r
+ else {\r
+ /* The DTD instance referenced by _dtd is shared between the document's\r
+ root parser and external PE parsers, therefore one does not need to\r
+ call setContext. In addition, one also *must* not call setContext,\r
+ because this would overwrite existing prefix->binding pointers in\r
+ _dtd with ones that get destroyed with the external PE parser.\r
+ This would leave those prefixes with dangling pointers.\r
+ */\r
+ isParamEntity = XML_TRUE;\r
+ XmlPrologStateInitExternalEntity(&prologState);\r
+ processor = externalParEntInitProcessor;\r
+ }\r
+#endif /* XML_DTD */\r
+ return parser;\r
+}\r
+\r
+static void FASTCALL\r
+destroyBindings(BINDING *bindings, XML_Parser parser)\r
+{\r
+ for (;;) {\r
+ BINDING *b = bindings;\r
+ if (!b)\r
+ break;\r
+ bindings = b->nextTagBinding;\r
+ FREE(b->uri);\r
+ FREE(b);\r
+ }\r
+}\r
+\r
+void XMLCALL\r
+XML_ParserFree(XML_Parser parser)\r
+{\r
+ TAG *tagList;\r
+ OPEN_INTERNAL_ENTITY *entityList;\r
+ if (parser == NULL)\r
+ return;\r
+ /* free tagStack and freeTagList */\r
+ tagList = tagStack;\r
+ for (;;) {\r
+ TAG *p;\r
+ if (tagList == NULL) {\r
+ if (freeTagList == NULL)\r
+ break;\r
+ tagList = freeTagList;\r
+ freeTagList = NULL;\r
+ }\r
+ p = tagList;\r
+ tagList = tagList->parent;\r
+ FREE(p->buf);\r
+ destroyBindings(p->bindings, parser);\r
+ FREE(p);\r
+ }\r
+ /* free openInternalEntities and freeInternalEntities */\r
+ entityList = openInternalEntities;\r
+ for (;;) {\r
+ OPEN_INTERNAL_ENTITY *openEntity;\r
+ if (entityList == NULL) {\r
+ if (freeInternalEntities == NULL)\r
+ break;\r
+ entityList = freeInternalEntities;\r
+ freeInternalEntities = NULL;\r
+ }\r
+ openEntity = entityList;\r
+ entityList = entityList->next;\r
+ FREE(openEntity);\r
+ }\r
+\r
+ destroyBindings(freeBindingList, parser);\r
+ destroyBindings(inheritedBindings, parser);\r
+ poolDestroy(&tempPool);\r
+ poolDestroy(&temp2Pool);\r
+#ifdef XML_DTD\r
+ /* external parameter entity parsers share the DTD structure\r
+ parser->m_dtd with the root parser, so we must not destroy it\r
+ */\r
+ if (!isParamEntity && _dtd)\r
+#else\r
+ if (_dtd)\r
+#endif /* XML_DTD */\r
+ dtdDestroy(_dtd, (XML_Bool)!parentParser, &parser->m_mem);\r
+ FREE((void *)atts);\r
+ FREE(groupConnector);\r
+ FREE(buffer);\r
+ FREE(dataBuf);\r
+ FREE(nsAtts);\r
+ FREE(unknownEncodingMem);\r
+ if (unknownEncodingRelease)\r
+ unknownEncodingRelease(unknownEncodingData);\r
+ FREE(parser);\r
+}\r
+\r
+void XMLCALL\r
+XML_UseParserAsHandlerArg(XML_Parser parser)\r
+{\r
+ handlerArg = parser;\r
+}\r
+\r
+enum XML_Error XMLCALL\r
+XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD)\r
+{\r
+#ifdef XML_DTD\r
+ /* block after XML_Parse()/XML_ParseBuffer() has been called */\r
+ if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)\r
+ return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;\r
+ useForeignDTD = useDTD;\r
+ return XML_ERROR_NONE;\r
+#else\r
+ return XML_ERROR_FEATURE_REQUIRES_XML_DTD;\r
+#endif\r
+}\r
+\r
+void XMLCALL\r
+XML_SetReturnNSTriplet(XML_Parser parser, int do_nst)\r
+{\r
+ /* block after XML_Parse()/XML_ParseBuffer() has been called */\r
+ if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)\r
+ return;\r
+ ns_triplets = do_nst ? XML_TRUE : XML_FALSE;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetUserData(XML_Parser parser, void *p)\r
+{\r
+ if (handlerArg == userData)\r
+ handlerArg = userData = p;\r
+ else\r
+ userData = p;\r
+}\r
+\r
+enum XML_Status XMLCALL\r
+XML_SetBase(XML_Parser parser, const XML_Char *p)\r
+{\r
+ if (p) {\r
+ p = poolCopyString(&_dtd->pool, p);\r
+ if (!p)\r
+ return XML_STATUS_ERROR;\r
+ curBase = p;\r
+ }\r
+ else\r
+ curBase = NULL;\r
+ return XML_STATUS_OK;\r
+}\r
+\r
+const XML_Char * XMLCALL\r
+XML_GetBase(XML_Parser parser)\r
+{\r
+ return curBase;\r
+}\r
+\r
+int XMLCALL\r
+XML_GetSpecifiedAttributeCount(XML_Parser parser)\r
+{\r
+ return nSpecifiedAtts;\r
+}\r
+\r
+int XMLCALL\r
+XML_GetIdAttributeIndex(XML_Parser parser)\r
+{\r
+ return idAttIndex;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetElementHandler(XML_Parser parser,\r
+ XML_StartElementHandler start,\r
+ XML_EndElementHandler end)\r
+{\r
+ startElementHandler = start;\r
+ endElementHandler = end;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetStartElementHandler(XML_Parser parser,\r
+ XML_StartElementHandler start) {\r
+ startElementHandler = start;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetEndElementHandler(XML_Parser parser,\r
+ XML_EndElementHandler end) {\r
+ endElementHandler = end;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetCharacterDataHandler(XML_Parser parser,\r
+ XML_CharacterDataHandler handler)\r
+{\r
+ characterDataHandler = handler;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetProcessingInstructionHandler(XML_Parser parser,\r
+ XML_ProcessingInstructionHandler handler)\r
+{\r
+ processingInstructionHandler = handler;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetCommentHandler(XML_Parser parser,\r
+ XML_CommentHandler handler)\r
+{\r
+ commentHandler = handler;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetCdataSectionHandler(XML_Parser parser,\r
+ XML_StartCdataSectionHandler start,\r
+ XML_EndCdataSectionHandler end)\r
+{\r
+ startCdataSectionHandler = start;\r
+ endCdataSectionHandler = end;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetStartCdataSectionHandler(XML_Parser parser,\r
+ XML_StartCdataSectionHandler start) {\r
+ startCdataSectionHandler = start;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetEndCdataSectionHandler(XML_Parser parser,\r
+ XML_EndCdataSectionHandler end) {\r
+ endCdataSectionHandler = end;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetDefaultHandler(XML_Parser parser,\r
+ XML_DefaultHandler handler)\r
+{\r
+ defaultHandler = handler;\r
+ defaultExpandInternalEntities = XML_FALSE;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetDefaultHandlerExpand(XML_Parser parser,\r
+ XML_DefaultHandler handler)\r
+{\r
+ defaultHandler = handler;\r
+ defaultExpandInternalEntities = XML_TRUE;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetDoctypeDeclHandler(XML_Parser parser,\r
+ XML_StartDoctypeDeclHandler start,\r
+ XML_EndDoctypeDeclHandler end)\r
+{\r
+ startDoctypeDeclHandler = start;\r
+ endDoctypeDeclHandler = end;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetStartDoctypeDeclHandler(XML_Parser parser,\r
+ XML_StartDoctypeDeclHandler start) {\r
+ startDoctypeDeclHandler = start;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetEndDoctypeDeclHandler(XML_Parser parser,\r
+ XML_EndDoctypeDeclHandler end) {\r
+ endDoctypeDeclHandler = end;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetUnparsedEntityDeclHandler(XML_Parser parser,\r
+ XML_UnparsedEntityDeclHandler handler)\r
+{\r
+ unparsedEntityDeclHandler = handler;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetNotationDeclHandler(XML_Parser parser,\r
+ XML_NotationDeclHandler handler)\r
+{\r
+ notationDeclHandler = handler;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetNamespaceDeclHandler(XML_Parser parser,\r
+ XML_StartNamespaceDeclHandler start,\r
+ XML_EndNamespaceDeclHandler end)\r
+{\r
+ startNamespaceDeclHandler = start;\r
+ endNamespaceDeclHandler = end;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetStartNamespaceDeclHandler(XML_Parser parser,\r
+ XML_StartNamespaceDeclHandler start) {\r
+ startNamespaceDeclHandler = start;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetEndNamespaceDeclHandler(XML_Parser parser,\r
+ XML_EndNamespaceDeclHandler end) {\r
+ endNamespaceDeclHandler = end;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetNotStandaloneHandler(XML_Parser parser,\r
+ XML_NotStandaloneHandler handler)\r
+{\r
+ notStandaloneHandler = handler;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetExternalEntityRefHandler(XML_Parser parser,\r
+ XML_ExternalEntityRefHandler handler)\r
+{\r
+ externalEntityRefHandler = handler;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg)\r
+{\r
+ if (arg)\r
+ externalEntityRefHandlerArg = (XML_Parser)arg;\r
+ else\r
+ externalEntityRefHandlerArg = parser;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetSkippedEntityHandler(XML_Parser parser,\r
+ XML_SkippedEntityHandler handler)\r
+{\r
+ skippedEntityHandler = handler;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetUnknownEncodingHandler(XML_Parser parser,\r
+ XML_UnknownEncodingHandler handler,\r
+ void *data)\r
+{\r
+ unknownEncodingHandler = handler;\r
+ unknownEncodingHandlerData = data;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetElementDeclHandler(XML_Parser parser,\r
+ XML_ElementDeclHandler eldecl)\r
+{\r
+ elementDeclHandler = eldecl;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetAttlistDeclHandler(XML_Parser parser,\r
+ XML_AttlistDeclHandler attdecl)\r
+{\r
+ attlistDeclHandler = attdecl;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetEntityDeclHandler(XML_Parser parser,\r
+ XML_EntityDeclHandler handler)\r
+{\r
+ entityDeclHandler = handler;\r
+}\r
+\r
+void XMLCALL\r
+XML_SetXmlDeclHandler(XML_Parser parser,\r
+ XML_XmlDeclHandler handler) {\r
+ xmlDeclHandler = handler;\r
+}\r
+\r
+int XMLCALL\r
+XML_SetParamEntityParsing(XML_Parser parser,\r
+ enum XML_ParamEntityParsing peParsing)\r
+{\r
+ /* block after XML_Parse()/XML_ParseBuffer() has been called */\r
+ if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)\r
+ return 0;\r
+#ifdef XML_DTD\r
+ paramEntityParsing = peParsing;\r
+ return 1;\r
+#else\r
+ return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;\r
+#endif\r
+}\r
+\r
+enum XML_Status XMLCALL\r
+XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)\r
+{\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ errorCode = XML_ERROR_SUSPENDED;\r
+ return XML_STATUS_ERROR;\r
+ case XML_FINISHED:\r
+ errorCode = XML_ERROR_FINISHED;\r
+ return XML_STATUS_ERROR;\r
+ default:\r
+ ps_parsing = XML_PARSING;\r
+ }\r
+\r
+ if (len == 0) {\r
+ ps_finalBuffer = (XML_Bool)isFinal;\r
+ if (!isFinal)\r
+ return XML_STATUS_OK;\r
+ positionPtr = bufferPtr;\r
+ parseEndPtr = bufferEnd;\r
+\r
+ /* If data are left over from last buffer, and we now know that these\r
+ data are the final chunk of input, then we have to check them again\r
+ to detect errors based on that fact.\r
+ */\r
+ errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);\r
+\r
+ if (errorCode == XML_ERROR_NONE) {\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);\r
+ positionPtr = bufferPtr;\r
+ return XML_STATUS_SUSPENDED;\r
+ case XML_INITIALIZED:\r
+ case XML_PARSING:\r
+ ps_parsing = XML_FINISHED;\r
+ /* fall through */\r
+ default:\r
+ return XML_STATUS_OK;\r
+ }\r
+ }\r
+ eventEndPtr = eventPtr;\r
+ processor = errorProcessor;\r
+ return XML_STATUS_ERROR;\r
+ }\r
+#ifndef XML_CONTEXT_BYTES\r
+ else if (bufferPtr == bufferEnd) {\r
+ const char *end;\r
+ int nLeftOver;\r
+ enum XML_Error result;\r
+ parseEndByteIndex += len;\r
+ positionPtr = s;\r
+ ps_finalBuffer = (XML_Bool)isFinal;\r
+\r
+ errorCode = processor(parser, s, parseEndPtr = s + len, &end);\r
+\r
+ if (errorCode != XML_ERROR_NONE) {\r
+ eventEndPtr = eventPtr;\r
+ processor = errorProcessor;\r
+ return XML_STATUS_ERROR;\r
+ }\r
+ else {\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ result = XML_STATUS_SUSPENDED;\r
+ break;\r
+ case XML_INITIALIZED:\r
+ case XML_PARSING:\r
+ result = XML_STATUS_OK;\r
+ if (isFinal) {\r
+ ps_parsing = XML_FINISHED;\r
+ return result;\r
+ }\r
+ break;\r
+ default:\r
+ /* XML_FINISHED case required by compiler - but not tested - djv */\r
+ return XML_STATUS_OK;\r
+ }\r
+ }\r
+\r
+ XmlUpdatePosition(encoding, positionPtr, end, &position);\r
+ nLeftOver = s + len - end;\r
+ if (nLeftOver) {\r
+ if (buffer == NULL || nLeftOver > bufferLim - buffer) {\r
+ /* FIXME avoid integer overflow */\r
+ char *temp;\r
+ temp = (buffer == NULL\r
+ ? (char *)MALLOC(len * 2)\r
+ : (char *)REALLOC(buffer, len * 2));\r
+ if (temp == NULL) {\r
+ errorCode = XML_ERROR_NO_MEMORY;\r
+ return XML_STATUS_ERROR;\r
+ }\r
+ buffer = temp;\r
+ if (!buffer) {\r
+ errorCode = XML_ERROR_NO_MEMORY;\r
+ eventPtr = eventEndPtr = NULL;\r
+ processor = errorProcessor;\r
+ return XML_STATUS_ERROR;\r
+ }\r
+ bufferLim = buffer + len * 2;\r
+ }\r
+ memcpy(buffer, end, nLeftOver);\r
+ }\r
+ bufferPtr = buffer;\r
+ bufferEnd = buffer + nLeftOver;\r
+ positionPtr = bufferPtr;\r
+ parseEndPtr = bufferEnd;\r
+ eventPtr = bufferPtr;\r
+ eventEndPtr = bufferPtr;\r
+ return result;\r
+ }\r
+#endif /* not defined XML_CONTEXT_BYTES */\r
+ else {\r
+ void *buff = XML_GetBuffer(parser, len);\r
+ if (buff == NULL)\r
+ return XML_STATUS_ERROR;\r
+ else {\r
+ memcpy(buff, s, len);\r
+ return XML_ParseBuffer(parser, len, isFinal);\r
+ }\r
+ }\r
+}\r
+\r
+enum XML_Status XMLCALL\r
+XML_ParseBuffer(XML_Parser parser, int len, int isFinal)\r
+{\r
+ const char *start;\r
+ enum XML_Status result = XML_STATUS_OK;\r
+\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ errorCode = XML_ERROR_SUSPENDED;\r
+ return XML_STATUS_ERROR;\r
+ case XML_FINISHED:\r
+ errorCode = XML_ERROR_FINISHED;\r
+ return XML_STATUS_ERROR;\r
+ default:\r
+ ps_parsing = XML_PARSING;\r
+ }\r
+\r
+ start = bufferPtr;\r
+ positionPtr = start;\r
+ bufferEnd += len;\r
+ parseEndPtr = bufferEnd;\r
+ parseEndByteIndex += len;\r
+ ps_finalBuffer = (XML_Bool)isFinal;\r
+\r
+ errorCode = processor(parser, start, parseEndPtr, &bufferPtr);\r
+\r
+ if (errorCode != XML_ERROR_NONE) {\r
+ eventEndPtr = eventPtr;\r
+ processor = errorProcessor;\r
+ return XML_STATUS_ERROR;\r
+ }\r
+ else {\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ result = XML_STATUS_SUSPENDED;\r
+ break;\r
+ case XML_INITIALIZED:\r
+ case XML_PARSING:\r
+ if (isFinal) {\r
+ ps_parsing = XML_FINISHED;\r
+ return result;\r
+ }\r
+ default: ; /* should not happen */\r
+ }\r
+ }\r
+\r
+ XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);\r
+ positionPtr = bufferPtr;\r
+ return result;\r
+}\r
+\r
+void * XMLCALL\r
+XML_GetBuffer(XML_Parser parser, int len)\r
+{\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ errorCode = XML_ERROR_SUSPENDED;\r
+ return NULL;\r
+ case XML_FINISHED:\r
+ errorCode = XML_ERROR_FINISHED;\r
+ return NULL;\r
+ default: ;\r
+ }\r
+\r
+ if (len > bufferLim - bufferEnd) {\r
+ /* FIXME avoid integer overflow */\r
+ int neededSize = len + (int)(bufferEnd - bufferPtr);\r
+#ifdef XML_CONTEXT_BYTES\r
+ int keep = (int)(bufferPtr - buffer);\r
+\r
+ if (keep > XML_CONTEXT_BYTES)\r
+ keep = XML_CONTEXT_BYTES;\r
+ neededSize += keep;\r
+#endif /* defined XML_CONTEXT_BYTES */\r
+ if (neededSize <= bufferLim - buffer) {\r
+#ifdef XML_CONTEXT_BYTES\r
+ if (keep < bufferPtr - buffer) {\r
+ int offset = (int)(bufferPtr - buffer) - keep;\r
+ memmove(buffer, &buffer[offset], bufferEnd - bufferPtr + keep);\r
+ bufferEnd -= offset;\r
+ bufferPtr -= offset;\r
+ }\r
+#else\r
+ memmove(buffer, bufferPtr, bufferEnd - bufferPtr);\r
+ bufferEnd = buffer + (bufferEnd - bufferPtr);\r
+ bufferPtr = buffer;\r
+#endif /* not defined XML_CONTEXT_BYTES */\r
+ }\r
+ else {\r
+ char *newBuf;\r
+ int bufferSize = (int)(bufferLim - bufferPtr);\r
+ if (bufferSize == 0)\r
+ bufferSize = INIT_BUFFER_SIZE;\r
+ do {\r
+ bufferSize *= 2;\r
+ } while (bufferSize < neededSize);\r
+ newBuf = (char *)MALLOC(bufferSize);\r
+ if (newBuf == 0) {\r
+ errorCode = XML_ERROR_NO_MEMORY;\r
+ return NULL;\r
+ }\r
+ bufferLim = newBuf + bufferSize;\r
+#ifdef XML_CONTEXT_BYTES\r
+ if (bufferPtr) {\r
+ int keep = (int)(bufferPtr - buffer);\r
+ if (keep > XML_CONTEXT_BYTES)\r
+ keep = XML_CONTEXT_BYTES;\r
+ memcpy(newBuf, &bufferPtr[-keep], bufferEnd - bufferPtr + keep);\r
+ FREE(buffer);\r
+ buffer = newBuf;\r
+ bufferEnd = buffer + (bufferEnd - bufferPtr) + keep;\r
+ bufferPtr = buffer + keep;\r
+ }\r
+ else {\r
+ bufferEnd = newBuf + (bufferEnd - bufferPtr);\r
+ bufferPtr = buffer = newBuf;\r
+ }\r
+#else\r
+ if (bufferPtr) {\r
+ memcpy(newBuf, bufferPtr, bufferEnd - bufferPtr);\r
+ FREE(buffer);\r
+ }\r
+ bufferEnd = newBuf + (bufferEnd - bufferPtr);\r
+ bufferPtr = buffer = newBuf;\r
+#endif /* not defined XML_CONTEXT_BYTES */\r
+ }\r
+ }\r
+ return bufferEnd;\r
+}\r
+\r
+enum XML_Status XMLCALL\r
+XML_StopParser(XML_Parser parser, XML_Bool resumable)\r
+{\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ if (resumable) {\r
+ errorCode = XML_ERROR_SUSPENDED;\r
+ return XML_STATUS_ERROR;\r
+ }\r
+ ps_parsing = XML_FINISHED;\r
+ break;\r
+ case XML_FINISHED:\r
+ errorCode = XML_ERROR_FINISHED;\r
+ return XML_STATUS_ERROR;\r
+ default:\r
+ if (resumable) {\r
+#ifdef XML_DTD\r
+ if (isParamEntity) {\r
+ errorCode = XML_ERROR_SUSPEND_PE;\r
+ return XML_STATUS_ERROR;\r
+ }\r
+#endif\r
+ ps_parsing = XML_SUSPENDED;\r
+ }\r
+ else\r
+ ps_parsing = XML_FINISHED;\r
+ }\r
+ return XML_STATUS_OK;\r
+}\r
+\r
+enum XML_Status XMLCALL\r
+XML_ResumeParser(XML_Parser parser)\r
+{\r
+ enum XML_Status result = XML_STATUS_OK;\r
+\r
+ if (ps_parsing != XML_SUSPENDED) {\r
+ errorCode = XML_ERROR_NOT_SUSPENDED;\r
+ return XML_STATUS_ERROR;\r
+ }\r
+ ps_parsing = XML_PARSING;\r
+\r
+ errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);\r
+\r
+ if (errorCode != XML_ERROR_NONE) {\r
+ eventEndPtr = eventPtr;\r
+ processor = errorProcessor;\r
+ return XML_STATUS_ERROR;\r
+ }\r
+ else {\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ result = XML_STATUS_SUSPENDED;\r
+ break;\r
+ case XML_INITIALIZED:\r
+ case XML_PARSING:\r
+ if (ps_finalBuffer) {\r
+ ps_parsing = XML_FINISHED;\r
+ return result;\r
+ }\r
+ default: ;\r
+ }\r
+ }\r
+\r
+ XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);\r
+ positionPtr = bufferPtr;\r
+ return result;\r
+}\r
+\r
+void XMLCALL\r
+XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status)\r
+{\r
+ assert(status != NULL);\r
+ *status = parser->m_parsingStatus;\r
+}\r
+\r
+enum XML_Error XMLCALL\r
+XML_GetErrorCode(XML_Parser parser)\r
+{\r
+ return errorCode;\r
+}\r
+\r
+XML_Index XMLCALL\r
+XML_GetCurrentByteIndex(XML_Parser parser)\r
+{\r
+ if (eventPtr)\r
+ return parseEndByteIndex - (parseEndPtr - eventPtr);\r
+ return -1;\r
+}\r
+\r
+int XMLCALL\r
+XML_GetCurrentByteCount(XML_Parser parser)\r
+{\r
+ if (eventEndPtr && eventPtr)\r
+ return (int)(eventEndPtr - eventPtr);\r
+ return 0;\r
+}\r
+\r
+const char * XMLCALL\r
+XML_GetInputContext(XML_Parser parser, int *offset, int *size)\r
+{\r
+#ifdef XML_CONTEXT_BYTES\r
+ if (eventPtr && buffer) {\r
+ *offset = (int)(eventPtr - buffer);\r
+ *size = (int)(bufferEnd - buffer);\r
+ return buffer;\r
+ }\r
+#endif /* defined XML_CONTEXT_BYTES */\r
+ return (char *) 0;\r
+}\r
+\r
+XML_Size XMLCALL\r
+XML_GetCurrentLineNumber(XML_Parser parser)\r
+{\r
+ if (eventPtr && eventPtr >= positionPtr) {\r
+ XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);\r
+ positionPtr = eventPtr;\r
+ }\r
+ return position.lineNumber + 1;\r
+}\r
+\r
+XML_Size XMLCALL\r
+XML_GetCurrentColumnNumber(XML_Parser parser)\r
+{\r
+ if (eventPtr && eventPtr >= positionPtr) {\r
+ XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);\r
+ positionPtr = eventPtr;\r
+ }\r
+ return position.columnNumber;\r
+}\r
+\r
+void XMLCALL\r
+XML_FreeContentModel(XML_Parser parser, XML_Content *model)\r
+{\r
+ FREE(model);\r
+}\r
+\r
+void * XMLCALL\r
+XML_MemMalloc(XML_Parser parser, size_t size)\r
+{\r
+ return MALLOC(size);\r
+}\r
+\r
+void * XMLCALL\r
+XML_MemRealloc(XML_Parser parser, void *ptr, size_t size)\r
+{\r
+ return REALLOC(ptr, size);\r
+}\r
+\r
+void XMLCALL\r
+XML_MemFree(XML_Parser parser, void *ptr)\r
+{\r
+ FREE(ptr);\r
+}\r
+\r
+void XMLCALL\r
+XML_DefaultCurrent(XML_Parser parser)\r
+{\r
+ if (defaultHandler) {\r
+ if (openInternalEntities)\r
+ reportDefault(parser,\r
+ internalEncoding,\r
+ openInternalEntities->internalEventPtr,\r
+ openInternalEntities->internalEventEndPtr);\r
+ else\r
+ reportDefault(parser, encoding, eventPtr, eventEndPtr);\r
+ }\r
+}\r
+\r
+const XML_LChar * XMLCALL\r
+XML_ErrorString(enum XML_Error code)\r
+{\r
+ static const XML_LChar* const message[] = {\r
+ 0,\r
+ XML_L("out of memory"),\r
+ XML_L("syntax error"),\r
+ XML_L("no element found"),\r
+ XML_L("not well-formed (invalid token)"),\r
+ XML_L("unclosed token"),\r
+ XML_L("partial character"),\r
+ XML_L("mismatched tag"),\r
+ XML_L("duplicate attribute"),\r
+ XML_L("junk after document element"),\r
+ XML_L("illegal parameter entity reference"),\r
+ XML_L("undefined entity"),\r
+ XML_L("recursive entity reference"),\r
+ XML_L("asynchronous entity"),\r
+ XML_L("reference to invalid character number"),\r
+ XML_L("reference to binary entity"),\r
+ XML_L("reference to external entity in attribute"),\r
+ XML_L("XML or text declaration not at start of entity"),\r
+ XML_L("unknown encoding"),\r
+ XML_L("encoding specified in XML declaration is incorrect"),\r
+ XML_L("unclosed CDATA section"),\r
+ XML_L("error in processing external entity reference"),\r
+ XML_L("document is not standalone"),\r
+ XML_L("unexpected parser state - please send a bug report"),\r
+ XML_L("entity declared in parameter entity"),\r
+ XML_L("requested feature requires XML_DTD support in Expat"),\r
+ XML_L("cannot change setting once parsing has begun"),\r
+ XML_L("unbound prefix"),\r
+ XML_L("must not undeclare prefix"),\r
+ XML_L("incomplete markup in parameter entity"),\r
+ XML_L("XML declaration not well-formed"),\r
+ XML_L("text declaration not well-formed"),\r
+ XML_L("illegal character(s) in public id"),\r
+ XML_L("parser suspended"),\r
+ XML_L("parser not suspended"),\r
+ XML_L("parsing aborted"),\r
+ XML_L("parsing finished"),\r
+ XML_L("cannot suspend in external parameter entity"),\r
+ XML_L("reserved prefix (xml) must not be undeclared or bound to another namespace name"),\r
+ XML_L("reserved prefix (xmlns) must not be declared or undeclared"),\r
+ XML_L("prefix must not be bound to one of the reserved namespace names")\r
+ };\r
+ if (code > 0 && code < sizeof(message)/sizeof(message[0]))\r
+ return message[code];\r
+ return NULL;\r
+}\r
+\r
+const XML_LChar * XMLCALL\r
+XML_ExpatVersion(void) {\r
+\r
+ /* V1 is used to string-ize the version number. However, it would\r
+ string-ize the actual version macro *names* unless we get them\r
+ substituted before being passed to V1. CPP is defined to expand\r
+ a macro, then rescan for more expansions. Thus, we use V2 to expand\r
+ the version macros, then CPP will expand the resulting V1() macro\r
+ with the correct numerals. */\r
+ /* ### I'm assuming cpp is portable in this respect... */\r
+\r
+#define V1(a,b,c) XML_L(#a)XML_L(".")XML_L(#b)XML_L(".")XML_L(#c)\r
+#define V2(a,b,c) XML_L("expat_")V1(a,b,c)\r
+\r
+ return V2(XML_MAJOR_VERSION, XML_MINOR_VERSION, XML_MICRO_VERSION);\r
+\r
+#undef V1\r
+#undef V2\r
+}\r
+\r
+XML_Expat_Version XMLCALL\r
+XML_ExpatVersionInfo(void)\r
+{\r
+ XML_Expat_Version version;\r
+\r
+ version.major = XML_MAJOR_VERSION;\r
+ version.minor = XML_MINOR_VERSION;\r
+ version.micro = XML_MICRO_VERSION;\r
+\r
+ return version;\r
+}\r
+\r
+const XML_Feature * XMLCALL\r
+XML_GetFeatureList(void)\r
+{\r
+ static const XML_Feature features[] = {\r
+ {XML_FEATURE_SIZEOF_XML_CHAR, XML_L("sizeof(XML_Char)"),\r
+ sizeof(XML_Char)},\r
+ {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"),\r
+ sizeof(XML_LChar)},\r
+#ifdef XML_UNICODE\r
+ {XML_FEATURE_UNICODE, XML_L("XML_UNICODE"), 0},\r
+#endif\r
+#ifdef XML_UNICODE_WCHAR_T\r
+ {XML_FEATURE_UNICODE_WCHAR_T, XML_L("XML_UNICODE_WCHAR_T"), 0},\r
+#endif\r
+#ifdef XML_DTD\r
+ {XML_FEATURE_DTD, XML_L("XML_DTD"), 0},\r
+#endif\r
+#ifdef XML_CONTEXT_BYTES\r
+ {XML_FEATURE_CONTEXT_BYTES, XML_L("XML_CONTEXT_BYTES"),\r
+ XML_CONTEXT_BYTES},\r
+#endif\r
+#ifdef XML_MIN_SIZE\r
+ {XML_FEATURE_MIN_SIZE, XML_L("XML_MIN_SIZE"), 0},\r
+#endif\r
+#ifdef XML_NS\r
+ {XML_FEATURE_NS, XML_L("XML_NS"), 0},\r
+#endif\r
+ {XML_FEATURE_END, NULL, 0}\r
+ };\r
+\r
+ return features;\r
+}\r
+\r
+/* Initially tag->rawName always points into the parse buffer;\r
+ for those TAG instances opened while the current parse buffer was\r
+ processed, and not yet closed, we need to store tag->rawName in a more\r
+ permanent location, since the parse buffer is about to be discarded.\r
+*/\r
+static XML_Bool\r
+storeRawNames(XML_Parser parser)\r
+{\r
+ TAG *tag = tagStack;\r
+ while (tag) {\r
+ int bufSize;\r
+ int nameLen = sizeof(XML_Char) * (tag->name.strLen + 1);\r
+ char *rawNameBuf = tag->buf + nameLen;\r
+ /* Stop if already stored. Since tagStack is a stack, we can stop\r
+ at the first entry that has already been copied; everything\r
+ below it in the stack is already been accounted for in a\r
+ previous call to this function.\r
+ */\r
+ if (tag->rawName == rawNameBuf)\r
+ break;\r
+ /* For re-use purposes we need to ensure that the\r
+ size of tag->buf is a multiple of sizeof(XML_Char).\r
+ */\r
+ bufSize = nameLen + ROUND_UP(tag->rawNameLength, sizeof(XML_Char));\r
+ if (bufSize > tag->bufEnd - tag->buf) {\r
+ char *temp = (char *)REALLOC(tag->buf, bufSize);\r
+ if (temp == NULL)\r
+ return XML_FALSE;\r
+ /* if tag->name.str points to tag->buf (only when namespace\r
+ processing is off) then we have to update it\r
+ */\r
+ if (tag->name.str == (XML_Char *)tag->buf)\r
+ tag->name.str = (XML_Char *)temp;\r
+ /* if tag->name.localPart is set (when namespace processing is on)\r
+ then update it as well, since it will always point into tag->buf\r
+ */\r
+ if (tag->name.localPart)\r
+ tag->name.localPart = (XML_Char *)temp + (tag->name.localPart -\r
+ (XML_Char *)tag->buf);\r
+ tag->buf = temp;\r
+ tag->bufEnd = temp + bufSize;\r
+ rawNameBuf = temp + nameLen;\r
+ }\r
+ memcpy(rawNameBuf, tag->rawName, tag->rawNameLength);\r
+ tag->rawName = rawNameBuf;\r
+ tag = tag->parent;\r
+ }\r
+ return XML_TRUE;\r
+}\r
+\r
+static enum XML_Error PTRCALL\r
+contentProcessor(XML_Parser parser,\r
+ const char *start,\r
+ const char *end,\r
+ const char **endPtr)\r
+{\r
+ enum XML_Error result = doContent(parser, 0, encoding, start, end,\r
+ endPtr, (XML_Bool)!ps_finalBuffer);\r
+ if (result == XML_ERROR_NONE) {\r
+ if (!storeRawNames(parser))\r
+ return XML_ERROR_NO_MEMORY;\r
+ }\r
+ return result;\r
+}\r
+\r
+static enum XML_Error PTRCALL\r
+externalEntityInitProcessor(XML_Parser parser,\r
+ const char *start,\r
+ const char *end,\r
+ const char **endPtr)\r
+{\r
+ enum XML_Error result = initializeEncoding(parser);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ processor = externalEntityInitProcessor2;\r
+ return externalEntityInitProcessor2(parser, start, end, endPtr);\r
+}\r
+\r
+static enum XML_Error PTRCALL\r
+externalEntityInitProcessor2(XML_Parser parser,\r
+ const char *start,\r
+ const char *end,\r
+ const char **endPtr)\r
+{\r
+ const char *next = start; /* XmlContentTok doesn't always set the last arg */\r
+ int tok = XmlContentTok(encoding, start, end, &next);\r
+ switch (tok) {\r
+ case XML_TOK_BOM:\r
+ /* If we are at the end of the buffer, this would cause the next stage,\r
+ i.e. externalEntityInitProcessor3, to pass control directly to\r
+ doContent (by detecting XML_TOK_NONE) without processing any xml text\r
+ declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.\r
+ */\r
+ if (next == end && !ps_finalBuffer) {\r
+ *endPtr = next;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ start = next;\r
+ break;\r
+ case XML_TOK_PARTIAL:\r
+ if (!ps_finalBuffer) {\r
+ *endPtr = start;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ eventPtr = start;\r
+ return XML_ERROR_UNCLOSED_TOKEN;\r
+ case XML_TOK_PARTIAL_CHAR:\r
+ if (!ps_finalBuffer) {\r
+ *endPtr = start;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ eventPtr = start;\r
+ return XML_ERROR_PARTIAL_CHAR;\r
+ }\r
+ processor = externalEntityInitProcessor3;\r
+ return externalEntityInitProcessor3(parser, start, end, endPtr);\r
+}\r
+\r
+static enum XML_Error PTRCALL\r
+externalEntityInitProcessor3(XML_Parser parser,\r
+ const char *start,\r
+ const char *end,\r
+ const char **endPtr)\r
+{\r
+ int tok;\r
+ const char *next = start; /* XmlContentTok doesn't always set the last arg */\r
+ eventPtr = start;\r
+ tok = XmlContentTok(encoding, start, end, &next);\r
+ eventEndPtr = next;\r
+\r
+ switch (tok) {\r
+ case XML_TOK_XML_DECL:\r
+ {\r
+ enum XML_Error result;\r
+ result = processXmlDecl(parser, 1, start, next);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ *endPtr = next;\r
+ return XML_ERROR_NONE;\r
+ case XML_FINISHED:\r
+ return XML_ERROR_ABORTED;\r
+ default:\r
+ start = next;\r
+ }\r
+ }\r
+ break;\r
+ case XML_TOK_PARTIAL:\r
+ if (!ps_finalBuffer) {\r
+ *endPtr = start;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ return XML_ERROR_UNCLOSED_TOKEN;\r
+ case XML_TOK_PARTIAL_CHAR:\r
+ if (!ps_finalBuffer) {\r
+ *endPtr = start;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ return XML_ERROR_PARTIAL_CHAR;\r
+ }\r
+ processor = externalEntityContentProcessor;\r
+ tagLevel = 1;\r
+ return externalEntityContentProcessor(parser, start, end, endPtr);\r
+}\r
+\r
+static enum XML_Error PTRCALL\r
+externalEntityContentProcessor(XML_Parser parser,\r
+ const char *start,\r
+ const char *end,\r
+ const char **endPtr)\r
+{\r
+ enum XML_Error result = doContent(parser, 1, encoding, start, end,\r
+ endPtr, (XML_Bool)!ps_finalBuffer);\r
+ if (result == XML_ERROR_NONE) {\r
+ if (!storeRawNames(parser))\r
+ return XML_ERROR_NO_MEMORY;\r
+ }\r
+ return result;\r
+}\r
+\r
+static enum XML_Error\r
+doContent(XML_Parser parser,\r
+ int startTagLevel,\r
+ const ENCODING *enc,\r
+ const char *s,\r
+ const char *end,\r
+ const char **nextPtr,\r
+ XML_Bool haveMore)\r
+{\r
+ /* save one level of indirection */\r
+ DTD * const dtd = _dtd;\r
+\r
+ const char **eventPP;\r
+ const char **eventEndPP;\r
+ if (enc == encoding) {\r
+ eventPP = &eventPtr;\r
+ eventEndPP = &eventEndPtr;\r
+ }\r
+ else {\r
+ eventPP = &(openInternalEntities->internalEventPtr);\r
+ eventEndPP = &(openInternalEntities->internalEventEndPtr);\r
+ }\r
+ *eventPP = s;\r
+\r
+ for (;;) {\r
+ const char *next = s; /* XmlContentTok doesn't always set the last arg */\r
+ int tok = XmlContentTok(enc, s, end, &next);\r
+ *eventEndPP = next;\r
+ switch (tok) {\r
+ case XML_TOK_TRAILING_CR:\r
+ if (haveMore) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ *eventEndPP = end;\r
+ if (characterDataHandler) {\r
+ XML_Char c = 0xA;\r
+ characterDataHandler(handlerArg, &c, 1);\r
+ }\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, end);\r
+ /* We are at the end of the final buffer, should we check for\r
+ XML_SUSPENDED, XML_FINISHED?\r
+ */\r
+ if (startTagLevel == 0)\r
+ return XML_ERROR_NO_ELEMENTS;\r
+ if (tagLevel != startTagLevel)\r
+ return XML_ERROR_ASYNC_ENTITY;\r
+ *nextPtr = end;\r
+ return XML_ERROR_NONE;\r
+ case XML_TOK_NONE:\r
+ if (haveMore) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ if (startTagLevel > 0) {\r
+ if (tagLevel != startTagLevel)\r
+ return XML_ERROR_ASYNC_ENTITY;\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ return XML_ERROR_NO_ELEMENTS;\r
+ case XML_TOK_INVALID:\r
+ *eventPP = next;\r
+ return XML_ERROR_INVALID_TOKEN;\r
+ case XML_TOK_PARTIAL:\r
+ if (haveMore) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ return XML_ERROR_UNCLOSED_TOKEN;\r
+ case XML_TOK_PARTIAL_CHAR:\r
+ if (haveMore) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ return XML_ERROR_PARTIAL_CHAR;\r
+ case XML_TOK_ENTITY_REF:\r
+ {\r
+ const XML_Char *name;\r
+ ENTITY *entity;\r
+ XML_Char ch = (XML_Char) XmlPredefinedEntityName(enc,\r
+ s + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar);\r
+ if (ch) {\r
+ if (characterDataHandler)\r
+ characterDataHandler(handlerArg, &ch, 1);\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ break;\r
+ }\r
+ name = poolStoreString(&dtd->pool, enc,\r
+ s + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar);\r
+ if (!name)\r
+ return XML_ERROR_NO_MEMORY;\r
+ entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);\r
+ poolDiscard(&dtd->pool);\r
+ /* First, determine if a check for an existing declaration is needed;\r
+ if yes, check that the entity exists, and that it is internal,\r
+ otherwise call the skipped entity or default handler.\r
+ */\r
+ if (!dtd->hasParamEntityRefs || dtd->standalone) {\r
+ if (!entity)\r
+ return XML_ERROR_UNDEFINED_ENTITY;\r
+ else if (!entity->is_internal)\r
+ return XML_ERROR_ENTITY_DECLARED_IN_PE;\r
+ }\r
+ else if (!entity) {\r
+ if (skippedEntityHandler)\r
+ skippedEntityHandler(handlerArg, name, 0);\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ break;\r
+ }\r
+ if (entity->open)\r
+ return XML_ERROR_RECURSIVE_ENTITY_REF;\r
+ if (entity->notation)\r
+ return XML_ERROR_BINARY_ENTITY_REF;\r
+ if (entity->textPtr) {\r
+ enum XML_Error result;\r
+ if (!defaultExpandInternalEntities) {\r
+ if (skippedEntityHandler)\r
+ skippedEntityHandler(handlerArg, entity->name, 0);\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ break;\r
+ }\r
+ result = processInternalEntity(parser, entity, XML_FALSE);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ }\r
+ else if (externalEntityRefHandler) {\r
+ const XML_Char *context;\r
+ entity->open = XML_TRUE;\r
+ context = getContext(parser);\r
+ entity->open = XML_FALSE;\r
+ if (!context)\r
+ return XML_ERROR_NO_MEMORY;\r
+ if (!externalEntityRefHandler(externalEntityRefHandlerArg,\r
+ context,\r
+ entity->base,\r
+ entity->systemId,\r
+ entity->publicId))\r
+ return XML_ERROR_EXTERNAL_ENTITY_HANDLING;\r
+ poolDiscard(&tempPool);\r
+ }\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ break;\r
+ }\r
+ case XML_TOK_START_TAG_NO_ATTS:\r
+ /* fall through */\r
+ case XML_TOK_START_TAG_WITH_ATTS:\r
+ {\r
+ TAG *tag;\r
+ enum XML_Error result;\r
+ XML_Char *toPtr;\r
+ if (freeTagList) {\r
+ tag = freeTagList;\r
+ freeTagList = freeTagList->parent;\r
+ }\r
+ else {\r
+ tag = (TAG *)MALLOC(sizeof(TAG));\r
+ if (!tag)\r
+ return XML_ERROR_NO_MEMORY;\r
+ tag->buf = (char *)MALLOC(INIT_TAG_BUF_SIZE);\r
+ if (!tag->buf) {\r
+ FREE(tag);\r
+ return XML_ERROR_NO_MEMORY;\r
+ }\r
+ tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;\r
+ }\r
+ tag->bindings = NULL;\r
+ tag->parent = tagStack;\r
+ tagStack = tag;\r
+ tag->name.localPart = NULL;\r
+ tag->name.prefix = NULL;\r
+ tag->rawName = s + enc->minBytesPerChar;\r
+ tag->rawNameLength = XmlNameLength(enc, tag->rawName);\r
+ ++tagLevel;\r
+ {\r
+ const char *rawNameEnd = tag->rawName + tag->rawNameLength;\r
+ const char *fromPtr = tag->rawName;\r
+ toPtr = (XML_Char *)tag->buf;\r
+ for (;;) {\r
+ int bufSize;\r
+ int convLen;\r
+ XmlConvert(enc,\r
+ &fromPtr, rawNameEnd,\r
+ (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);\r
+ convLen = (int)(toPtr - (XML_Char *)tag->buf);\r
+ if (fromPtr == rawNameEnd) {\r
+ tag->name.strLen = convLen;\r
+ break;\r
+ }\r
+ bufSize = (int)(tag->bufEnd - tag->buf) << 1;\r
+ {\r
+ char *temp = (char *)REALLOC(tag->buf, bufSize);\r
+ if (temp == NULL)\r
+ return XML_ERROR_NO_MEMORY;\r
+ tag->buf = temp;\r
+ tag->bufEnd = temp + bufSize;\r
+ toPtr = (XML_Char *)temp + convLen;\r
+ }\r
+ }\r
+ }\r
+ tag->name.str = (XML_Char *)tag->buf;\r
+ *toPtr = XML_T('\0');\r
+ result = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings));\r
+ if (result)\r
+ return result;\r
+ if (startElementHandler)\r
+ startElementHandler(handlerArg, tag->name.str,\r
+ (const XML_Char **)atts);\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ poolClear(&tempPool);\r
+ break;\r
+ }\r
+ case XML_TOK_EMPTY_ELEMENT_NO_ATTS:\r
+ /* fall through */\r
+ case XML_TOK_EMPTY_ELEMENT_WITH_ATTS:\r
+ {\r
+ const char *rawName = s + enc->minBytesPerChar;\r
+ enum XML_Error result;\r
+ BINDING *bindings = NULL;\r
+ XML_Bool noElmHandlers = XML_TRUE;\r
+ TAG_NAME name;\r
+ name.str = poolStoreString(&tempPool, enc, rawName,\r
+ rawName + XmlNameLength(enc, rawName));\r
+ if (!name.str)\r
+ return XML_ERROR_NO_MEMORY;\r
+ poolFinish(&tempPool);\r
+ result = storeAtts(parser, enc, s, &name, &bindings);\r
+ if (result)\r
+ return result;\r
+ poolFinish(&tempPool);\r
+ if (startElementHandler) {\r
+ startElementHandler(handlerArg, name.str, (const XML_Char **)atts);\r
+ noElmHandlers = XML_FALSE;\r
+ }\r
+ if (endElementHandler) {\r
+ if (startElementHandler)\r
+ *eventPP = *eventEndPP;\r
+ endElementHandler(handlerArg, name.str);\r
+ noElmHandlers = XML_FALSE;\r
+ }\r
+ if (noElmHandlers && defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ poolClear(&tempPool);\r
+ while (bindings) {\r
+ BINDING *b = bindings;\r
+ if (endNamespaceDeclHandler)\r
+ endNamespaceDeclHandler(handlerArg, b->prefix->name);\r
+ bindings = bindings->nextTagBinding;\r
+ b->nextTagBinding = freeBindingList;\r
+ freeBindingList = b;\r
+ b->prefix->binding = b->prevPrefixBinding;\r
+ }\r
+ }\r
+ if (tagLevel == 0)\r
+ return epilogProcessor(parser, next, end, nextPtr);\r
+ break;\r
+ case XML_TOK_END_TAG:\r
+ if (tagLevel == startTagLevel)\r
+ return XML_ERROR_ASYNC_ENTITY;\r
+ else {\r
+ int len;\r
+ const char *rawName;\r
+ TAG *tag = tagStack;\r
+ tagStack = tag->parent;\r
+ tag->parent = freeTagList;\r
+ freeTagList = tag;\r
+ rawName = s + enc->minBytesPerChar*2;\r
+ len = XmlNameLength(enc, rawName);\r
+ if (len != tag->rawNameLength\r
+ || memcmp(tag->rawName, rawName, len) != 0) {\r
+ *eventPP = rawName;\r
+ return XML_ERROR_TAG_MISMATCH;\r
+ }\r
+ --tagLevel;\r
+ if (endElementHandler) {\r
+ const XML_Char *localPart;\r
+ const XML_Char *prefix;\r
+ XML_Char *uri;\r
+ localPart = tag->name.localPart;\r
+ if (ns && localPart) {\r
+ /* localPart and prefix may have been overwritten in\r
+ tag->name.str, since this points to the binding->uri\r
+ buffer which gets re-used; so we have to add them again\r
+ */\r
+ uri = (XML_Char *)tag->name.str + tag->name.uriLen;\r
+ /* don't need to check for space - already done in storeAtts() */\r
+ while (*localPart) *uri++ = *localPart++;\r
+ prefix = (XML_Char *)tag->name.prefix;\r
+ if (ns_triplets && prefix) {\r
+ *uri++ = namespaceSeparator;\r
+ while (*prefix) *uri++ = *prefix++;\r
+ }\r
+ *uri = XML_T('\0');\r
+ }\r
+ endElementHandler(handlerArg, tag->name.str);\r
+ }\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ while (tag->bindings) {\r
+ BINDING *b = tag->bindings;\r
+ if (endNamespaceDeclHandler)\r
+ endNamespaceDeclHandler(handlerArg, b->prefix->name);\r
+ tag->bindings = tag->bindings->nextTagBinding;\r
+ b->nextTagBinding = freeBindingList;\r
+ freeBindingList = b;\r
+ b->prefix->binding = b->prevPrefixBinding;\r
+ }\r
+ if (tagLevel == 0)\r
+ return epilogProcessor(parser, next, end, nextPtr);\r
+ }\r
+ break;\r
+ case XML_TOK_CHAR_REF:\r
+ {\r
+ int n = XmlCharRefNumber(enc, s);\r
+ if (n < 0)\r
+ return XML_ERROR_BAD_CHAR_REF;\r
+ if (characterDataHandler) {\r
+ XML_Char buf[XML_ENCODE_MAX];\r
+ characterDataHandler(handlerArg, buf, XmlEncode(n, (ICHAR *)buf));\r
+ }\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ }\r
+ break;\r
+ case XML_TOK_XML_DECL:\r
+ return XML_ERROR_MISPLACED_XML_PI;\r
+ case XML_TOK_DATA_NEWLINE:\r
+ if (characterDataHandler) {\r
+ XML_Char c = 0xA;\r
+ characterDataHandler(handlerArg, &c, 1);\r
+ }\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ break;\r
+ case XML_TOK_CDATA_SECT_OPEN:\r
+ {\r
+ enum XML_Error result;\r
+ if (startCdataSectionHandler)\r
+ startCdataSectionHandler(handlerArg);\r
+#if 0\r
+ /* Suppose you doing a transformation on a document that involves\r
+ changing only the character data. You set up a defaultHandler\r
+ and a characterDataHandler. The defaultHandler simply copies\r
+ characters through. The characterDataHandler does the\r
+ transformation and writes the characters out escaping them as\r
+ necessary. This case will fail to work if we leave out the\r
+ following two lines (because & and < inside CDATA sections will\r
+ be incorrectly escaped).\r
+\r
+ However, now we have a start/endCdataSectionHandler, so it seems\r
+ easier to let the user deal with this.\r
+ */\r
+ else if (characterDataHandler)\r
+ characterDataHandler(handlerArg, dataBuf, 0);\r
+#endif\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ result = doCdataSection(parser, enc, &next, end, nextPtr, haveMore);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ else if (!next) {\r
+ processor = cdataSectionProcessor;\r
+ return result;\r
+ }\r
+ }\r
+ break;\r
+ case XML_TOK_TRAILING_RSQB:\r
+ if (haveMore) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ if (characterDataHandler) {\r
+ if (MUST_CONVERT(enc, s)) {\r
+ ICHAR *dataPtr = (ICHAR *)dataBuf;\r
+ XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);\r
+ characterDataHandler(handlerArg, dataBuf,\r
+ (int)(dataPtr - (ICHAR *)dataBuf));\r
+ }\r
+ else\r
+ characterDataHandler(handlerArg,\r
+ (XML_Char *)s,\r
+ (int)((XML_Char *)end - (XML_Char *)s));\r
+ }\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, end);\r
+ /* We are at the end of the final buffer, should we check for\r
+ XML_SUSPENDED, XML_FINISHED?\r
+ */\r
+ if (startTagLevel == 0) {\r
+ *eventPP = end;\r
+ return XML_ERROR_NO_ELEMENTS;\r
+ }\r
+ if (tagLevel != startTagLevel) {\r
+ *eventPP = end;\r
+ return XML_ERROR_ASYNC_ENTITY;\r
+ }\r
+ *nextPtr = end;\r
+ return XML_ERROR_NONE;\r
+ case XML_TOK_DATA_CHARS:\r
+ if (characterDataHandler) {\r
+ if (MUST_CONVERT(enc, s)) {\r
+ for (;;) {\r
+ ICHAR *dataPtr = (ICHAR *)dataBuf;\r
+ XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);\r
+ *eventEndPP = s;\r
+ characterDataHandler(handlerArg, dataBuf,\r
+ (int)(dataPtr - (ICHAR *)dataBuf));\r
+ if (s == next)\r
+ break;\r
+ *eventPP = s;\r
+ }\r
+ }\r
+ else\r
+ characterDataHandler(handlerArg,\r
+ (XML_Char *)s,\r
+ (int)((XML_Char *)next - (XML_Char *)s));\r
+ }\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ break;\r
+ case XML_TOK_PI:\r
+ if (!reportProcessingInstruction(parser, enc, s, next))\r
+ return XML_ERROR_NO_MEMORY;\r
+ break;\r
+ case XML_TOK_COMMENT:\r
+ if (!reportComment(parser, enc, s, next))\r
+ return XML_ERROR_NO_MEMORY;\r
+ break;\r
+ default:\r
+ if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ break;\r
+ }\r
+ *eventPP = s = next;\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ *nextPtr = next;\r
+ return XML_ERROR_NONE;\r
+ case XML_FINISHED:\r
+ return XML_ERROR_ABORTED;\r
+ default: ;\r
+ }\r
+ }\r
+ /* not reached */\r
+}\r
+\r
+/* Precondition: all arguments must be non-NULL;\r
+ Purpose:\r
+ - normalize attributes\r
+ - check attributes for well-formedness\r
+ - generate namespace aware attribute names (URI, prefix)\r
+ - build list of attributes for startElementHandler\r
+ - default attributes\r
+ - process namespace declarations (check and report them)\r
+ - generate namespace aware element name (URI, prefix)\r
+*/\r
+static enum XML_Error\r
+storeAtts(XML_Parser parser, const ENCODING *enc,\r
+ const char *attStr, TAG_NAME *tagNamePtr,\r
+ BINDING **bindingsPtr)\r
+{\r
+ DTD * const dtd = _dtd; /* save one level of indirection */\r
+ ELEMENT_TYPE *elementType;\r
+ int nDefaultAtts;\r
+ const XML_Char **appAtts; /* the attribute list for the application */\r
+ int attIndex = 0;\r
+ int prefixLen;\r
+ int i;\r
+ int n;\r
+ XML_Char *uri;\r
+ int nPrefixes = 0;\r
+ BINDING *binding;\r
+ const XML_Char *localPart;\r
+\r
+ /* lookup the element type name */\r
+ elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, tagNamePtr->str,0);\r
+ if (!elementType) {\r
+ const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);\r
+ if (!name)\r
+ return XML_ERROR_NO_MEMORY;\r
+ elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, name,\r
+ sizeof(ELEMENT_TYPE));\r
+ if (!elementType)\r
+ return XML_ERROR_NO_MEMORY;\r
+ if (ns && !setElementTypePrefix(parser, elementType))\r
+ return XML_ERROR_NO_MEMORY;\r
+ }\r
+ nDefaultAtts = elementType->nDefaultAtts;\r
+\r
+ /* get the attributes from the tokenizer */\r
+ n = XmlGetAttributes(enc, attStr, attsSize, atts);\r
+ if (n + nDefaultAtts > attsSize) {\r
+ int oldAttsSize = attsSize;\r
+ ATTRIBUTE *temp;\r
+ attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;\r
+ temp = (ATTRIBUTE *)REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));\r
+ if (temp == NULL)\r
+ return XML_ERROR_NO_MEMORY;\r
+ atts = temp;\r
+ if (n > oldAttsSize)\r
+ XmlGetAttributes(enc, attStr, n, atts);\r
+ }\r
+\r
+ appAtts = (const XML_Char **)atts;\r
+ for (i = 0; i < n; i++) {\r
+ /* add the name and value to the attribute list */\r
+ ATTRIBUTE_ID *attId = getAttributeId(parser, enc, atts[i].name,\r
+ atts[i].name\r
+ + XmlNameLength(enc, atts[i].name));\r
+ if (!attId)\r
+ return XML_ERROR_NO_MEMORY;\r
+ /* Detect duplicate attributes by their QNames. This does not work when\r
+ namespace processing is turned on and different prefixes for the same\r
+ namespace are used. For this case we have a check further down.\r
+ */\r
+ if ((attId->name)[-1]) {\r
+ if (enc == encoding)\r
+ eventPtr = atts[i].name;\r
+ return XML_ERROR_DUPLICATE_ATTRIBUTE;\r
+ }\r
+ (attId->name)[-1] = 1;\r
+ appAtts[attIndex++] = attId->name;\r
+ if (!atts[i].normalized) {\r
+ enum XML_Error result;\r
+ XML_Bool isCdata = XML_TRUE;\r
+\r
+ /* figure out whether declared as other than CDATA */\r
+ if (attId->maybeTokenized) {\r
+ int j;\r
+ for (j = 0; j < nDefaultAtts; j++) {\r
+ if (attId == elementType->defaultAtts[j].id) {\r
+ isCdata = elementType->defaultAtts[j].isCdata;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ /* normalize the attribute value */\r
+ result = storeAttributeValue(parser, enc, isCdata,\r
+ atts[i].valuePtr, atts[i].valueEnd,\r
+ &tempPool);\r
+ if (result)\r
+ return result;\r
+ appAtts[attIndex] = poolStart(&tempPool);\r
+ poolFinish(&tempPool);\r
+ }\r
+ else {\r
+ /* the value did not need normalizing */\r
+ appAtts[attIndex] = poolStoreString(&tempPool, enc, atts[i].valuePtr,\r
+ atts[i].valueEnd);\r
+ if (appAtts[attIndex] == 0)\r
+ return XML_ERROR_NO_MEMORY;\r
+ poolFinish(&tempPool);\r
+ }\r
+ /* handle prefixed attribute names */\r
+ if (attId->prefix) {\r
+ if (attId->xmlns) {\r
+ /* deal with namespace declarations here */\r
+ enum XML_Error result = addBinding(parser, attId->prefix, attId,\r
+ appAtts[attIndex], bindingsPtr);\r
+ if (result)\r
+ return result;\r
+ --attIndex;\r
+ }\r
+ else {\r
+ /* deal with other prefixed names later */\r
+ attIndex++;\r
+ nPrefixes++;\r
+ (attId->name)[-1] = 2;\r
+ }\r
+ }\r
+ else\r
+ attIndex++;\r
+ }\r
+\r
+ /* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */\r
+ nSpecifiedAtts = attIndex;\r
+ if (elementType->idAtt && (elementType->idAtt->name)[-1]) {\r
+ for (i = 0; i < attIndex; i += 2)\r
+ if (appAtts[i] == elementType->idAtt->name) {\r
+ idAttIndex = i;\r
+ break;\r
+ }\r
+ }\r
+ else\r
+ idAttIndex = -1;\r
+\r
+ /* do attribute defaulting */\r
+ for (i = 0; i < nDefaultAtts; i++) {\r
+ const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i;\r
+ if (!(da->id->name)[-1] && da->value) {\r
+ if (da->id->prefix) {\r
+ if (da->id->xmlns) {\r
+ enum XML_Error result = addBinding(parser, da->id->prefix, da->id,\r
+ da->value, bindingsPtr);\r
+ if (result)\r
+ return result;\r
+ }\r
+ else {\r
+ (da->id->name)[-1] = 2;\r
+ nPrefixes++;\r
+ appAtts[attIndex++] = da->id->name;\r
+ appAtts[attIndex++] = da->value;\r
+ }\r
+ }\r
+ else {\r
+ (da->id->name)[-1] = 1;\r
+ appAtts[attIndex++] = da->id->name;\r
+ appAtts[attIndex++] = da->value;\r
+ }\r
+ }\r
+ }\r
+ appAtts[attIndex] = 0;\r
+\r
+ /* expand prefixed attribute names, check for duplicates,\r
+ and clear flags that say whether attributes were specified */\r
+ i = 0;\r
+ if (nPrefixes) {\r
+ int j; /* hash table index */\r
+ unsigned long version = nsAttsVersion;\r
+ int nsAttsSize = (int)1 << nsAttsPower;\r
+ /* size of hash table must be at least 2 * (# of prefixed attributes) */\r
+ if ((nPrefixes << 1) >> nsAttsPower) { /* true for nsAttsPower = 0 */\r
+ NS_ATT *temp;\r
+ /* hash table size must also be a power of 2 and >= 8 */\r
+ while (nPrefixes >> nsAttsPower++);\r
+ if (nsAttsPower < 3)\r
+ nsAttsPower = 3;\r
+ nsAttsSize = (int)1 << nsAttsPower;\r
+ temp = (NS_ATT *)REALLOC(nsAtts, nsAttsSize * sizeof(NS_ATT));\r
+ if (!temp)\r
+ return XML_ERROR_NO_MEMORY;\r
+ nsAtts = temp;\r
+ version = 0; /* force re-initialization of nsAtts hash table */\r
+ }\r
+ /* using a version flag saves us from initializing nsAtts every time */\r
+ if (!version) { /* initialize version flags when version wraps around */\r
+ version = INIT_ATTS_VERSION;\r
+ for (j = nsAttsSize; j != 0; )\r
+ nsAtts[--j].version = version;\r
+ }\r
+ nsAttsVersion = --version;\r
+\r
+ /* expand prefixed names and check for duplicates */\r
+ for (; i < attIndex; i += 2) {\r
+ const XML_Char *s = appAtts[i];\r
+ if (s[-1] == 2) { /* prefixed */\r
+ ATTRIBUTE_ID *id;\r
+ const BINDING *b;\r
+ unsigned long uriHash = 0;\r
+ ((XML_Char *)s)[-1] = 0; /* clear flag */\r
+ id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, s, 0);\r
+ if (!id)\r
+ return XML_ERROR_NO_MEMORY;\r
+ b = id->prefix->binding;\r
+ if (!b)\r
+ return XML_ERROR_UNBOUND_PREFIX;\r
+\r
+ /* as we expand the name we also calculate its hash value */\r
+ for (j = 0; j < b->uriLen; j++) {\r
+ const XML_Char c = b->uri[j];\r
+ if (!poolAppendChar(&tempPool, c))\r
+ return XML_ERROR_NO_MEMORY;\r
+ uriHash = CHAR_HASH(uriHash, c);\r
+ }\r
+ while (*s++ != XML_T(':'))\r
+ ;\r
+ do { /* copies null terminator */\r
+ const XML_Char c = *s;\r
+ if (!poolAppendChar(&tempPool, *s))\r
+ return XML_ERROR_NO_MEMORY;\r
+ uriHash = CHAR_HASH(uriHash, c);\r
+ } while (*s++);\r
+\r
+ { /* Check hash table for duplicate of expanded name (uriName).\r
+ Derived from code in lookup(HASH_TABLE *table, ...).\r
+ */\r
+ unsigned char step = 0;\r
+ unsigned long mask = nsAttsSize - 1;\r
+ j = uriHash & mask; /* index into hash table */\r
+ while (nsAtts[j].version == version) {\r
+ /* for speed we compare stored hash values first */\r
+ if (uriHash == nsAtts[j].hash) {\r
+ const XML_Char *s1 = poolStart(&tempPool);\r
+ const XML_Char *s2 = nsAtts[j].uriName;\r
+ /* s1 is null terminated, but not s2 */\r
+ for (; *s1 == *s2 && *s1 != 0; s1++, s2++);\r
+ if (*s1 == 0)\r
+ return XML_ERROR_DUPLICATE_ATTRIBUTE;\r
+ }\r
+ if (!step)\r
+ step = PROBE_STEP(uriHash, mask, nsAttsPower);\r
+ j < step ? (j += nsAttsSize - step) : (j -= step);\r
+ }\r
+ }\r
+\r
+ if (ns_triplets) { /* append namespace separator and prefix */\r
+ tempPool.ptr[-1] = namespaceSeparator;\r
+ s = b->prefix->name;\r
+ do {\r
+ if (!poolAppendChar(&tempPool, *s))\r
+ return XML_ERROR_NO_MEMORY;\r
+ } while (*s++);\r
+ }\r
+\r
+ /* store expanded name in attribute list */\r
+ s = poolStart(&tempPool);\r
+ poolFinish(&tempPool);\r
+ appAtts[i] = s;\r
+\r
+ /* fill empty slot with new version, uriName and hash value */\r
+ nsAtts[j].version = version;\r
+ nsAtts[j].hash = uriHash;\r
+ nsAtts[j].uriName = s;\r
+\r
+ if (!--nPrefixes) {\r
+ i += 2;\r
+ break;\r
+ }\r
+ }\r
+ else /* not prefixed */\r
+ ((XML_Char *)s)[-1] = 0; /* clear flag */\r
+ }\r
+ }\r
+ /* clear flags for the remaining attributes */\r
+ for (; i < attIndex; i += 2)\r
+ ((XML_Char *)(appAtts[i]))[-1] = 0;\r
+ for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)\r
+ binding->attId->name[-1] = 0;\r
+\r
+ if (!ns)\r
+ return XML_ERROR_NONE;\r
+\r
+ /* expand the element type name */\r
+ if (elementType->prefix) {\r
+ binding = elementType->prefix->binding;\r
+ if (!binding)\r
+ return XML_ERROR_UNBOUND_PREFIX;\r
+ localPart = tagNamePtr->str;\r
+ while (*localPart++ != XML_T(':'))\r
+ ;\r
+ }\r
+ else if (dtd->defaultPrefix.binding) {\r
+ binding = dtd->defaultPrefix.binding;\r
+ localPart = tagNamePtr->str;\r
+ }\r
+ else\r
+ return XML_ERROR_NONE;\r
+ prefixLen = 0;\r
+ if (ns_triplets && binding->prefix->name) {\r
+ for (; binding->prefix->name[prefixLen++];)\r
+ ; /* prefixLen includes null terminator */\r
+ }\r
+ tagNamePtr->localPart = localPart;\r
+ tagNamePtr->uriLen = binding->uriLen;\r
+ tagNamePtr->prefix = binding->prefix->name;\r
+ tagNamePtr->prefixLen = prefixLen;\r
+ for (i = 0; localPart[i++];)\r
+ ; /* i includes null terminator */\r
+ n = i + binding->uriLen + prefixLen;\r
+ if (n > binding->uriAlloc) {\r
+ TAG *p;\r
+ uri = (XML_Char *)MALLOC((n + EXPAND_SPARE) * sizeof(XML_Char));\r
+ if (!uri)\r
+ return XML_ERROR_NO_MEMORY;\r
+ binding->uriAlloc = n + EXPAND_SPARE;\r
+ memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));\r
+ for (p = tagStack; p; p = p->parent)\r
+ if (p->name.str == binding->uri)\r
+ p->name.str = uri;\r
+ FREE(binding->uri);\r
+ binding->uri = uri;\r
+ }\r
+ /* if namespaceSeparator != '\0' then uri includes it already */\r
+ uri = binding->uri + binding->uriLen;\r
+ memcpy(uri, localPart, i * sizeof(XML_Char));\r
+ /* we always have a namespace separator between localPart and prefix */\r
+ if (prefixLen) {\r
+ uri += i - 1;\r
+ *uri = namespaceSeparator; /* replace null terminator */\r
+ memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));\r
+ }\r
+ tagNamePtr->str = binding->uri;\r
+ return XML_ERROR_NONE;\r
+}\r
+\r
+/* addBinding() overwrites the value of prefix->binding without checking.\r
+ Therefore one must keep track of the old value outside of addBinding().\r
+*/\r
+static enum XML_Error\r
+addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,\r
+ const XML_Char *uri, BINDING **bindingsPtr)\r
+{\r
+ static const XML_Char xmlNamespace[] = {\r
+ 'h', 't', 't', 'p', ':', '/', '/',\r
+ 'w', 'w', 'w', '.', 'w', '3', '.', 'o', 'r', 'g', '/',\r
+ 'X', 'M', 'L', '/', '1', '9', '9', '8', '/',\r
+ 'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', '\0'\r
+ };\r
+ static const int xmlLen =\r
+ (int)sizeof(xmlNamespace)/sizeof(XML_Char) - 1;\r
+ static const XML_Char xmlnsNamespace[] = {\r
+ 'h', 't', 't', 'p', ':', '/', '/',\r
+ 'w', 'w', 'w', '.', 'w', '3', '.', 'o', 'r', 'g', '/',\r
+ '2', '0', '0', '0', '/', 'x', 'm', 'l', 'n', 's', '/', '\0'\r
+ };\r
+ static const int xmlnsLen =\r
+ (int)sizeof(xmlnsNamespace)/sizeof(XML_Char) - 1;\r
+\r
+ XML_Bool mustBeXML = XML_FALSE;\r
+ XML_Bool isXML = XML_TRUE;\r
+ XML_Bool isXMLNS = XML_TRUE;\r
+\r
+ BINDING *b;\r
+ int len;\r
+\r
+ /* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */\r
+ if (*uri == XML_T('\0') && prefix->name)\r
+ return XML_ERROR_UNDECLARING_PREFIX;\r
+\r
+ if (prefix->name\r
+ && prefix->name[0] == XML_T('x')\r
+ && prefix->name[1] == XML_T('m')\r
+ && prefix->name[2] == XML_T('l')) {\r
+\r
+ /* Not allowed to bind xmlns */\r
+ if (prefix->name[3] == XML_T('n')\r
+ && prefix->name[4] == XML_T('s')\r
+ && prefix->name[5] == XML_T('\0'))\r
+ return XML_ERROR_RESERVED_PREFIX_XMLNS;\r
+\r
+ if (prefix->name[3] == XML_T('\0'))\r
+ mustBeXML = XML_TRUE;\r
+ }\r
+\r
+ for (len = 0; uri[len]; len++) {\r
+ if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))\r
+ isXML = XML_FALSE;\r
+\r
+ if (!mustBeXML && isXMLNS\r
+ && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))\r
+ isXMLNS = XML_FALSE;\r
+ }\r
+ isXML = isXML && len == xmlLen;\r
+ isXMLNS = isXMLNS && len == xmlnsLen;\r
+\r
+ if (mustBeXML != isXML)\r
+ return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML\r
+ : XML_ERROR_RESERVED_NAMESPACE_URI;\r
+\r
+ if (isXMLNS)\r
+ return XML_ERROR_RESERVED_NAMESPACE_URI;\r
+\r
+ if (namespaceSeparator)\r
+ len++;\r
+ if (freeBindingList) {\r
+ b = freeBindingList;\r
+ if (len > b->uriAlloc) {\r
+ XML_Char *temp = (XML_Char *)REALLOC(b->uri,\r
+ sizeof(XML_Char) * (len + EXPAND_SPARE));\r
+ if (temp == NULL)\r
+ return XML_ERROR_NO_MEMORY;\r
+ b->uri = temp;\r
+ b->uriAlloc = len + EXPAND_SPARE;\r
+ }\r
+ freeBindingList = b->nextTagBinding;\r
+ }\r
+ else {\r
+ b = (BINDING *)MALLOC(sizeof(BINDING));\r
+ if (!b)\r
+ return XML_ERROR_NO_MEMORY;\r
+ b->uri = (XML_Char *)MALLOC(sizeof(XML_Char) * (len + EXPAND_SPARE));\r
+ if (!b->uri) {\r
+ FREE(b);\r
+ return XML_ERROR_NO_MEMORY;\r
+ }\r
+ b->uriAlloc = len + EXPAND_SPARE;\r
+ }\r
+ b->uriLen = len;\r
+ memcpy(b->uri, uri, len * sizeof(XML_Char));\r
+ if (namespaceSeparator)\r
+ b->uri[len - 1] = namespaceSeparator;\r
+ b->prefix = prefix;\r
+ b->attId = attId;\r
+ b->prevPrefixBinding = prefix->binding;\r
+ /* NULL binding when default namespace undeclared */\r
+ if (*uri == XML_T('\0') && prefix == &_dtd->defaultPrefix)\r
+ prefix->binding = NULL;\r
+ else\r
+ prefix->binding = b;\r
+ b->nextTagBinding = *bindingsPtr;\r
+ *bindingsPtr = b;\r
+ /* if attId == NULL then we are not starting a namespace scope */\r
+ if (attId && startNamespaceDeclHandler)\r
+ startNamespaceDeclHandler(handlerArg, prefix->name,\r
+ prefix->binding ? uri : 0);\r
+ return XML_ERROR_NONE;\r
+}\r
+\r
+/* The idea here is to avoid using stack for each CDATA section when\r
+ the whole file is parsed with one call.\r
+*/\r
+static enum XML_Error PTRCALL\r
+cdataSectionProcessor(XML_Parser parser,\r
+ const char *start,\r
+ const char *end,\r
+ const char **endPtr)\r
+{\r
+ enum XML_Error result = doCdataSection(parser, encoding, &start, end,\r
+ endPtr, (XML_Bool)!ps_finalBuffer);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ if (start) {\r
+ if (parentParser) { /* we are parsing an external entity */\r
+ processor = externalEntityContentProcessor;\r
+ return externalEntityContentProcessor(parser, start, end, endPtr);\r
+ }\r
+ else {\r
+ processor = contentProcessor;\r
+ return contentProcessor(parser, start, end, endPtr);\r
+ }\r
+ }\r
+ return result;\r
+}\r
+\r
+/* startPtr gets set to non-null if the section is closed, and to null if\r
+ the section is not yet closed.\r
+*/\r
+static enum XML_Error\r
+doCdataSection(XML_Parser parser,\r
+ const ENCODING *enc,\r
+ const char **startPtr,\r
+ const char *end,\r
+ const char **nextPtr,\r
+ XML_Bool haveMore)\r
+{\r
+ const char *s = *startPtr;\r
+ const char **eventPP;\r
+ const char **eventEndPP;\r
+ if (enc == encoding) {\r
+ eventPP = &eventPtr;\r
+ *eventPP = s;\r
+ eventEndPP = &eventEndPtr;\r
+ }\r
+ else {\r
+ eventPP = &(openInternalEntities->internalEventPtr);\r
+ eventEndPP = &(openInternalEntities->internalEventEndPtr);\r
+ }\r
+ *eventPP = s;\r
+ *startPtr = NULL;\r
+\r
+ for (;;) {\r
+ const char *next;\r
+ int tok = XmlCdataSectionTok(enc, s, end, &next);\r
+ *eventEndPP = next;\r
+ switch (tok) {\r
+ case XML_TOK_CDATA_SECT_CLOSE:\r
+ if (endCdataSectionHandler)\r
+ endCdataSectionHandler(handlerArg);\r
+#if 0\r
+ /* see comment under XML_TOK_CDATA_SECT_OPEN */\r
+ else if (characterDataHandler)\r
+ characterDataHandler(handlerArg, dataBuf, 0);\r
+#endif\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ *startPtr = next;\r
+ *nextPtr = next;\r
+ if (ps_parsing == XML_FINISHED)\r
+ return XML_ERROR_ABORTED;\r
+ else\r
+ return XML_ERROR_NONE;\r
+ case XML_TOK_DATA_NEWLINE:\r
+ if (characterDataHandler) {\r
+ XML_Char c = 0xA;\r
+ characterDataHandler(handlerArg, &c, 1);\r
+ }\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ break;\r
+ case XML_TOK_DATA_CHARS:\r
+ if (characterDataHandler) {\r
+ if (MUST_CONVERT(enc, s)) {\r
+ for (;;) {\r
+ ICHAR *dataPtr = (ICHAR *)dataBuf;\r
+ XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);\r
+ *eventEndPP = next;\r
+ characterDataHandler(handlerArg, dataBuf,\r
+ (int)(dataPtr - (ICHAR *)dataBuf));\r
+ if (s == next)\r
+ break;\r
+ *eventPP = s;\r
+ }\r
+ }\r
+ else\r
+ characterDataHandler(handlerArg,\r
+ (XML_Char *)s,\r
+ (int)((XML_Char *)next - (XML_Char *)s));\r
+ }\r
+ else if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ break;\r
+ case XML_TOK_INVALID:\r
+ *eventPP = next;\r
+ return XML_ERROR_INVALID_TOKEN;\r
+ case XML_TOK_PARTIAL_CHAR:\r
+ if (haveMore) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ return XML_ERROR_PARTIAL_CHAR;\r
+ case XML_TOK_PARTIAL:\r
+ case XML_TOK_NONE:\r
+ if (haveMore) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ return XML_ERROR_UNCLOSED_CDATA_SECTION;\r
+ default:\r
+ *eventPP = next;\r
+ return XML_ERROR_UNEXPECTED_STATE;\r
+ }\r
+\r
+ *eventPP = s = next;\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ *nextPtr = next;\r
+ return XML_ERROR_NONE;\r
+ case XML_FINISHED:\r
+ return XML_ERROR_ABORTED;\r
+ default: ;\r
+ }\r
+ }\r
+ /* not reached */\r
+}\r
+\r
+#ifdef XML_DTD\r
+\r
+/* The idea here is to avoid using stack for each IGNORE section when\r
+ the whole file is parsed with one call.\r
+*/\r
+static enum XML_Error PTRCALL\r
+ignoreSectionProcessor(XML_Parser parser,\r
+ const char *start,\r
+ const char *end,\r
+ const char **endPtr)\r
+{\r
+ enum XML_Error result = doIgnoreSection(parser, encoding, &start, end,\r
+ endPtr, (XML_Bool)!ps_finalBuffer);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ if (start) {\r
+ processor = prologProcessor;\r
+ return prologProcessor(parser, start, end, endPtr);\r
+ }\r
+ return result;\r
+}\r
+\r
+/* startPtr gets set to non-null is the section is closed, and to null\r
+ if the section is not yet closed.\r
+*/\r
+static enum XML_Error\r
+doIgnoreSection(XML_Parser parser,\r
+ const ENCODING *enc,\r
+ const char **startPtr,\r
+ const char *end,\r
+ const char **nextPtr,\r
+ XML_Bool haveMore)\r
+{\r
+ const char *next;\r
+ int tok;\r
+ const char *s = *startPtr;\r
+ const char **eventPP;\r
+ const char **eventEndPP;\r
+ if (enc == encoding) {\r
+ eventPP = &eventPtr;\r
+ *eventPP = s;\r
+ eventEndPP = &eventEndPtr;\r
+ }\r
+ else {\r
+ eventPP = &(openInternalEntities->internalEventPtr);\r
+ eventEndPP = &(openInternalEntities->internalEventEndPtr);\r
+ }\r
+ *eventPP = s;\r
+ *startPtr = NULL;\r
+ tok = XmlIgnoreSectionTok(enc, s, end, &next);\r
+ *eventEndPP = next;\r
+ switch (tok) {\r
+ case XML_TOK_IGNORE_SECT:\r
+ if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ *startPtr = next;\r
+ *nextPtr = next;\r
+ if (ps_parsing == XML_FINISHED)\r
+ return XML_ERROR_ABORTED;\r
+ else\r
+ return XML_ERROR_NONE;\r
+ case XML_TOK_INVALID:\r
+ *eventPP = next;\r
+ return XML_ERROR_INVALID_TOKEN;\r
+ case XML_TOK_PARTIAL_CHAR:\r
+ if (haveMore) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ return XML_ERROR_PARTIAL_CHAR;\r
+ case XML_TOK_PARTIAL:\r
+ case XML_TOK_NONE:\r
+ if (haveMore) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */\r
+ default:\r
+ *eventPP = next;\r
+ return XML_ERROR_UNEXPECTED_STATE;\r
+ }\r
+ /* not reached */\r
+}\r
+\r
+#endif /* XML_DTD */\r
+\r
+static enum XML_Error\r
+initializeEncoding(XML_Parser parser)\r
+{\r
+ const char *s;\r
+#ifdef XML_UNICODE\r
+ char encodingBuf[128];\r
+ if (!protocolEncodingName)\r
+ s = NULL;\r
+ else {\r
+ int i;\r
+ for (i = 0; protocolEncodingName[i]; i++) {\r
+ if (i == sizeof(encodingBuf) - 1\r
+ || (protocolEncodingName[i] & ~0x7f) != 0) {\r
+ encodingBuf[0] = '\0';\r
+ break;\r
+ }\r
+ encodingBuf[i] = (char)protocolEncodingName[i];\r
+ }\r
+ encodingBuf[i] = '\0';\r
+ s = encodingBuf;\r
+ }\r
+#else\r
+ s = protocolEncodingName;\r
+#endif\r
+ if ((ns ? XmlInitEncodingNS : XmlInitEncoding)(&initEncoding, &encoding, s))\r
+ return XML_ERROR_NONE;\r
+ return handleUnknownEncoding(parser, protocolEncodingName);\r
+}\r
+\r
+static enum XML_Error\r
+processXmlDecl(XML_Parser parser, int isGeneralTextEntity,\r
+ const char *s, const char *next)\r
+{\r
+ const char *encodingName = NULL;\r
+ const XML_Char *storedEncName = NULL;\r
+ const ENCODING *newEncoding = NULL;\r
+ const char *version = NULL;\r
+ const char *versionend;\r
+ const XML_Char *storedversion = NULL;\r
+ int standalone = -1;\r
+ if (!(ns\r
+ ? XmlParseXmlDeclNS\r
+ : XmlParseXmlDecl)(isGeneralTextEntity,\r
+ encoding,\r
+ s,\r
+ next,\r
+ &eventPtr,\r
+ &version,\r
+ &versionend,\r
+ &encodingName,\r
+ &newEncoding,\r
+ &standalone)) {\r
+ if (isGeneralTextEntity)\r
+ return XML_ERROR_TEXT_DECL;\r
+ else\r
+ return XML_ERROR_XML_DECL;\r
+ }\r
+ if (!isGeneralTextEntity && standalone == 1) {\r
+ _dtd->standalone = XML_TRUE;\r
+#ifdef XML_DTD\r
+ if (paramEntityParsing == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)\r
+ paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;\r
+#endif /* XML_DTD */\r
+ }\r
+ if (xmlDeclHandler) {\r
+ if (encodingName != NULL) {\r
+ storedEncName = poolStoreString(&temp2Pool,\r
+ encoding,\r
+ encodingName,\r
+ encodingName\r
+ + XmlNameLength(encoding, encodingName));\r
+ if (!storedEncName)\r
+ return XML_ERROR_NO_MEMORY;\r
+ poolFinish(&temp2Pool);\r
+ }\r
+ if (version) {\r
+ storedversion = poolStoreString(&temp2Pool,\r
+ encoding,\r
+ version,\r
+ versionend - encoding->minBytesPerChar);\r
+ if (!storedversion)\r
+ return XML_ERROR_NO_MEMORY;\r
+ }\r
+ xmlDeclHandler(handlerArg, storedversion, storedEncName, standalone);\r
+ }\r
+ else if (defaultHandler)\r
+ reportDefault(parser, encoding, s, next);\r
+ if (protocolEncodingName == NULL) {\r
+ if (newEncoding) {\r
+ if (newEncoding->minBytesPerChar != encoding->minBytesPerChar) {\r
+ eventPtr = encodingName;\r
+ return XML_ERROR_INCORRECT_ENCODING;\r
+ }\r
+ encoding = newEncoding;\r
+ }\r
+ else if (encodingName) {\r
+ enum XML_Error result;\r
+ if (!storedEncName) {\r
+ storedEncName = poolStoreString(\r
+ &temp2Pool, encoding, encodingName,\r
+ encodingName + XmlNameLength(encoding, encodingName));\r
+ if (!storedEncName)\r
+ return XML_ERROR_NO_MEMORY;\r
+ }\r
+ result = handleUnknownEncoding(parser, storedEncName);\r
+ poolClear(&temp2Pool);\r
+ if (result == XML_ERROR_UNKNOWN_ENCODING)\r
+ eventPtr = encodingName;\r
+ return result;\r
+ }\r
+ }\r
+\r
+ if (storedEncName || storedversion)\r
+ poolClear(&temp2Pool);\r
+\r
+ return XML_ERROR_NONE;\r
+}\r
+\r
+static enum XML_Error\r
+handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName)\r
+{\r
+ if (unknownEncodingHandler) {\r
+ XML_Encoding info;\r
+ int i;\r
+ for (i = 0; i < 256; i++)\r
+ info.map[i] = -1;\r
+ info.convert = NULL;\r
+ info.data = NULL;\r
+ info.release = NULL;\r
+ if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName,\r
+ &info)) {\r
+ ENCODING *enc;\r
+ unknownEncodingMem = MALLOC(XmlSizeOfUnknownEncoding());\r
+ if (!unknownEncodingMem) {\r
+ if (info.release)\r
+ info.release(info.data);\r
+ return XML_ERROR_NO_MEMORY;\r
+ }\r
+ enc = (ns\r
+ ? XmlInitUnknownEncodingNS\r
+ : XmlInitUnknownEncoding)(unknownEncodingMem,\r
+ info.map,\r
+ info.convert,\r
+ info.data);\r
+ if (enc) {\r
+ unknownEncodingData = info.data;\r
+ unknownEncodingRelease = info.release;\r
+ encoding = enc;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ }\r
+ if (info.release != NULL)\r
+ info.release(info.data);\r
+ }\r
+ return XML_ERROR_UNKNOWN_ENCODING;\r
+}\r
+\r
+static enum XML_Error PTRCALL\r
+prologInitProcessor(XML_Parser parser,\r
+ const char *s,\r
+ const char *end,\r
+ const char **nextPtr)\r
+{\r
+ enum XML_Error result = initializeEncoding(parser);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ processor = prologProcessor;\r
+ return prologProcessor(parser, s, end, nextPtr);\r
+}\r
+\r
+#ifdef XML_DTD\r
+\r
+static enum XML_Error PTRCALL\r
+externalParEntInitProcessor(XML_Parser parser,\r
+ const char *s,\r
+ const char *end,\r
+ const char **nextPtr)\r
+{\r
+ enum XML_Error result = initializeEncoding(parser);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+\r
+ /* we know now that XML_Parse(Buffer) has been called,\r
+ so we consider the external parameter entity read */\r
+ _dtd->paramEntityRead = XML_TRUE;\r
+\r
+ if (prologState.inEntityValue) {\r
+ processor = entityValueInitProcessor;\r
+ return entityValueInitProcessor(parser, s, end, nextPtr);\r
+ }\r
+ else {\r
+ processor = externalParEntProcessor;\r
+ return externalParEntProcessor(parser, s, end, nextPtr);\r
+ }\r
+}\r
+\r
+static enum XML_Error PTRCALL\r
+entityValueInitProcessor(XML_Parser parser,\r
+ const char *s,\r
+ const char *end,\r
+ const char **nextPtr)\r
+{\r
+ int tok;\r
+ const char *start = s;\r
+ const char *next = start;\r
+ eventPtr = start;\r
+\r
+ for (;;) {\r
+ tok = XmlPrologTok(encoding, start, end, &next);\r
+ eventEndPtr = next;\r
+ if (tok <= 0) {\r
+ if (!ps_finalBuffer && tok != XML_TOK_INVALID) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ switch (tok) {\r
+ case XML_TOK_INVALID:\r
+ return XML_ERROR_INVALID_TOKEN;\r
+ case XML_TOK_PARTIAL:\r
+ return XML_ERROR_UNCLOSED_TOKEN;\r
+ case XML_TOK_PARTIAL_CHAR:\r
+ return XML_ERROR_PARTIAL_CHAR;\r
+ case XML_TOK_NONE: /* start == end */\r
+ default:\r
+ break;\r
+ }\r
+ /* found end of entity value - can store it now */\r
+ return storeEntityValue(parser, encoding, s, end);\r
+ }\r
+ else if (tok == XML_TOK_XML_DECL) {\r
+ enum XML_Error result;\r
+ result = processXmlDecl(parser, 0, start, next);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ *nextPtr = next;\r
+ return XML_ERROR_NONE;\r
+ case XML_FINISHED:\r
+ return XML_ERROR_ABORTED;\r
+ default:\r
+ *nextPtr = next;\r
+ }\r
+ /* stop scanning for text declaration - we found one */\r
+ processor = entityValueProcessor;\r
+ return entityValueProcessor(parser, next, end, nextPtr);\r
+ }\r
+ /* If we are at the end of the buffer, this would cause XmlPrologTok to\r
+ return XML_TOK_NONE on the next call, which would then cause the\r
+ function to exit with *nextPtr set to s - that is what we want for other\r
+ tokens, but not for the BOM - we would rather like to skip it;\r
+ then, when this routine is entered the next time, XmlPrologTok will\r
+ return XML_TOK_INVALID, since the BOM is still in the buffer\r
+ */\r
+ else if (tok == XML_TOK_BOM && next == end && !ps_finalBuffer) {\r
+ *nextPtr = next;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ start = next;\r
+ eventPtr = start;\r
+ }\r
+}\r
+\r
+static enum XML_Error PTRCALL\r
+externalParEntProcessor(XML_Parser parser,\r
+ const char *s,\r
+ const char *end,\r
+ const char **nextPtr)\r
+{\r
+ const char *next = s;\r
+ int tok;\r
+\r
+ tok = XmlPrologTok(encoding, s, end, &next);\r
+ if (tok <= 0) {\r
+ if (!ps_finalBuffer && tok != XML_TOK_INVALID) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ switch (tok) {\r
+ case XML_TOK_INVALID:\r
+ return XML_ERROR_INVALID_TOKEN;\r
+ case XML_TOK_PARTIAL:\r
+ return XML_ERROR_UNCLOSED_TOKEN;\r
+ case XML_TOK_PARTIAL_CHAR:\r
+ return XML_ERROR_PARTIAL_CHAR;\r
+ case XML_TOK_NONE: /* start == end */\r
+ default:\r
+ break;\r
+ }\r
+ }\r
+ /* This would cause the next stage, i.e. doProlog to be passed XML_TOK_BOM.\r
+ However, when parsing an external subset, doProlog will not accept a BOM\r
+ as valid, and report a syntax error, so we have to skip the BOM\r
+ */\r
+ else if (tok == XML_TOK_BOM) {\r
+ s = next;\r
+ tok = XmlPrologTok(encoding, s, end, &next);\r
+ }\r
+\r
+ processor = prologProcessor;\r
+ return doProlog(parser, encoding, s, end, tok, next,\r
+ nextPtr, (XML_Bool)!ps_finalBuffer);\r
+}\r
+\r
+static enum XML_Error PTRCALL\r
+entityValueProcessor(XML_Parser parser,\r
+ const char *s,\r
+ const char *end,\r
+ const char **nextPtr)\r
+{\r
+ const char *start = s;\r
+ const char *next = s;\r
+ const ENCODING *enc = encoding;\r
+ int tok;\r
+\r
+ for (;;) {\r
+ tok = XmlPrologTok(enc, start, end, &next);\r
+ if (tok <= 0) {\r
+ if (!ps_finalBuffer && tok != XML_TOK_INVALID) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ switch (tok) {\r
+ case XML_TOK_INVALID:\r
+ return XML_ERROR_INVALID_TOKEN;\r
+ case XML_TOK_PARTIAL:\r
+ return XML_ERROR_UNCLOSED_TOKEN;\r
+ case XML_TOK_PARTIAL_CHAR:\r
+ return XML_ERROR_PARTIAL_CHAR;\r
+ case XML_TOK_NONE: /* start == end */\r
+ default:\r
+ break;\r
+ }\r
+ /* found end of entity value - can store it now */\r
+ return storeEntityValue(parser, enc, s, end);\r
+ }\r
+ start = next;\r
+ }\r
+}\r
+\r
+#endif /* XML_DTD */\r
+\r
+static enum XML_Error PTRCALL\r
+prologProcessor(XML_Parser parser,\r
+ const char *s,\r
+ const char *end,\r
+ const char **nextPtr)\r
+{\r
+ const char *next = s;\r
+ int tok = XmlPrologTok(encoding, s, end, &next);\r
+ return doProlog(parser, encoding, s, end, tok, next,\r
+ nextPtr, (XML_Bool)!ps_finalBuffer);\r
+}\r
+\r
+static enum XML_Error\r
+doProlog(XML_Parser parser,\r
+ const ENCODING *enc,\r
+ const char *s,\r
+ const char *end,\r
+ int tok,\r
+ const char *next,\r
+ const char **nextPtr,\r
+ XML_Bool haveMore)\r
+{\r
+#ifdef XML_DTD\r
+ static const XML_Char externalSubsetName[] = { '#' , '\0' };\r
+#endif /* XML_DTD */\r
+ static const XML_Char atypeCDATA[] = { 'C', 'D', 'A', 'T', 'A', '\0' };\r
+ static const XML_Char atypeID[] = { 'I', 'D', '\0' };\r
+ static const XML_Char atypeIDREF[] = { 'I', 'D', 'R', 'E', 'F', '\0' };\r
+ static const XML_Char atypeIDREFS[] = { 'I', 'D', 'R', 'E', 'F', 'S', '\0' };\r
+ static const XML_Char atypeENTITY[] = { 'E', 'N', 'T', 'I', 'T', 'Y', '\0' };\r
+ static const XML_Char atypeENTITIES[] =\r
+ { 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S', '\0' };\r
+ static const XML_Char atypeNMTOKEN[] = {\r
+ 'N', 'M', 'T', 'O', 'K', 'E', 'N', '\0' };\r
+ static const XML_Char atypeNMTOKENS[] = {\r
+ 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S', '\0' };\r
+ static const XML_Char notationPrefix[] = {\r
+ 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N', '(', '\0' };\r
+ static const XML_Char enumValueSep[] = { '|', '\0' };\r
+ static const XML_Char enumValueStart[] = { '(', '\0' };\r
+\r
+ /* save one level of indirection */\r
+ DTD * const dtd = _dtd;\r
+\r
+ const char **eventPP;\r
+ const char **eventEndPP;\r
+ enum XML_Content_Quant quant;\r
+\r
+ if (enc == encoding) {\r
+ eventPP = &eventPtr;\r
+ eventEndPP = &eventEndPtr;\r
+ }\r
+ else {\r
+ eventPP = &(openInternalEntities->internalEventPtr);\r
+ eventEndPP = &(openInternalEntities->internalEventEndPtr);\r
+ }\r
+\r
+ for (;;) {\r
+ int role;\r
+ XML_Bool handleDefault = XML_TRUE;\r
+ *eventPP = s;\r
+ *eventEndPP = next;\r
+ if (tok <= 0) {\r
+ if (haveMore && tok != XML_TOK_INVALID) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ switch (tok) {\r
+ case XML_TOK_INVALID:\r
+ *eventPP = next;\r
+ return XML_ERROR_INVALID_TOKEN;\r
+ case XML_TOK_PARTIAL:\r
+ return XML_ERROR_UNCLOSED_TOKEN;\r
+ case XML_TOK_PARTIAL_CHAR:\r
+ return XML_ERROR_PARTIAL_CHAR;\r
+ case -XML_TOK_PROLOG_S:\r
+ tok = -tok;\r
+ break;\r
+ case XML_TOK_NONE:\r
+#ifdef XML_DTD\r
+ /* for internal PE NOT referenced between declarations */\r
+ if (enc != encoding && !openInternalEntities->betweenDecl) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ /* WFC: PE Between Declarations - must check that PE contains\r
+ complete markup, not only for external PEs, but also for\r
+ internal PEs if the reference occurs between declarations.\r
+ */\r
+ if (isParamEntity || enc != encoding) {\r
+ if (XmlTokenRole(&prologState, XML_TOK_NONE, end, end, enc)\r
+ == XML_ROLE_ERROR)\r
+ return XML_ERROR_INCOMPLETE_PE;\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+#endif /* XML_DTD */\r
+ return XML_ERROR_NO_ELEMENTS;\r
+ default:\r
+ tok = -tok;\r
+ next = end;\r
+ break;\r
+ }\r
+ }\r
+ role = XmlTokenRole(&prologState, tok, s, next, enc);\r
+ switch (role) {\r
+ case XML_ROLE_XML_DECL:\r
+ {\r
+ enum XML_Error result = processXmlDecl(parser, 0, s, next);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ enc = encoding;\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+ case XML_ROLE_DOCTYPE_NAME:\r
+ if (startDoctypeDeclHandler) {\r
+ doctypeName = poolStoreString(&tempPool, enc, s, next);\r
+ if (!doctypeName)\r
+ return XML_ERROR_NO_MEMORY;\r
+ poolFinish(&tempPool);\r
+ doctypePubid = NULL;\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ doctypeSysid = NULL; /* always initialize to NULL */\r
+ break;\r
+ case XML_ROLE_DOCTYPE_INTERNAL_SUBSET:\r
+ if (startDoctypeDeclHandler) {\r
+ startDoctypeDeclHandler(handlerArg, doctypeName, doctypeSysid,\r
+ doctypePubid, 1);\r
+ doctypeName = NULL;\r
+ poolClear(&tempPool);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+#ifdef XML_DTD\r
+ case XML_ROLE_TEXT_DECL:\r
+ {\r
+ enum XML_Error result = processXmlDecl(parser, 1, s, next);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ enc = encoding;\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+#endif /* XML_DTD */\r
+ case XML_ROLE_DOCTYPE_PUBLIC_ID:\r
+#ifdef XML_DTD\r
+ useForeignDTD = XML_FALSE;\r
+ declEntity = (ENTITY *)lookup(&dtd->paramEntities,\r
+ externalSubsetName,\r
+ sizeof(ENTITY));\r
+ if (!declEntity)\r
+ return XML_ERROR_NO_MEMORY;\r
+#endif /* XML_DTD */\r
+ dtd->hasParamEntityRefs = XML_TRUE;\r
+ if (startDoctypeDeclHandler) {\r
+ if (!XmlIsPublicId(enc, s, next, eventPP))\r
+ return XML_ERROR_PUBLICID;\r
+ doctypePubid = poolStoreString(&tempPool, enc,\r
+ s + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar);\r
+ if (!doctypePubid)\r
+ return XML_ERROR_NO_MEMORY;\r
+ normalizePublicId((XML_Char *)doctypePubid);\r
+ poolFinish(&tempPool);\r
+ handleDefault = XML_FALSE;\r
+ goto alreadyChecked;\r
+ }\r
+ /* fall through */\r
+ case XML_ROLE_ENTITY_PUBLIC_ID:\r
+ if (!XmlIsPublicId(enc, s, next, eventPP))\r
+ return XML_ERROR_PUBLICID;\r
+ alreadyChecked:\r
+ if (dtd->keepProcessing && declEntity) {\r
+ XML_Char *tem = poolStoreString(&dtd->pool,\r
+ enc,\r
+ s + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar);\r
+ if (!tem)\r
+ return XML_ERROR_NO_MEMORY;\r
+ normalizePublicId(tem);\r
+ declEntity->publicId = tem;\r
+ poolFinish(&dtd->pool);\r
+ if (entityDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+ case XML_ROLE_DOCTYPE_CLOSE:\r
+ if (doctypeName) {\r
+ startDoctypeDeclHandler(handlerArg, doctypeName,\r
+ doctypeSysid, doctypePubid, 0);\r
+ poolClear(&tempPool);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ /* doctypeSysid will be non-NULL in the case of a previous\r
+ XML_ROLE_DOCTYPE_SYSTEM_ID, even if startDoctypeDeclHandler\r
+ was not set, indicating an external subset\r
+ */\r
+#ifdef XML_DTD\r
+ if (doctypeSysid || useForeignDTD) {\r
+ XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;\r
+ dtd->hasParamEntityRefs = XML_TRUE;\r
+ if (paramEntityParsing && externalEntityRefHandler) {\r
+ ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,\r
+ externalSubsetName,\r
+ sizeof(ENTITY));\r
+ if (!entity)\r
+ return XML_ERROR_NO_MEMORY;\r
+ if (useForeignDTD)\r
+ entity->base = curBase;\r
+ dtd->paramEntityRead = XML_FALSE;\r
+ if (!externalEntityRefHandler(externalEntityRefHandlerArg,\r
+ 0,\r
+ entity->base,\r
+ entity->systemId,\r
+ entity->publicId))\r
+ return XML_ERROR_EXTERNAL_ENTITY_HANDLING;\r
+ if (dtd->paramEntityRead) {\r
+ if (!dtd->standalone &&\r
+ notStandaloneHandler &&\r
+ !notStandaloneHandler(handlerArg))\r
+ return XML_ERROR_NOT_STANDALONE;\r
+ }\r
+ /* if we didn't read the foreign DTD then this means that there\r
+ is no external subset and we must reset dtd->hasParamEntityRefs\r
+ */\r
+ else if (!doctypeSysid)\r
+ dtd->hasParamEntityRefs = hadParamEntityRefs;\r
+ /* end of DTD - no need to update dtd->keepProcessing */\r
+ }\r
+ useForeignDTD = XML_FALSE;\r
+ }\r
+#endif /* XML_DTD */\r
+ if (endDoctypeDeclHandler) {\r
+ endDoctypeDeclHandler(handlerArg);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+ case XML_ROLE_INSTANCE_START:\r
+#ifdef XML_DTD\r
+ /* if there is no DOCTYPE declaration then now is the\r
+ last chance to read the foreign DTD\r
+ */\r
+ if (useForeignDTD) {\r
+ XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;\r
+ dtd->hasParamEntityRefs = XML_TRUE;\r
+ if (paramEntityParsing && externalEntityRefHandler) {\r
+ ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,\r
+ externalSubsetName,\r
+ sizeof(ENTITY));\r
+ if (!entity)\r
+ return XML_ERROR_NO_MEMORY;\r
+ entity->base = curBase;\r
+ dtd->paramEntityRead = XML_FALSE;\r
+ if (!externalEntityRefHandler(externalEntityRefHandlerArg,\r
+ 0,\r
+ entity->base,\r
+ entity->systemId,\r
+ entity->publicId))\r
+ return XML_ERROR_EXTERNAL_ENTITY_HANDLING;\r
+ if (dtd->paramEntityRead) {\r
+ if (!dtd->standalone &&\r
+ notStandaloneHandler &&\r
+ !notStandaloneHandler(handlerArg))\r
+ return XML_ERROR_NOT_STANDALONE;\r
+ }\r
+ /* if we didn't read the foreign DTD then this means that there\r
+ is no external subset and we must reset dtd->hasParamEntityRefs\r
+ */\r
+ else\r
+ dtd->hasParamEntityRefs = hadParamEntityRefs;\r
+ /* end of DTD - no need to update dtd->keepProcessing */\r
+ }\r
+ }\r
+#endif /* XML_DTD */\r
+ processor = contentProcessor;\r
+ return contentProcessor(parser, s, end, nextPtr);\r
+ case XML_ROLE_ATTLIST_ELEMENT_NAME:\r
+ declElementType = getElementType(parser, enc, s, next);\r
+ if (!declElementType)\r
+ return XML_ERROR_NO_MEMORY;\r
+ goto checkAttListDeclHandler;\r
+ case XML_ROLE_ATTRIBUTE_NAME:\r
+ declAttributeId = getAttributeId(parser, enc, s, next);\r
+ if (!declAttributeId)\r
+ return XML_ERROR_NO_MEMORY;\r
+ declAttributeIsCdata = XML_FALSE;\r
+ declAttributeType = NULL;\r
+ declAttributeIsId = XML_FALSE;\r
+ goto checkAttListDeclHandler;\r
+ case XML_ROLE_ATTRIBUTE_TYPE_CDATA:\r
+ declAttributeIsCdata = XML_TRUE;\r
+ declAttributeType = atypeCDATA;\r
+ goto checkAttListDeclHandler;\r
+ case XML_ROLE_ATTRIBUTE_TYPE_ID:\r
+ declAttributeIsId = XML_TRUE;\r
+ declAttributeType = atypeID;\r
+ goto checkAttListDeclHandler;\r
+ case XML_ROLE_ATTRIBUTE_TYPE_IDREF:\r
+ declAttributeType = atypeIDREF;\r
+ goto checkAttListDeclHandler;\r
+ case XML_ROLE_ATTRIBUTE_TYPE_IDREFS:\r
+ declAttributeType = atypeIDREFS;\r
+ goto checkAttListDeclHandler;\r
+ case XML_ROLE_ATTRIBUTE_TYPE_ENTITY:\r
+ declAttributeType = atypeENTITY;\r
+ goto checkAttListDeclHandler;\r
+ case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES:\r
+ declAttributeType = atypeENTITIES;\r
+ goto checkAttListDeclHandler;\r
+ case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN:\r
+ declAttributeType = atypeNMTOKEN;\r
+ goto checkAttListDeclHandler;\r
+ case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS:\r
+ declAttributeType = atypeNMTOKENS;\r
+ checkAttListDeclHandler:\r
+ if (dtd->keepProcessing && attlistDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ break;\r
+ case XML_ROLE_ATTRIBUTE_ENUM_VALUE:\r
+ case XML_ROLE_ATTRIBUTE_NOTATION_VALUE:\r
+ if (dtd->keepProcessing && attlistDeclHandler) {\r
+ const XML_Char *prefix;\r
+ if (declAttributeType) {\r
+ prefix = enumValueSep;\r
+ }\r
+ else {\r
+ prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE\r
+ ? notationPrefix\r
+ : enumValueStart);\r
+ }\r
+ if (!poolAppendString(&tempPool, prefix))\r
+ return XML_ERROR_NO_MEMORY;\r
+ if (!poolAppend(&tempPool, enc, s, next))\r
+ return XML_ERROR_NO_MEMORY;\r
+ declAttributeType = tempPool.start;\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+ case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:\r
+ case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:\r
+ if (dtd->keepProcessing) {\r
+ if (!defineAttribute(declElementType, declAttributeId,\r
+ declAttributeIsCdata, declAttributeIsId,\r
+ 0, parser))\r
+ return XML_ERROR_NO_MEMORY;\r
+ if (attlistDeclHandler && declAttributeType) {\r
+ if (*declAttributeType == XML_T('(')\r
+ || (*declAttributeType == XML_T('N')\r
+ && declAttributeType[1] == XML_T('O'))) {\r
+ /* Enumerated or Notation type */\r
+ if (!poolAppendChar(&tempPool, XML_T(')'))\r
+ || !poolAppendChar(&tempPool, XML_T('\0')))\r
+ return XML_ERROR_NO_MEMORY;\r
+ declAttributeType = tempPool.start;\r
+ poolFinish(&tempPool);\r
+ }\r
+ *eventEndPP = s;\r
+ attlistDeclHandler(handlerArg, declElementType->name,\r
+ declAttributeId->name, declAttributeType,\r
+ 0, role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);\r
+ poolClear(&tempPool);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ }\r
+ break;\r
+ case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:\r
+ case XML_ROLE_FIXED_ATTRIBUTE_VALUE:\r
+ if (dtd->keepProcessing) {\r
+ const XML_Char *attVal;\r
+ enum XML_Error result =\r
+ storeAttributeValue(parser, enc, declAttributeIsCdata,\r
+ s + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar,\r
+ &dtd->pool);\r
+ if (result)\r
+ return result;\r
+ attVal = poolStart(&dtd->pool);\r
+ poolFinish(&dtd->pool);\r
+ /* ID attributes aren't allowed to have a default */\r
+ if (!defineAttribute(declElementType, declAttributeId,\r
+ declAttributeIsCdata, XML_FALSE, attVal, parser))\r
+ return XML_ERROR_NO_MEMORY;\r
+ if (attlistDeclHandler && declAttributeType) {\r
+ if (*declAttributeType == XML_T('(')\r
+ || (*declAttributeType == XML_T('N')\r
+ && declAttributeType[1] == XML_T('O'))) {\r
+ /* Enumerated or Notation type */\r
+ if (!poolAppendChar(&tempPool, XML_T(')'))\r
+ || !poolAppendChar(&tempPool, XML_T('\0')))\r
+ return XML_ERROR_NO_MEMORY;\r
+ declAttributeType = tempPool.start;\r
+ poolFinish(&tempPool);\r
+ }\r
+ *eventEndPP = s;\r
+ attlistDeclHandler(handlerArg, declElementType->name,\r
+ declAttributeId->name, declAttributeType,\r
+ attVal,\r
+ role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);\r
+ poolClear(&tempPool);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ }\r
+ break;\r
+ case XML_ROLE_ENTITY_VALUE:\r
+ if (dtd->keepProcessing) {\r
+ enum XML_Error result = storeEntityValue(parser, enc,\r
+ s + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar);\r
+ if (declEntity) {\r
+ declEntity->textPtr = poolStart(&dtd->entityValuePool);\r
+ declEntity->textLen = (int)(poolLength(&dtd->entityValuePool));\r
+ poolFinish(&dtd->entityValuePool);\r
+ if (entityDeclHandler) {\r
+ *eventEndPP = s;\r
+ entityDeclHandler(handlerArg,\r
+ declEntity->name,\r
+ declEntity->is_param,\r
+ declEntity->textPtr,\r
+ declEntity->textLen,\r
+ curBase, 0, 0, 0);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ }\r
+ else\r
+ poolDiscard(&dtd->entityValuePool);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ }\r
+ break;\r
+ case XML_ROLE_DOCTYPE_SYSTEM_ID:\r
+#ifdef XML_DTD\r
+ useForeignDTD = XML_FALSE;\r
+#endif /* XML_DTD */\r
+ dtd->hasParamEntityRefs = XML_TRUE;\r
+ if (startDoctypeDeclHandler) {\r
+ doctypeSysid = poolStoreString(&tempPool, enc,\r
+ s + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar);\r
+ if (doctypeSysid == NULL)\r
+ return XML_ERROR_NO_MEMORY;\r
+ poolFinish(&tempPool);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+#ifdef XML_DTD\r
+ else\r
+ /* use externalSubsetName to make doctypeSysid non-NULL\r
+ for the case where no startDoctypeDeclHandler is set */\r
+ doctypeSysid = externalSubsetName;\r
+#endif /* XML_DTD */\r
+ if (!dtd->standalone\r
+#ifdef XML_DTD\r
+ && !paramEntityParsing\r
+#endif /* XML_DTD */\r
+ && notStandaloneHandler\r
+ && !notStandaloneHandler(handlerArg))\r
+ return XML_ERROR_NOT_STANDALONE;\r
+#ifndef XML_DTD\r
+ break;\r
+#else /* XML_DTD */\r
+ if (!declEntity) {\r
+ declEntity = (ENTITY *)lookup(&dtd->paramEntities,\r
+ externalSubsetName,\r
+ sizeof(ENTITY));\r
+ if (!declEntity)\r
+ return XML_ERROR_NO_MEMORY;\r
+ declEntity->publicId = NULL;\r
+ }\r
+ /* fall through */\r
+#endif /* XML_DTD */\r
+ case XML_ROLE_ENTITY_SYSTEM_ID:\r
+ if (dtd->keepProcessing && declEntity) {\r
+ declEntity->systemId = poolStoreString(&dtd->pool, enc,\r
+ s + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar);\r
+ if (!declEntity->systemId)\r
+ return XML_ERROR_NO_MEMORY;\r
+ declEntity->base = curBase;\r
+ poolFinish(&dtd->pool);\r
+ if (entityDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+ case XML_ROLE_ENTITY_COMPLETE:\r
+ if (dtd->keepProcessing && declEntity && entityDeclHandler) {\r
+ *eventEndPP = s;\r
+ entityDeclHandler(handlerArg,\r
+ declEntity->name,\r
+ declEntity->is_param,\r
+ 0,0,\r
+ declEntity->base,\r
+ declEntity->systemId,\r
+ declEntity->publicId,\r
+ 0);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+ case XML_ROLE_ENTITY_NOTATION_NAME:\r
+ if (dtd->keepProcessing && declEntity) {\r
+ declEntity->notation = poolStoreString(&dtd->pool, enc, s, next);\r
+ if (!declEntity->notation)\r
+ return XML_ERROR_NO_MEMORY;\r
+ poolFinish(&dtd->pool);\r
+ if (unparsedEntityDeclHandler) {\r
+ *eventEndPP = s;\r
+ unparsedEntityDeclHandler(handlerArg,\r
+ declEntity->name,\r
+ declEntity->base,\r
+ declEntity->systemId,\r
+ declEntity->publicId,\r
+ declEntity->notation);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ else if (entityDeclHandler) {\r
+ *eventEndPP = s;\r
+ entityDeclHandler(handlerArg,\r
+ declEntity->name,\r
+ 0,0,0,\r
+ declEntity->base,\r
+ declEntity->systemId,\r
+ declEntity->publicId,\r
+ declEntity->notation);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ }\r
+ break;\r
+ case XML_ROLE_GENERAL_ENTITY_NAME:\r
+ {\r
+ if (XmlPredefinedEntityName(enc, s, next)) {\r
+ declEntity = NULL;\r
+ break;\r
+ }\r
+ if (dtd->keepProcessing) {\r
+ const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);\r
+ if (!name)\r
+ return XML_ERROR_NO_MEMORY;\r
+ declEntity = (ENTITY *)lookup(&dtd->generalEntities, name,\r
+ sizeof(ENTITY));\r
+ if (!declEntity)\r
+ return XML_ERROR_NO_MEMORY;\r
+ if (declEntity->name != name) {\r
+ poolDiscard(&dtd->pool);\r
+ declEntity = NULL;\r
+ }\r
+ else {\r
+ poolFinish(&dtd->pool);\r
+ declEntity->publicId = NULL;\r
+ declEntity->is_param = XML_FALSE;\r
+ /* if we have a parent parser or are reading an internal parameter\r
+ entity, then the entity declaration is not considered "internal"\r
+ */\r
+ declEntity->is_internal = !(parentParser || openInternalEntities);\r
+ if (entityDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ }\r
+ else {\r
+ poolDiscard(&dtd->pool);\r
+ declEntity = NULL;\r
+ }\r
+ }\r
+ break;\r
+ case XML_ROLE_PARAM_ENTITY_NAME:\r
+#ifdef XML_DTD\r
+ if (dtd->keepProcessing) {\r
+ const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);\r
+ if (!name)\r
+ return XML_ERROR_NO_MEMORY;\r
+ declEntity = (ENTITY *)lookup(&dtd->paramEntities,\r
+ name, sizeof(ENTITY));\r
+ if (!declEntity)\r
+ return XML_ERROR_NO_MEMORY;\r
+ if (declEntity->name != name) {\r
+ poolDiscard(&dtd->pool);\r
+ declEntity = NULL;\r
+ }\r
+ else {\r
+ poolFinish(&dtd->pool);\r
+ declEntity->publicId = NULL;\r
+ declEntity->is_param = XML_TRUE;\r
+ /* if we have a parent parser or are reading an internal parameter\r
+ entity, then the entity declaration is not considered "internal"\r
+ */\r
+ declEntity->is_internal = !(parentParser || openInternalEntities);\r
+ if (entityDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ }\r
+ else {\r
+ poolDiscard(&dtd->pool);\r
+ declEntity = NULL;\r
+ }\r
+#else /* not XML_DTD */\r
+ declEntity = NULL;\r
+#endif /* XML_DTD */\r
+ break;\r
+ case XML_ROLE_NOTATION_NAME:\r
+ declNotationPublicId = NULL;\r
+ declNotationName = NULL;\r
+ if (notationDeclHandler) {\r
+ declNotationName = poolStoreString(&tempPool, enc, s, next);\r
+ if (!declNotationName)\r
+ return XML_ERROR_NO_MEMORY;\r
+ poolFinish(&tempPool);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+ case XML_ROLE_NOTATION_PUBLIC_ID:\r
+ if (!XmlIsPublicId(enc, s, next, eventPP))\r
+ return XML_ERROR_PUBLICID;\r
+ if (declNotationName) { /* means notationDeclHandler != NULL */\r
+ XML_Char *tem = poolStoreString(&tempPool,\r
+ enc,\r
+ s + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar);\r
+ if (!tem)\r
+ return XML_ERROR_NO_MEMORY;\r
+ normalizePublicId(tem);\r
+ declNotationPublicId = tem;\r
+ poolFinish(&tempPool);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+ case XML_ROLE_NOTATION_SYSTEM_ID:\r
+ if (declNotationName && notationDeclHandler) {\r
+ const XML_Char *systemId\r
+ = poolStoreString(&tempPool, enc,\r
+ s + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar);\r
+ if (!systemId)\r
+ return XML_ERROR_NO_MEMORY;\r
+ *eventEndPP = s;\r
+ notationDeclHandler(handlerArg,\r
+ declNotationName,\r
+ curBase,\r
+ systemId,\r
+ declNotationPublicId);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ poolClear(&tempPool);\r
+ break;\r
+ case XML_ROLE_NOTATION_NO_SYSTEM_ID:\r
+ if (declNotationPublicId && notationDeclHandler) {\r
+ *eventEndPP = s;\r
+ notationDeclHandler(handlerArg,\r
+ declNotationName,\r
+ curBase,\r
+ 0,\r
+ declNotationPublicId);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ poolClear(&tempPool);\r
+ break;\r
+ case XML_ROLE_ERROR:\r
+ switch (tok) {\r
+ case XML_TOK_PARAM_ENTITY_REF:\r
+ /* PE references in internal subset are\r
+ not allowed within declarations. */\r
+ return XML_ERROR_PARAM_ENTITY_REF;\r
+ case XML_TOK_XML_DECL:\r
+ return XML_ERROR_MISPLACED_XML_PI;\r
+ default:\r
+ return XML_ERROR_SYNTAX;\r
+ }\r
+#ifdef XML_DTD\r
+ case XML_ROLE_IGNORE_SECT:\r
+ {\r
+ enum XML_Error result;\r
+ if (defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+ handleDefault = XML_FALSE;\r
+ result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ else if (!next) {\r
+ processor = ignoreSectionProcessor;\r
+ return result;\r
+ }\r
+ }\r
+ break;\r
+#endif /* XML_DTD */\r
+ case XML_ROLE_GROUP_OPEN:\r
+ if (prologState.level >= groupSize) {\r
+ if (groupSize) {\r
+ char *temp = (char *)REALLOC(groupConnector, groupSize *= 2);\r
+ if (temp == NULL)\r
+ return XML_ERROR_NO_MEMORY;\r
+ groupConnector = temp;\r
+ if (dtd->scaffIndex) {\r
+ int *temp = (int *)REALLOC(dtd->scaffIndex,\r
+ groupSize * sizeof(int));\r
+ if (temp == NULL)\r
+ return XML_ERROR_NO_MEMORY;\r
+ dtd->scaffIndex = temp;\r
+ }\r
+ }\r
+ else {\r
+ groupConnector = (char *)MALLOC(groupSize = 32);\r
+ if (!groupConnector)\r
+ return XML_ERROR_NO_MEMORY;\r
+ }\r
+ }\r
+ groupConnector[prologState.level] = 0;\r
+ if (dtd->in_eldecl) {\r
+ int myindex = nextScaffoldPart(parser);\r
+ if (myindex < 0)\r
+ return XML_ERROR_NO_MEMORY;\r
+ dtd->scaffIndex[dtd->scaffLevel] = myindex;\r
+ dtd->scaffLevel++;\r
+ dtd->scaffold[myindex].type = XML_CTYPE_SEQ;\r
+ if (elementDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+ case XML_ROLE_GROUP_SEQUENCE:\r
+ if (groupConnector[prologState.level] == '|')\r
+ return XML_ERROR_SYNTAX;\r
+ groupConnector[prologState.level] = ',';\r
+ if (dtd->in_eldecl && elementDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ break;\r
+ case XML_ROLE_GROUP_CHOICE:\r
+ if (groupConnector[prologState.level] == ',')\r
+ return XML_ERROR_SYNTAX;\r
+ if (dtd->in_eldecl\r
+ && !groupConnector[prologState.level]\r
+ && (dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type\r
+ != XML_CTYPE_MIXED)\r
+ ) {\r
+ dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type\r
+ = XML_CTYPE_CHOICE;\r
+ if (elementDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ groupConnector[prologState.level] = '|';\r
+ break;\r
+ case XML_ROLE_PARAM_ENTITY_REF:\r
+#ifdef XML_DTD\r
+ case XML_ROLE_INNER_PARAM_ENTITY_REF:\r
+ dtd->hasParamEntityRefs = XML_TRUE;\r
+ if (!paramEntityParsing)\r
+ dtd->keepProcessing = dtd->standalone;\r
+ else {\r
+ const XML_Char *name;\r
+ ENTITY *entity;\r
+ name = poolStoreString(&dtd->pool, enc,\r
+ s + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar);\r
+ if (!name)\r
+ return XML_ERROR_NO_MEMORY;\r
+ entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);\r
+ poolDiscard(&dtd->pool);\r
+ /* first, determine if a check for an existing declaration is needed;\r
+ if yes, check that the entity exists, and that it is internal,\r
+ otherwise call the skipped entity handler\r
+ */\r
+ if (prologState.documentEntity &&\r
+ (dtd->standalone\r
+ ? !openInternalEntities\r
+ : !dtd->hasParamEntityRefs)) {\r
+ if (!entity)\r
+ return XML_ERROR_UNDEFINED_ENTITY;\r
+ else if (!entity->is_internal)\r
+ return XML_ERROR_ENTITY_DECLARED_IN_PE;\r
+ }\r
+ else if (!entity) {\r
+ dtd->keepProcessing = dtd->standalone;\r
+ /* cannot report skipped entities in declarations */\r
+ if ((role == XML_ROLE_PARAM_ENTITY_REF) && skippedEntityHandler) {\r
+ skippedEntityHandler(handlerArg, name, 1);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+ }\r
+ if (entity->open)\r
+ return XML_ERROR_RECURSIVE_ENTITY_REF;\r
+ if (entity->textPtr) {\r
+ enum XML_Error result;\r
+ XML_Bool betweenDecl =\r
+ (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);\r
+ result = processInternalEntity(parser, entity, betweenDecl);\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ handleDefault = XML_FALSE;\r
+ break;\r
+ }\r
+ if (externalEntityRefHandler) {\r
+ dtd->paramEntityRead = XML_FALSE;\r
+ entity->open = XML_TRUE;\r
+ if (!externalEntityRefHandler(externalEntityRefHandlerArg,\r
+ 0,\r
+ entity->base,\r
+ entity->systemId,\r
+ entity->publicId)) {\r
+ entity->open = XML_FALSE;\r
+ return XML_ERROR_EXTERNAL_ENTITY_HANDLING;\r
+ }\r
+ entity->open = XML_FALSE;\r
+ handleDefault = XML_FALSE;\r
+ if (!dtd->paramEntityRead) {\r
+ dtd->keepProcessing = dtd->standalone;\r
+ break;\r
+ }\r
+ }\r
+ else {\r
+ dtd->keepProcessing = dtd->standalone;\r
+ break;\r
+ }\r
+ }\r
+#endif /* XML_DTD */\r
+ if (!dtd->standalone &&\r
+ notStandaloneHandler &&\r
+ !notStandaloneHandler(handlerArg))\r
+ return XML_ERROR_NOT_STANDALONE;\r
+ break;\r
+\r
+ /* Element declaration stuff */\r
+\r
+ case XML_ROLE_ELEMENT_NAME:\r
+ if (elementDeclHandler) {\r
+ declElementType = getElementType(parser, enc, s, next);\r
+ if (!declElementType)\r
+ return XML_ERROR_NO_MEMORY;\r
+ dtd->scaffLevel = 0;\r
+ dtd->scaffCount = 0;\r
+ dtd->in_eldecl = XML_TRUE;\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+\r
+ case XML_ROLE_CONTENT_ANY:\r
+ case XML_ROLE_CONTENT_EMPTY:\r
+ if (dtd->in_eldecl) {\r
+ if (elementDeclHandler) {\r
+ XML_Content * content = (XML_Content *) MALLOC(sizeof(XML_Content));\r
+ if (!content)\r
+ return XML_ERROR_NO_MEMORY;\r
+ content->quant = XML_CQUANT_NONE;\r
+ content->name = NULL;\r
+ content->numchildren = 0;\r
+ content->children = NULL;\r
+ content->type = ((role == XML_ROLE_CONTENT_ANY) ?\r
+ XML_CTYPE_ANY :\r
+ XML_CTYPE_EMPTY);\r
+ *eventEndPP = s;\r
+ elementDeclHandler(handlerArg, declElementType->name, content);\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ dtd->in_eldecl = XML_FALSE;\r
+ }\r
+ break;\r
+\r
+ case XML_ROLE_CONTENT_PCDATA:\r
+ if (dtd->in_eldecl) {\r
+ dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type\r
+ = XML_CTYPE_MIXED;\r
+ if (elementDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+\r
+ case XML_ROLE_CONTENT_ELEMENT:\r
+ quant = XML_CQUANT_NONE;\r
+ goto elementContent;\r
+ case XML_ROLE_CONTENT_ELEMENT_OPT:\r
+ quant = XML_CQUANT_OPT;\r
+ goto elementContent;\r
+ case XML_ROLE_CONTENT_ELEMENT_REP:\r
+ quant = XML_CQUANT_REP;\r
+ goto elementContent;\r
+ case XML_ROLE_CONTENT_ELEMENT_PLUS:\r
+ quant = XML_CQUANT_PLUS;\r
+ elementContent:\r
+ if (dtd->in_eldecl) {\r
+ ELEMENT_TYPE *el;\r
+ const XML_Char *name;\r
+ int nameLen;\r
+ const char *nxt = (quant == XML_CQUANT_NONE\r
+ ? next\r
+ : next - enc->minBytesPerChar);\r
+ int myindex = nextScaffoldPart(parser);\r
+ if (myindex < 0)\r
+ return XML_ERROR_NO_MEMORY;\r
+ dtd->scaffold[myindex].type = XML_CTYPE_NAME;\r
+ dtd->scaffold[myindex].quant = quant;\r
+ el = getElementType(parser, enc, s, nxt);\r
+ if (!el)\r
+ return XML_ERROR_NO_MEMORY;\r
+ name = el->name;\r
+ dtd->scaffold[myindex].name = name;\r
+ nameLen = 0;\r
+ for (; name[nameLen++]; );\r
+ dtd->contentStringLen += nameLen;\r
+ if (elementDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ }\r
+ break;\r
+\r
+ case XML_ROLE_GROUP_CLOSE:\r
+ quant = XML_CQUANT_NONE;\r
+ goto closeGroup;\r
+ case XML_ROLE_GROUP_CLOSE_OPT:\r
+ quant = XML_CQUANT_OPT;\r
+ goto closeGroup;\r
+ case XML_ROLE_GROUP_CLOSE_REP:\r
+ quant = XML_CQUANT_REP;\r
+ goto closeGroup;\r
+ case XML_ROLE_GROUP_CLOSE_PLUS:\r
+ quant = XML_CQUANT_PLUS;\r
+ closeGroup:\r
+ if (dtd->in_eldecl) {\r
+ if (elementDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ dtd->scaffLevel--;\r
+ dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel]].quant = quant;\r
+ if (dtd->scaffLevel == 0) {\r
+ if (!handleDefault) {\r
+ XML_Content *model = build_model(parser);\r
+ if (!model)\r
+ return XML_ERROR_NO_MEMORY;\r
+ *eventEndPP = s;\r
+ elementDeclHandler(handlerArg, declElementType->name, model);\r
+ }\r
+ dtd->in_eldecl = XML_FALSE;\r
+ dtd->contentStringLen = 0;\r
+ }\r
+ }\r
+ break;\r
+ /* End element declaration stuff */\r
+\r
+ case XML_ROLE_PI:\r
+ if (!reportProcessingInstruction(parser, enc, s, next))\r
+ return XML_ERROR_NO_MEMORY;\r
+ handleDefault = XML_FALSE;\r
+ break;\r
+ case XML_ROLE_COMMENT:\r
+ if (!reportComment(parser, enc, s, next))\r
+ return XML_ERROR_NO_MEMORY;\r
+ handleDefault = XML_FALSE;\r
+ break;\r
+ case XML_ROLE_NONE:\r
+ switch (tok) {\r
+ case XML_TOK_BOM:\r
+ handleDefault = XML_FALSE;\r
+ break;\r
+ }\r
+ break;\r
+ case XML_ROLE_DOCTYPE_NONE:\r
+ if (startDoctypeDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ break;\r
+ case XML_ROLE_ENTITY_NONE:\r
+ if (dtd->keepProcessing && entityDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ break;\r
+ case XML_ROLE_NOTATION_NONE:\r
+ if (notationDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ break;\r
+ case XML_ROLE_ATTLIST_NONE:\r
+ if (dtd->keepProcessing && attlistDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ break;\r
+ case XML_ROLE_ELEMENT_NONE:\r
+ if (elementDeclHandler)\r
+ handleDefault = XML_FALSE;\r
+ break;\r
+ } /* end of big switch */\r
+\r
+ if (handleDefault && defaultHandler)\r
+ reportDefault(parser, enc, s, next);\r
+\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ *nextPtr = next;\r
+ return XML_ERROR_NONE;\r
+ case XML_FINISHED:\r
+ return XML_ERROR_ABORTED;\r
+ default:\r
+ s = next;\r
+ tok = XmlPrologTok(enc, s, end, &next);\r
+ }\r
+ }\r
+ /* not reached */\r
+}\r
+\r
+static enum XML_Error PTRCALL\r
+epilogProcessor(XML_Parser parser,\r
+ const char *s,\r
+ const char *end,\r
+ const char **nextPtr)\r
+{\r
+ processor = epilogProcessor;\r
+ eventPtr = s;\r
+ for (;;) {\r
+ const char *next = NULL;\r
+ int tok = XmlPrologTok(encoding, s, end, &next);\r
+ eventEndPtr = next;\r
+ switch (tok) {\r
+ /* report partial linebreak - it might be the last token */\r
+ case -XML_TOK_PROLOG_S:\r
+ if (defaultHandler) {\r
+ reportDefault(parser, encoding, s, next);\r
+ if (ps_parsing == XML_FINISHED)\r
+ return XML_ERROR_ABORTED;\r
+ }\r
+ *nextPtr = next;\r
+ return XML_ERROR_NONE;\r
+ case XML_TOK_NONE:\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ case XML_TOK_PROLOG_S:\r
+ if (defaultHandler)\r
+ reportDefault(parser, encoding, s, next);\r
+ break;\r
+ case XML_TOK_PI:\r
+ if (!reportProcessingInstruction(parser, encoding, s, next))\r
+ return XML_ERROR_NO_MEMORY;\r
+ break;\r
+ case XML_TOK_COMMENT:\r
+ if (!reportComment(parser, encoding, s, next))\r
+ return XML_ERROR_NO_MEMORY;\r
+ break;\r
+ case XML_TOK_INVALID:\r
+ eventPtr = next;\r
+ return XML_ERROR_INVALID_TOKEN;\r
+ case XML_TOK_PARTIAL:\r
+ if (!ps_finalBuffer) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ return XML_ERROR_UNCLOSED_TOKEN;\r
+ case XML_TOK_PARTIAL_CHAR:\r
+ if (!ps_finalBuffer) {\r
+ *nextPtr = s;\r
+ return XML_ERROR_NONE;\r
+ }\r
+ return XML_ERROR_PARTIAL_CHAR;\r
+ default:\r
+ return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;\r
+ }\r
+ eventPtr = s = next;\r
+ switch (ps_parsing) {\r
+ case XML_SUSPENDED:\r
+ *nextPtr = next;\r
+ return XML_ERROR_NONE;\r
+ case XML_FINISHED:\r
+ return XML_ERROR_ABORTED;\r
+ default: ;\r
+ }\r
+ }\r
+}\r
+\r
+static enum XML_Error\r
+processInternalEntity(XML_Parser parser, ENTITY *entity,\r
+ XML_Bool betweenDecl)\r
+{\r
+ const char *textStart, *textEnd;\r
+ const char *next;\r
+ enum XML_Error result;\r
+ OPEN_INTERNAL_ENTITY *openEntity;\r
+\r
+ if (freeInternalEntities) {\r
+ openEntity = freeInternalEntities;\r
+ freeInternalEntities = openEntity->next;\r
+ }\r
+ else {\r
+ openEntity = (OPEN_INTERNAL_ENTITY *)MALLOC(sizeof(OPEN_INTERNAL_ENTITY));\r
+ if (!openEntity)\r
+ return XML_ERROR_NO_MEMORY;\r
+ }\r
+ entity->open = XML_TRUE;\r
+ entity->processed = 0;\r
+ openEntity->next = openInternalEntities;\r
+ openInternalEntities = openEntity;\r
+ openEntity->entity = entity;\r
+ openEntity->startTagLevel = tagLevel;\r
+ openEntity->betweenDecl = betweenDecl;\r
+ openEntity->internalEventPtr = NULL;\r
+ openEntity->internalEventEndPtr = NULL;\r
+ textStart = (char *)entity->textPtr;\r
+ textEnd = (char *)(entity->textPtr + entity->textLen);\r
+\r
+#ifdef XML_DTD\r
+ if (entity->is_param) {\r
+ int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);\r
+ result = doProlog(parser, internalEncoding, textStart, textEnd, tok,\r
+ next, &next, XML_FALSE);\r
+ }\r
+ else\r
+#endif /* XML_DTD */\r
+ result = doContent(parser, tagLevel, internalEncoding, textStart,\r
+ textEnd, &next, XML_FALSE);\r
+\r
+ if (result == XML_ERROR_NONE) {\r
+ if (textEnd != next && ps_parsing == XML_SUSPENDED) {\r
+ entity->processed = (int)(next - textStart);\r
+ processor = internalEntityProcessor;\r
+ }\r
+ else {\r
+ entity->open = XML_FALSE;\r
+ openInternalEntities = openEntity->next;\r
+ /* put openEntity back in list of free instances */\r
+ openEntity->next = freeInternalEntities;\r
+ freeInternalEntities = openEntity;\r
+ }\r
+ }\r
+ return result;\r
+}\r
+\r
+static enum XML_Error PTRCALL\r
+internalEntityProcessor(XML_Parser parser,\r
+ const char *s,\r
+ const char *end,\r
+ const char **nextPtr)\r
+{\r
+ ENTITY *entity;\r
+ const char *textStart, *textEnd;\r
+ const char *next;\r
+ enum XML_Error result;\r
+ OPEN_INTERNAL_ENTITY *openEntity = openInternalEntities;\r
+ if (!openEntity)\r
+ return XML_ERROR_UNEXPECTED_STATE;\r
+\r
+ entity = openEntity->entity;\r
+ textStart = ((char *)entity->textPtr) + entity->processed;\r
+ textEnd = (char *)(entity->textPtr + entity->textLen);\r
+\r
+#ifdef XML_DTD\r
+ if (entity->is_param) {\r
+ int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);\r
+ result = doProlog(parser, internalEncoding, textStart, textEnd, tok,\r
+ next, &next, XML_FALSE);\r
+ }\r
+ else\r
+#endif /* XML_DTD */\r
+ result = doContent(parser, openEntity->startTagLevel, internalEncoding,\r
+ textStart, textEnd, &next, XML_FALSE);\r
+\r
+ if (result != XML_ERROR_NONE)\r
+ return result;\r
+ else if (textEnd != next && ps_parsing == XML_SUSPENDED) {\r
+ entity->processed = (int)(next - (char *)entity->textPtr);\r
+ return result;\r
+ }\r
+ else {\r
+ entity->open = XML_FALSE;\r
+ openInternalEntities = openEntity->next;\r
+ /* put openEntity back in list of free instances */\r
+ openEntity->next = freeInternalEntities;\r
+ freeInternalEntities = openEntity;\r
+ }\r
+\r
+#ifdef XML_DTD\r
+ if (entity->is_param) {\r
+ int tok;\r
+ processor = prologProcessor;\r
+ tok = XmlPrologTok(encoding, s, end, &next);\r
+ return doProlog(parser, encoding, s, end, tok, next, nextPtr,\r
+ (XML_Bool)!ps_finalBuffer);\r
+ }\r
+ else\r
+#endif /* XML_DTD */\r
+ {\r
+ processor = contentProcessor;\r
+ /* see externalEntityContentProcessor vs contentProcessor */\r
+ return doContent(parser, parentParser ? 1 : 0, encoding, s, end,\r
+ nextPtr, (XML_Bool)!ps_finalBuffer);\r
+ }\r
+}\r
+\r
+static enum XML_Error PTRCALL\r
+errorProcessor(XML_Parser parser,\r
+ const char *s,\r
+ const char *end,\r
+ const char **nextPtr)\r
+{\r
+ return errorCode;\r
+}\r
+\r
+static enum XML_Error\r
+storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,\r
+ const char *ptr, const char *end,\r
+ STRING_POOL *pool)\r
+{\r
+ enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr,\r
+ end, pool);\r
+ if (result)\r
+ return result;\r
+ if (!isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)\r
+ poolChop(pool);\r
+ if (!poolAppendChar(pool, XML_T('\0')))\r
+ return XML_ERROR_NO_MEMORY;\r
+ return XML_ERROR_NONE;\r
+}\r
+\r
+static enum XML_Error\r
+appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,\r
+ const char *ptr, const char *end,\r
+ STRING_POOL *pool)\r
+{\r
+ DTD * const dtd = _dtd; /* save one level of indirection */\r
+ for (;;) {\r
+ const char *next;\r
+ int tok = XmlAttributeValueTok(enc, ptr, end, &next);\r
+ switch (tok) {\r
+ case XML_TOK_NONE:\r
+ return XML_ERROR_NONE;\r
+ case XML_TOK_INVALID:\r
+ if (enc == encoding)\r
+ eventPtr = next;\r
+ return XML_ERROR_INVALID_TOKEN;\r
+ case XML_TOK_PARTIAL:\r
+ if (enc == encoding)\r
+ eventPtr = ptr;\r
+ return XML_ERROR_INVALID_TOKEN;\r
+ case XML_TOK_CHAR_REF:\r
+ {\r
+ XML_Char buf[XML_ENCODE_MAX];\r
+ int i;\r
+ int n = XmlCharRefNumber(enc, ptr);\r
+ if (n < 0) {\r
+ if (enc == encoding)\r
+ eventPtr = ptr;\r
+ return XML_ERROR_BAD_CHAR_REF;\r
+ }\r
+ if (!isCdata\r
+ && n == 0x20 /* space */\r
+ && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))\r
+ break;\r
+ n = XmlEncode(n, (ICHAR *)buf);\r
+ if (!n) {\r
+ if (enc == encoding)\r
+ eventPtr = ptr;\r
+ return XML_ERROR_BAD_CHAR_REF;\r
+ }\r
+ for (i = 0; i < n; i++) {\r
+ if (!poolAppendChar(pool, buf[i]))\r
+ return XML_ERROR_NO_MEMORY;\r
+ }\r
+ }\r
+ break;\r
+ case XML_TOK_DATA_CHARS:\r
+ if (!poolAppend(pool, enc, ptr, next))\r
+ return XML_ERROR_NO_MEMORY;\r
+ break;\r
+ case XML_TOK_TRAILING_CR:\r
+ next = ptr + enc->minBytesPerChar;\r
+ /* fall through */\r
+ case XML_TOK_ATTRIBUTE_VALUE_S:\r
+ case XML_TOK_DATA_NEWLINE:\r
+ if (!isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))\r
+ break;\r
+ if (!poolAppendChar(pool, 0x20))\r
+ return XML_ERROR_NO_MEMORY;\r
+ break;\r
+ case XML_TOK_ENTITY_REF:\r
+ {\r
+ const XML_Char *name;\r
+ ENTITY *entity;\r
+ char checkEntityDecl;\r
+ XML_Char ch = (XML_Char) XmlPredefinedEntityName(enc,\r
+ ptr + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar);\r
+ if (ch) {\r
+ if (!poolAppendChar(pool, ch))\r
+ return XML_ERROR_NO_MEMORY;\r
+ break;\r
+ }\r
+ name = poolStoreString(&temp2Pool, enc,\r
+ ptr + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar);\r
+ if (!name)\r
+ return XML_ERROR_NO_MEMORY;\r
+ entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);\r
+ poolDiscard(&temp2Pool);\r
+ /* First, determine if a check for an existing declaration is needed;\r
+ if yes, check that the entity exists, and that it is internal.\r
+ */\r
+ if (pool == &dtd->pool) /* are we called from prolog? */\r
+ checkEntityDecl =\r
+#ifdef XML_DTD\r
+ prologState.documentEntity &&\r
+#endif /* XML_DTD */\r
+ (dtd->standalone\r
+ ? !openInternalEntities\r
+ : !dtd->hasParamEntityRefs);\r
+ else /* if (pool == &tempPool): we are called from content */\r
+ checkEntityDecl = !dtd->hasParamEntityRefs || dtd->standalone;\r
+ if (checkEntityDecl) {\r
+ if (!entity)\r
+ return XML_ERROR_UNDEFINED_ENTITY;\r
+ else if (!entity->is_internal)\r
+ return XML_ERROR_ENTITY_DECLARED_IN_PE;\r
+ }\r
+ else if (!entity) {\r
+ /* Cannot report skipped entity here - see comments on\r
+ skippedEntityHandler.\r
+ if (skippedEntityHandler)\r
+ skippedEntityHandler(handlerArg, name, 0);\r
+ */\r
+ /* Cannot call the default handler because this would be\r
+ out of sync with the call to the startElementHandler.\r
+ if ((pool == &tempPool) && defaultHandler)\r
+ reportDefault(parser, enc, ptr, next);\r
+ */\r
+ break;\r
+ }\r
+ if (entity->open) {\r
+ if (enc == encoding)\r
+ eventPtr = ptr;\r
+ return XML_ERROR_RECURSIVE_ENTITY_REF;\r
+ }\r
+ if (entity->notation) {\r
+ if (enc == encoding)\r
+ eventPtr = ptr;\r
+ return XML_ERROR_BINARY_ENTITY_REF;\r
+ }\r
+ if (!entity->textPtr) {\r
+ if (enc == encoding)\r
+ eventPtr = ptr;\r
+ return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;\r
+ }\r
+ else {\r
+ enum XML_Error result;\r
+ const XML_Char *textEnd = entity->textPtr + entity->textLen;\r
+ entity->open = XML_TRUE;\r
+ result = appendAttributeValue(parser, internalEncoding, isCdata,\r
+ (char *)entity->textPtr,\r
+ (char *)textEnd, pool);\r
+ entity->open = XML_FALSE;\r
+ if (result)\r
+ return result;\r
+ }\r
+ }\r
+ break;\r
+ default:\r
+ if (enc == encoding)\r
+ eventPtr = ptr;\r
+ return XML_ERROR_UNEXPECTED_STATE;\r
+ }\r
+ ptr = next;\r
+ }\r
+ /* not reached */\r
+}\r
+\r
+static enum XML_Error\r
+storeEntityValue(XML_Parser parser,\r
+ const ENCODING *enc,\r
+ const char *entityTextPtr,\r
+ const char *entityTextEnd)\r
+{\r
+ DTD * const dtd = _dtd; /* save one level of indirection */\r
+ STRING_POOL *pool = &(dtd->entityValuePool);\r
+ enum XML_Error result = XML_ERROR_NONE;\r
+#ifdef XML_DTD\r
+ int oldInEntityValue = prologState.inEntityValue;\r
+ prologState.inEntityValue = 1;\r
+#endif /* XML_DTD */\r
+ /* never return Null for the value argument in EntityDeclHandler,\r
+ since this would indicate an external entity; therefore we\r
+ have to make sure that entityValuePool.start is not null */\r
+ if (!pool->blocks) {\r
+ if (!poolGrow(pool))\r
+ return XML_ERROR_NO_MEMORY;\r
+ }\r
+\r
+ for (;;) {\r
+ const char *next;\r
+ int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);\r
+ switch (tok) {\r
+ case XML_TOK_PARAM_ENTITY_REF:\r
+#ifdef XML_DTD\r
+ if (isParamEntity || enc != encoding) {\r
+ const XML_Char *name;\r
+ ENTITY *entity;\r
+ name = poolStoreString(&tempPool, enc,\r
+ entityTextPtr + enc->minBytesPerChar,\r
+ next - enc->minBytesPerChar);\r
+ if (!name) {\r
+ result = XML_ERROR_NO_MEMORY;\r
+ goto endEntityValue;\r
+ }\r
+ entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);\r
+ poolDiscard(&tempPool);\r
+ if (!entity) {\r
+ /* not a well-formedness error - see XML 1.0: WFC Entity Declared */\r
+ /* cannot report skipped entity here - see comments on\r
+ skippedEntityHandler\r
+ if (skippedEntityHandler)\r
+ skippedEntityHandler(handlerArg, name, 0);\r
+ */\r
+ dtd->keepProcessing = dtd->standalone;\r
+ goto endEntityValue;\r
+ }\r
+ if (entity->open) {\r
+ if (enc == encoding)\r
+ eventPtr = entityTextPtr;\r
+ result = XML_ERROR_RECURSIVE_ENTITY_REF;\r
+ goto endEntityValue;\r
+ }\r
+ if (entity->systemId) {\r
+ if (externalEntityRefHandler) {\r
+ dtd->paramEntityRead = XML_FALSE;\r
+ entity->open = XML_TRUE;\r
+ if (!externalEntityRefHandler(externalEntityRefHandlerArg,\r
+ 0,\r
+ entity->base,\r
+ entity->systemId,\r
+ entity->publicId)) {\r
+ entity->open = XML_FALSE;\r
+ result = XML_ERROR_EXTERNAL_ENTITY_HANDLING;\r
+ goto endEntityValue;\r
+ }\r
+ entity->open = XML_FALSE;\r
+ if (!dtd->paramEntityRead)\r
+ dtd->keepProcessing = dtd->standalone;\r
+ }\r
+ else\r
+ dtd->keepProcessing = dtd->standalone;\r
+ }\r
+ else {\r
+ entity->open = XML_TRUE;\r
+ result = storeEntityValue(parser,\r
+ internalEncoding,\r
+ (char *)entity->textPtr,\r
+ (char *)(entity->textPtr\r
+ + entity->textLen));\r
+ entity->open = XML_FALSE;\r
+ if (result)\r
+ goto endEntityValue;\r
+ }\r
+ break;\r
+ }\r
+#endif /* XML_DTD */\r
+ /* In the internal subset, PE references are not legal\r
+ within markup declarations, e.g entity values in this case. */\r
+ eventPtr = entityTextPtr;\r
+ result = XML_ERROR_PARAM_ENTITY_REF;\r
+ goto endEntityValue;\r
+ case XML_TOK_NONE:\r
+ result = XML_ERROR_NONE;\r
+ goto endEntityValue;\r
+ case XML_TOK_ENTITY_REF:\r
+ case XML_TOK_DATA_CHARS:\r
+ if (!poolAppend(pool, enc, entityTextPtr, next)) {\r
+ result = XML_ERROR_NO_MEMORY;\r
+ goto endEntityValue;\r
+ }\r
+ break;\r
+ case XML_TOK_TRAILING_CR:\r
+ next = entityTextPtr + enc->minBytesPerChar;\r
+ /* fall through */\r
+ case XML_TOK_DATA_NEWLINE:\r
+ if (pool->end == pool->ptr && !poolGrow(pool)) {\r
+ result = XML_ERROR_NO_MEMORY;\r
+ goto endEntityValue;\r
+ }\r
+ *(pool->ptr)++ = 0xA;\r
+ break;\r
+ case XML_TOK_CHAR_REF:\r
+ {\r
+ XML_Char buf[XML_ENCODE_MAX];\r
+ int i;\r
+ int n = XmlCharRefNumber(enc, entityTextPtr);\r
+ if (n < 0) {\r
+ if (enc == encoding)\r
+ eventPtr = entityTextPtr;\r
+ result = XML_ERROR_BAD_CHAR_REF;\r
+ goto endEntityValue;\r
+ }\r
+ n = XmlEncode(n, (ICHAR *)buf);\r
+ if (!n) {\r
+ if (enc == encoding)\r
+ eventPtr = entityTextPtr;\r
+ result = XML_ERROR_BAD_CHAR_REF;\r
+ goto endEntityValue;\r
+ }\r
+ for (i = 0; i < n; i++) {\r
+ if (pool->end == pool->ptr && !poolGrow(pool)) {\r
+ result = XML_ERROR_NO_MEMORY;\r
+ goto endEntityValue;\r
+ }\r
+ *(pool->ptr)++ = buf[i];\r
+ }\r
+ }\r
+ break;\r
+ case XML_TOK_PARTIAL:\r
+ if (enc == encoding)\r
+ eventPtr = entityTextPtr;\r
+ result = XML_ERROR_INVALID_TOKEN;\r
+ goto endEntityValue;\r
+ case XML_TOK_INVALID:\r
+ if (enc == encoding)\r
+ eventPtr = next;\r
+ result = XML_ERROR_INVALID_TOKEN;\r
+ goto endEntityValue;\r
+ default:\r
+ if (enc == encoding)\r
+ eventPtr = entityTextPtr;\r
+ result = XML_ERROR_UNEXPECTED_STATE;\r
+ goto endEntityValue;\r
+ }\r
+ entityTextPtr = next;\r
+ }\r
+endEntityValue:\r
+#ifdef XML_DTD\r
+ prologState.inEntityValue = oldInEntityValue;\r
+#endif /* XML_DTD */\r
+ return result;\r
+}\r
+\r
+static void FASTCALL\r
+normalizeLines(XML_Char *s)\r
+{\r
+ XML_Char *p;\r
+ for (;; s++) {\r
+ if (*s == XML_T('\0'))\r
+ return;\r
+ if (*s == 0xD)\r
+ break;\r
+ }\r
+ p = s;\r
+ do {\r
+ if (*s == 0xD) {\r
+ *p++ = 0xA;\r
+ if (*++s == 0xA)\r
+ s++;\r
+ }\r
+ else\r
+ *p++ = *s++;\r
+ } while (*s);\r
+ *p = XML_T('\0');\r
+}\r
+\r
+static int\r
+reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,\r
+ const char *start, const char *end)\r
+{\r
+ const XML_Char *target;\r
+ XML_Char *data;\r
+ const char *tem;\r
+ if (!processingInstructionHandler) {\r
+ if (defaultHandler)\r
+ reportDefault(parser, enc, start, end);\r
+ return 1;\r
+ }\r
+ start += enc->minBytesPerChar * 2;\r
+ tem = start + XmlNameLength(enc, start);\r
+ target = poolStoreString(&tempPool, enc, start, tem);\r
+ if (!target)\r
+ return 0;\r
+ poolFinish(&tempPool);\r
+ data = poolStoreString(&tempPool, enc,\r
+ XmlSkipS(enc, tem),\r
+ end - enc->minBytesPerChar*2);\r
+ if (!data)\r
+ return 0;\r
+ normalizeLines(data);\r
+ processingInstructionHandler(handlerArg, target, data);\r
+ poolClear(&tempPool);\r
+ return 1;\r
+}\r
+\r
+static int\r
+reportComment(XML_Parser parser, const ENCODING *enc,\r
+ const char *start, const char *end)\r
+{\r
+ XML_Char *data;\r
+ if (!commentHandler) {\r
+ if (defaultHandler)\r
+ reportDefault(parser, enc, start, end);\r
+ return 1;\r
+ }\r
+ data = poolStoreString(&tempPool,\r
+ enc,\r
+ start + enc->minBytesPerChar * 4,\r
+ end - enc->minBytesPerChar * 3);\r
+ if (!data)\r
+ return 0;\r
+ normalizeLines(data);\r
+ commentHandler(handlerArg, data);\r
+ poolClear(&tempPool);\r
+ return 1;\r
+}\r
+\r
+static void\r
+reportDefault(XML_Parser parser, const ENCODING *enc,\r
+ const char *s, const char *end)\r
+{\r
+ if (MUST_CONVERT(enc, s)) {\r
+ const char **eventPP;\r
+ const char **eventEndPP;\r
+ if (enc == encoding) {\r
+ eventPP = &eventPtr;\r
+ eventEndPP = &eventEndPtr;\r
+ }\r
+ else {\r
+ eventPP = &(openInternalEntities->internalEventPtr);\r
+ eventEndPP = &(openInternalEntities->internalEventEndPtr);\r
+ }\r
+ do {\r
+ ICHAR *dataPtr = (ICHAR *)dataBuf;\r
+ XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);\r
+ *eventEndPP = s;\r
+ defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));\r
+ *eventPP = s;\r
+ } while (s != end);\r
+ }\r
+ else\r
+ defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));\r
+}\r
+\r
+\r
+static int\r
+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,\r
+ XML_Bool isId, const XML_Char *value, XML_Parser parser)\r
+{\r
+ DEFAULT_ATTRIBUTE *att;\r
+ if (value || isId) {\r
+ /* The handling of default attributes gets messed up if we have\r
+ a default which duplicates a non-default. */\r
+ int i;\r
+ for (i = 0; i < type->nDefaultAtts; i++)\r
+ if (attId == type->defaultAtts[i].id)\r
+ return 1;\r
+ if (isId && !type->idAtt && !attId->xmlns)\r
+ type->idAtt = attId;\r
+ }\r
+ if (type->nDefaultAtts == type->allocDefaultAtts) {\r
+ if (type->allocDefaultAtts == 0) {\r
+ type->allocDefaultAtts = 8;\r
+ type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(type->allocDefaultAtts\r
+ * sizeof(DEFAULT_ATTRIBUTE));\r
+ if (!type->defaultAtts)\r
+ return 0;\r
+ }\r
+ else {\r
+ DEFAULT_ATTRIBUTE *temp;\r
+ int count = type->allocDefaultAtts * 2;\r
+ temp = (DEFAULT_ATTRIBUTE *)\r
+ REALLOC(type->defaultAtts, (count * sizeof(DEFAULT_ATTRIBUTE)));\r
+ if (temp == NULL)\r
+ return 0;\r
+ type->allocDefaultAtts = count;\r
+ type->defaultAtts = temp;\r
+ }\r
+ }\r
+ att = type->defaultAtts + type->nDefaultAtts;\r
+ att->id = attId;\r
+ att->value = value;\r
+ att->isCdata = isCdata;\r
+ if (!isCdata)\r
+ attId->maybeTokenized = XML_TRUE;\r
+ type->nDefaultAtts += 1;\r
+ return 1;\r
+}\r
+\r
+static int\r
+setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType)\r
+{\r
+ DTD * const dtd = _dtd; /* save one level of indirection */\r
+ const XML_Char *name;\r
+ for (name = elementType->name; *name; name++) {\r
+ if (*name == XML_T(':')) {\r
+ PREFIX *prefix;\r
+ const XML_Char *s;\r
+ for (s = elementType->name; s != name; s++) {\r
+ if (!poolAppendChar(&dtd->pool, *s))\r
+ return 0;\r
+ }\r
+ if (!poolAppendChar(&dtd->pool, XML_T('\0')))\r
+ return 0;\r
+ prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),\r
+ sizeof(PREFIX));\r
+ if (!prefix)\r
+ return 0;\r
+ if (prefix->name == poolStart(&dtd->pool))\r
+ poolFinish(&dtd->pool);\r
+ else\r
+ poolDiscard(&dtd->pool);\r
+ elementType->prefix = prefix;\r
+\r
+ }\r
+ }\r
+ return 1;\r
+}\r
+\r
+static ATTRIBUTE_ID *\r
+getAttributeId(XML_Parser parser, const ENCODING *enc,\r
+ const char *start, const char *end)\r
+{\r
+ DTD * const dtd = _dtd; /* save one level of indirection */\r
+ ATTRIBUTE_ID *id;\r
+ const XML_Char *name;\r
+ if (!poolAppendChar(&dtd->pool, XML_T('\0')))\r
+ return NULL;\r
+ name = poolStoreString(&dtd->pool, enc, start, end);\r
+ if (!name)\r
+ return NULL;\r
+ /* skip quotation mark - its storage will be re-used (like in name[-1]) */\r
+ ++name;\r
+ id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, name, sizeof(ATTRIBUTE_ID));\r
+ if (!id)\r
+ return NULL;\r
+ if (id->name != name)\r
+ poolDiscard(&dtd->pool);\r
+ else {\r
+ poolFinish(&dtd->pool);\r
+ if (!ns)\r
+ ;\r
+ else if (name[0] == XML_T('x')\r
+ && name[1] == XML_T('m')\r
+ && name[2] == XML_T('l')\r
+ && name[3] == XML_T('n')\r
+ && name[4] == XML_T('s')\r
+ && (name[5] == XML_T('\0') || name[5] == XML_T(':'))) {\r
+ if (name[5] == XML_T('\0'))\r
+ id->prefix = &dtd->defaultPrefix;\r
+ else\r
+ id->prefix = (PREFIX *)lookup(&dtd->prefixes, name + 6, sizeof(PREFIX));\r
+ id->xmlns = XML_TRUE;\r
+ }\r
+ else {\r
+ int i;\r
+ for (i = 0; name[i]; i++) {\r
+ /* attributes without prefix are *not* in the default namespace */\r
+ if (name[i] == XML_T(':')) {\r
+ int j;\r
+ for (j = 0; j < i; j++) {\r
+ if (!poolAppendChar(&dtd->pool, name[j]))\r
+ return NULL;\r
+ }\r
+ if (!poolAppendChar(&dtd->pool, XML_T('\0')))\r
+ return NULL;\r
+ id->prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),\r
+ sizeof(PREFIX));\r
+ if (!id->prefix)\r
+ return NULL;\r
+ if (id->prefix->name == poolStart(&dtd->pool))\r
+ poolFinish(&dtd->pool);\r
+ else\r
+ poolDiscard(&dtd->pool);\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return id;\r
+}\r
+\r
+#define CONTEXT_SEP XML_T('\f')\r
+\r
+static const XML_Char *\r
+getContext(XML_Parser parser)\r
+{\r
+ DTD * const dtd = _dtd; /* save one level of indirection */\r
+ HASH_TABLE_ITER iter;\r
+ XML_Bool needSep = XML_FALSE;\r
+\r
+ if (dtd->defaultPrefix.binding) {\r
+ int i;\r
+ int len;\r
+ if (!poolAppendChar(&tempPool, XML_T('=')))\r
+ return NULL;\r
+ len = dtd->defaultPrefix.binding->uriLen;\r
+ if (namespaceSeparator)\r
+ len--;\r
+ for (i = 0; i < len; i++)\r
+ if (!poolAppendChar(&tempPool, dtd->defaultPrefix.binding->uri[i]))\r
+ return NULL;\r
+ needSep = XML_TRUE;\r
+ }\r
+\r
+ hashTableIterInit(&iter, &(dtd->prefixes));\r
+ for (;;) {\r
+ int i;\r
+ int len;\r
+ const XML_Char *s;\r
+ PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);\r
+ if (!prefix)\r
+ break;\r
+ if (!prefix->binding)\r
+ continue;\r
+ if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))\r
+ return NULL;\r
+ for (s = prefix->name; *s; s++)\r
+ if (!poolAppendChar(&tempPool, *s))\r
+ return NULL;\r
+ if (!poolAppendChar(&tempPool, XML_T('=')))\r
+ return NULL;\r
+ len = prefix->binding->uriLen;\r
+ if (namespaceSeparator)\r
+ len--;\r
+ for (i = 0; i < len; i++)\r
+ if (!poolAppendChar(&tempPool, prefix->binding->uri[i]))\r
+ return NULL;\r
+ needSep = XML_TRUE;\r
+ }\r
+\r
+\r
+ hashTableIterInit(&iter, &(dtd->generalEntities));\r
+ for (;;) {\r
+ const XML_Char *s;\r
+ ENTITY *e = (ENTITY *)hashTableIterNext(&iter);\r
+ if (!e)\r
+ break;\r
+ if (!e->open)\r
+ continue;\r
+ if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))\r
+ return NULL;\r
+ for (s = e->name; *s; s++)\r
+ if (!poolAppendChar(&tempPool, *s))\r
+ return 0;\r
+ needSep = XML_TRUE;\r
+ }\r
+\r
+ if (!poolAppendChar(&tempPool, XML_T('\0')))\r
+ return NULL;\r
+ return tempPool.start;\r
+}\r
+\r
+static XML_Bool\r
+setContext(XML_Parser parser, const XML_Char *context)\r
+{\r
+ DTD * const dtd = _dtd; /* save one level of indirection */\r
+ const XML_Char *s = context;\r
+\r
+ while (*context != XML_T('\0')) {\r
+ if (*s == CONTEXT_SEP || *s == XML_T('\0')) {\r
+ ENTITY *e;\r
+ if (!poolAppendChar(&tempPool, XML_T('\0')))\r
+ return XML_FALSE;\r
+ e = (ENTITY *)lookup(&dtd->generalEntities, poolStart(&tempPool), 0);\r
+ if (e)\r
+ e->open = XML_TRUE;\r
+ if (*s != XML_T('\0'))\r
+ s++;\r
+ context = s;\r
+ poolDiscard(&tempPool);\r
+ }\r
+ else if (*s == XML_T('=')) {\r
+ PREFIX *prefix;\r
+ if (poolLength(&tempPool) == 0)\r
+ prefix = &dtd->defaultPrefix;\r
+ else {\r
+ if (!poolAppendChar(&tempPool, XML_T('\0')))\r
+ return XML_FALSE;\r
+ prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&tempPool),\r
+ sizeof(PREFIX));\r
+ if (!prefix)\r
+ return XML_FALSE;\r
+ if (prefix->name == poolStart(&tempPool)) {\r
+ prefix->name = poolCopyString(&dtd->pool, prefix->name);\r
+ if (!prefix->name)\r
+ return XML_FALSE;\r
+ }\r
+ poolDiscard(&tempPool);\r
+ }\r
+ for (context = s + 1;\r
+ *context != CONTEXT_SEP && *context != XML_T('\0');\r
+ context++)\r
+ if (!poolAppendChar(&tempPool, *context))\r
+ return XML_FALSE;\r
+ if (!poolAppendChar(&tempPool, XML_T('\0')))\r
+ return XML_FALSE;\r
+ if (addBinding(parser, prefix, NULL, poolStart(&tempPool),\r
+ &inheritedBindings) != XML_ERROR_NONE)\r
+ return XML_FALSE;\r
+ poolDiscard(&tempPool);\r
+ if (*context != XML_T('\0'))\r
+ ++context;\r
+ s = context;\r
+ }\r
+ else {\r
+ if (!poolAppendChar(&tempPool, *s))\r
+ return XML_FALSE;\r
+ s++;\r
+ }\r
+ }\r
+ return XML_TRUE;\r
+}\r
+\r
+static void FASTCALL\r
+normalizePublicId(XML_Char *publicId)\r
+{\r
+ XML_Char *p = publicId;\r
+ XML_Char *s;\r
+ for (s = publicId; *s; s++) {\r
+ switch (*s) {\r
+ case 0x20:\r
+ case 0xD:\r
+ case 0xA:\r
+ if (p != publicId && p[-1] != 0x20)\r
+ *p++ = 0x20;\r
+ break;\r
+ default:\r
+ *p++ = *s;\r
+ }\r
+ }\r
+ if (p != publicId && p[-1] == 0x20)\r
+ --p;\r
+ *p = XML_T('\0');\r
+}\r
+\r
+static DTD *\r
+dtdCreate(const XML_Memory_Handling_Suite *ms)\r
+{\r
+ DTD *p = (DTD *)ms->malloc_fcn(sizeof(DTD));\r
+ if (p == NULL)\r
+ return p;\r
+ poolInit(&(p->pool), ms);\r
+ poolInit(&(p->entityValuePool), ms);\r
+ hashTableInit(&(p->generalEntities), ms);\r
+ hashTableInit(&(p->elementTypes), ms);\r
+ hashTableInit(&(p->attributeIds), ms);\r
+ hashTableInit(&(p->prefixes), ms);\r
+#ifdef XML_DTD\r
+ p->paramEntityRead = XML_FALSE;\r
+ hashTableInit(&(p->paramEntities), ms);\r
+#endif /* XML_DTD */\r
+ p->defaultPrefix.name = NULL;\r
+ p->defaultPrefix.binding = NULL;\r
+\r
+ p->in_eldecl = XML_FALSE;\r
+ p->scaffIndex = NULL;\r
+ p->scaffold = NULL;\r
+ p->scaffLevel = 0;\r
+ p->scaffSize = 0;\r
+ p->scaffCount = 0;\r
+ p->contentStringLen = 0;\r
+\r
+ p->keepProcessing = XML_TRUE;\r
+ p->hasParamEntityRefs = XML_FALSE;\r
+ p->standalone = XML_FALSE;\r
+ return p;\r
+}\r
+\r
+static void\r
+dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms)\r
+{\r
+ HASH_TABLE_ITER iter;\r
+ hashTableIterInit(&iter, &(p->elementTypes));\r
+ for (;;) {\r
+ ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);\r
+ if (!e)\r
+ break;\r
+ if (e->allocDefaultAtts != 0)\r
+ ms->free_fcn(e->defaultAtts);\r
+ }\r
+ hashTableClear(&(p->generalEntities));\r
+#ifdef XML_DTD\r
+ p->paramEntityRead = XML_FALSE;\r
+ hashTableClear(&(p->paramEntities));\r
+#endif /* XML_DTD */\r
+ hashTableClear(&(p->elementTypes));\r
+ hashTableClear(&(p->attributeIds));\r
+ hashTableClear(&(p->prefixes));\r
+ poolClear(&(p->pool));\r
+ poolClear(&(p->entityValuePool));\r
+ p->defaultPrefix.name = NULL;\r
+ p->defaultPrefix.binding = NULL;\r
+\r
+ p->in_eldecl = XML_FALSE;\r
+\r
+ ms->free_fcn(p->scaffIndex);\r
+ p->scaffIndex = NULL;\r
+ ms->free_fcn(p->scaffold);\r
+ p->scaffold = NULL;\r
+\r
+ p->scaffLevel = 0;\r
+ p->scaffSize = 0;\r
+ p->scaffCount = 0;\r
+ p->contentStringLen = 0;\r
+\r
+ p->keepProcessing = XML_TRUE;\r
+ p->hasParamEntityRefs = XML_FALSE;\r
+ p->standalone = XML_FALSE;\r
+}\r
+\r
+static void\r
+dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms)\r
+{\r
+ HASH_TABLE_ITER iter;\r
+ hashTableIterInit(&iter, &(p->elementTypes));\r
+ for (;;) {\r
+ ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);\r
+ if (!e)\r
+ break;\r
+ if (e->allocDefaultAtts != 0)\r
+ ms->free_fcn(e->defaultAtts);\r
+ }\r
+ hashTableDestroy(&(p->generalEntities));\r
+#ifdef XML_DTD\r
+ hashTableDestroy(&(p->paramEntities));\r
+#endif /* XML_DTD */\r
+ hashTableDestroy(&(p->elementTypes));\r
+ hashTableDestroy(&(p->attributeIds));\r
+ hashTableDestroy(&(p->prefixes));\r
+ poolDestroy(&(p->pool));\r
+ poolDestroy(&(p->entityValuePool));\r
+ if (isDocEntity) {\r
+ ms->free_fcn(p->scaffIndex);\r
+ ms->free_fcn(p->scaffold);\r
+ }\r
+ ms->free_fcn(p);\r
+}\r
+\r
+/* Do a deep copy of the DTD. Return 0 for out of memory, non-zero otherwise.\r
+ The new DTD has already been initialized.\r
+*/\r
+static int\r
+dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)\r
+{\r
+ HASH_TABLE_ITER iter;\r
+\r
+ /* Copy the prefix table. */\r
+\r
+ hashTableIterInit(&iter, &(oldDtd->prefixes));\r
+ for (;;) {\r
+ const XML_Char *name;\r
+ const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);\r
+ if (!oldP)\r
+ break;\r
+ name = poolCopyString(&(newDtd->pool), oldP->name);\r
+ if (!name)\r
+ return 0;\r
+ if (!lookup(&(newDtd->prefixes), name, sizeof(PREFIX)))\r
+ return 0;\r
+ }\r
+\r
+ hashTableIterInit(&iter, &(oldDtd->attributeIds));\r
+\r
+ /* Copy the attribute id table. */\r
+\r
+ for (;;) {\r
+ ATTRIBUTE_ID *newA;\r
+ const XML_Char *name;\r
+ const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);\r
+\r
+ if (!oldA)\r
+ break;\r
+ /* Remember to allocate the scratch byte before the name. */\r
+ if (!poolAppendChar(&(newDtd->pool), XML_T('\0')))\r
+ return 0;\r
+ name = poolCopyString(&(newDtd->pool), oldA->name);\r
+ if (!name)\r
+ return 0;\r
+ ++name;\r
+ newA = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), name,\r
+ sizeof(ATTRIBUTE_ID));\r
+ if (!newA)\r
+ return 0;\r
+ newA->maybeTokenized = oldA->maybeTokenized;\r
+ if (oldA->prefix) {\r
+ newA->xmlns = oldA->xmlns;\r
+ if (oldA->prefix == &oldDtd->defaultPrefix)\r
+ newA->prefix = &newDtd->defaultPrefix;\r
+ else\r
+ newA->prefix = (PREFIX *)lookup(&(newDtd->prefixes),\r
+ oldA->prefix->name, 0);\r
+ }\r
+ }\r
+\r
+ /* Copy the element type table. */\r
+\r
+ hashTableIterInit(&iter, &(oldDtd->elementTypes));\r
+\r
+ for (;;) {\r
+ int i;\r
+ ELEMENT_TYPE *newE;\r
+ const XML_Char *name;\r
+ const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);\r
+ if (!oldE)\r
+ break;\r
+ name = poolCopyString(&(newDtd->pool), oldE->name);\r
+ if (!name)\r
+ return 0;\r
+ newE = (ELEMENT_TYPE *)lookup(&(newDtd->elementTypes), name,\r
+ sizeof(ELEMENT_TYPE));\r
+ if (!newE)\r
+ return 0;\r
+ if (oldE->nDefaultAtts) {\r
+ newE->defaultAtts = (DEFAULT_ATTRIBUTE *)\r
+ ms->malloc_fcn(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));\r
+ if (!newE->defaultAtts) {\r
+ ms->free_fcn(newE);\r
+ return 0;\r
+ }\r
+ }\r
+ if (oldE->idAtt)\r
+ newE->idAtt = (ATTRIBUTE_ID *)\r
+ lookup(&(newDtd->attributeIds), oldE->idAtt->name, 0);\r
+ newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;\r
+ if (oldE->prefix)\r
+ newE->prefix = (PREFIX *)lookup(&(newDtd->prefixes),\r
+ oldE->prefix->name, 0);\r
+ for (i = 0; i < newE->nDefaultAtts; i++) {\r
+ newE->defaultAtts[i].id = (ATTRIBUTE_ID *)\r
+ lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);\r
+ newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;\r
+ if (oldE->defaultAtts[i].value) {\r
+ newE->defaultAtts[i].value\r
+ = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);\r
+ if (!newE->defaultAtts[i].value)\r
+ return 0;\r
+ }\r
+ else\r
+ newE->defaultAtts[i].value = NULL;\r
+ }\r
+ }\r
+\r
+ /* Copy the entity tables. */\r
+ if (!copyEntityTable(&(newDtd->generalEntities),\r
+ &(newDtd->pool),\r
+ &(oldDtd->generalEntities)))\r
+ return 0;\r
+\r
+#ifdef XML_DTD\r
+ if (!copyEntityTable(&(newDtd->paramEntities),\r
+ &(newDtd->pool),\r
+ &(oldDtd->paramEntities)))\r
+ return 0;\r
+ newDtd->paramEntityRead = oldDtd->paramEntityRead;\r
+#endif /* XML_DTD */\r
+\r
+ newDtd->keepProcessing = oldDtd->keepProcessing;\r
+ newDtd->hasParamEntityRefs = oldDtd->hasParamEntityRefs;\r
+ newDtd->standalone = oldDtd->standalone;\r
+\r
+ /* Don't want deep copying for scaffolding */\r
+ newDtd->in_eldecl = oldDtd->in_eldecl;\r
+ newDtd->scaffold = oldDtd->scaffold;\r
+ newDtd->contentStringLen = oldDtd->contentStringLen;\r
+ newDtd->scaffSize = oldDtd->scaffSize;\r
+ newDtd->scaffLevel = oldDtd->scaffLevel;\r
+ newDtd->scaffIndex = oldDtd->scaffIndex;\r
+\r
+ return 1;\r
+} /* End dtdCopy */\r
+\r
+static int\r
+copyEntityTable(HASH_TABLE *newTable,\r
+ STRING_POOL *newPool,\r
+ const HASH_TABLE *oldTable)\r
+{\r
+ HASH_TABLE_ITER iter;\r
+ const XML_Char *cachedOldBase = NULL;\r
+ const XML_Char *cachedNewBase = NULL;\r
+\r
+ hashTableIterInit(&iter, oldTable);\r
+\r
+ for (;;) {\r
+ ENTITY *newE;\r
+ const XML_Char *name;\r
+ const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);\r
+ if (!oldE)\r
+ break;\r
+ name = poolCopyString(newPool, oldE->name);\r
+ if (!name)\r
+ return 0;\r
+ newE = (ENTITY *)lookup(newTable, name, sizeof(ENTITY));\r
+ if (!newE)\r
+ return 0;\r
+ if (oldE->systemId) {\r
+ const XML_Char *tem = poolCopyString(newPool, oldE->systemId);\r
+ if (!tem)\r
+ return 0;\r
+ newE->systemId = tem;\r
+ if (oldE->base) {\r
+ if (oldE->base == cachedOldBase)\r
+ newE->base = cachedNewBase;\r
+ else {\r
+ cachedOldBase = oldE->base;\r
+ tem = poolCopyString(newPool, cachedOldBase);\r
+ if (!tem)\r
+ return 0;\r
+ cachedNewBase = newE->base = tem;\r
+ }\r
+ }\r
+ if (oldE->publicId) {\r
+ tem = poolCopyString(newPool, oldE->publicId);\r
+ if (!tem)\r
+ return 0;\r
+ newE->publicId = tem;\r
+ }\r
+ }\r
+ else {\r
+ const XML_Char *tem = poolCopyStringN(newPool, oldE->textPtr,\r
+ oldE->textLen);\r
+ if (!tem)\r
+ return 0;\r
+ newE->textPtr = tem;\r
+ newE->textLen = oldE->textLen;\r
+ }\r
+ if (oldE->notation) {\r
+ const XML_Char *tem = poolCopyString(newPool, oldE->notation);\r
+ if (!tem)\r
+ return 0;\r
+ newE->notation = tem;\r
+ }\r
+ newE->is_param = oldE->is_param;\r
+ newE->is_internal = oldE->is_internal;\r
+ }\r
+ return 1;\r
+}\r
+\r
+#define INIT_POWER 6\r
+\r
+static XML_Bool FASTCALL\r
+keyeq(KEY s1, KEY s2)\r
+{\r
+ for (; *s1 == *s2; s1++, s2++)\r
+ if (*s1 == 0)\r
+ return XML_TRUE;\r
+ return XML_FALSE;\r
+}\r
+\r
+static unsigned long FASTCALL\r
+hash(KEY s)\r
+{\r
+ unsigned long h = 0;\r
+ while (*s)\r
+ h = CHAR_HASH(h, *s++);\r
+ return h;\r
+}\r
+\r
+static NAMED *\r
+lookup(HASH_TABLE *table, KEY name, size_t createSize)\r
+{\r
+ size_t i;\r
+ if (table->size == 0) {\r
+ size_t tsize;\r
+ if (!createSize)\r
+ return NULL;\r
+ table->power = INIT_POWER;\r
+ /* table->size is a power of 2 */\r
+ table->size = (size_t)1 << INIT_POWER;\r
+ tsize = table->size * sizeof(NAMED *);\r
+ table->v = (NAMED **)table->mem->malloc_fcn(tsize);\r
+ if (!table->v) {\r
+ table->size = 0;\r
+ return NULL;\r
+ }\r
+ memset(table->v, 0, tsize);\r
+ i = hash(name) & ((unsigned long)table->size - 1);\r
+ }\r
+ else {\r
+ unsigned long h = hash(name);\r
+ unsigned long mask = (unsigned long)table->size - 1;\r
+ unsigned char step = 0;\r
+ i = h & mask;\r
+ while (table->v[i]) {\r
+ if (keyeq(name, table->v[i]->name))\r
+ return table->v[i];\r
+ if (!step)\r
+ step = PROBE_STEP(h, mask, table->power);\r
+ i < step ? (i += table->size - step) : (i -= step);\r
+ }\r
+ if (!createSize)\r
+ return NULL;\r
+\r
+ /* check for overflow (table is half full) */\r
+ if (table->used >> (table->power - 1)) {\r
+ unsigned char newPower = table->power + 1;\r
+ size_t newSize = (size_t)1 << newPower;\r
+ unsigned long newMask = (unsigned long)newSize - 1;\r
+ size_t tsize = newSize * sizeof(NAMED *);\r
+ NAMED **newV = (NAMED **)table->mem->malloc_fcn(tsize);\r
+ if (!newV)\r
+ return NULL;\r
+ memset(newV, 0, tsize);\r
+ for (i = 0; i < table->size; i++)\r
+ if (table->v[i]) {\r
+ unsigned long newHash = hash(table->v[i]->name);\r
+ size_t j = newHash & newMask;\r
+ step = 0;\r
+ while (newV[j]) {\r
+ if (!step)\r
+ step = PROBE_STEP(newHash, newMask, newPower);\r
+ j < step ? (j += newSize - step) : (j -= step);\r
+ }\r
+ newV[j] = table->v[i];\r
+ }\r
+ table->mem->free_fcn(table->v);\r
+ table->v = newV;\r
+ table->power = newPower;\r
+ table->size = newSize;\r
+ i = h & newMask;\r
+ step = 0;\r
+ while (table->v[i]) {\r
+ if (!step)\r
+ step = PROBE_STEP(h, newMask, newPower);\r
+ i < step ? (i += newSize - step) : (i -= step);\r
+ }\r
+ }\r
+ }\r
+ table->v[i] = (NAMED *)table->mem->malloc_fcn(createSize);\r
+ if (!table->v[i])\r
+ return NULL;\r
+ memset(table->v[i], 0, createSize);\r
+ table->v[i]->name = name;\r
+ (table->used)++;\r
+ return table->v[i];\r
+}\r
+\r
+static void FASTCALL\r
+hashTableClear(HASH_TABLE *table)\r
+{\r
+ size_t i;\r
+ for (i = 0; i < table->size; i++) {\r
+ table->mem->free_fcn(table->v[i]);\r
+ table->v[i] = NULL;\r
+ }\r
+ table->used = 0;\r
+}\r
+\r
+static void FASTCALL\r
+hashTableDestroy(HASH_TABLE *table)\r
+{\r
+ size_t i;\r
+ for (i = 0; i < table->size; i++)\r
+ table->mem->free_fcn(table->v[i]);\r
+ table->mem->free_fcn(table->v);\r
+}\r
+\r
+static void FASTCALL\r
+hashTableInit(HASH_TABLE *p, const XML_Memory_Handling_Suite *ms)\r
+{\r
+ p->power = 0;\r
+ p->size = 0;\r
+ p->used = 0;\r
+ p->v = NULL;\r
+ p->mem = ms;\r
+}\r
+\r
+static void FASTCALL\r
+hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table)\r
+{\r
+ iter->p = table->v;\r
+ iter->end = iter->p + table->size;\r
+}\r
+\r
+static NAMED * FASTCALL\r
+hashTableIterNext(HASH_TABLE_ITER *iter)\r
+{\r
+ while (iter->p != iter->end) {\r
+ NAMED *tem = *(iter->p)++;\r
+ if (tem)\r
+ return tem;\r
+ }\r
+ return NULL;\r
+}\r
+\r
+static void FASTCALL\r
+poolInit(STRING_POOL *pool, const XML_Memory_Handling_Suite *ms)\r
+{\r
+ pool->blocks = NULL;\r
+ pool->freeBlocks = NULL;\r
+ pool->start = NULL;\r
+ pool->ptr = NULL;\r
+ pool->end = NULL;\r
+ pool->mem = ms;\r
+}\r
+\r
+static void FASTCALL\r
+poolClear(STRING_POOL *pool)\r
+{\r
+ if (!pool->freeBlocks)\r
+ pool->freeBlocks = pool->blocks;\r
+ else {\r
+ BLOCK *p = pool->blocks;\r
+ while (p) {\r
+ BLOCK *tem = p->next;\r
+ p->next = pool->freeBlocks;\r
+ pool->freeBlocks = p;\r
+ p = tem;\r
+ }\r
+ }\r
+ pool->blocks = NULL;\r
+ pool->start = NULL;\r
+ pool->ptr = NULL;\r
+ pool->end = NULL;\r
+}\r
+\r
+static void FASTCALL\r
+poolDestroy(STRING_POOL *pool)\r
+{\r
+ BLOCK *p = pool->blocks;\r
+ while (p) {\r
+ BLOCK *tem = p->next;\r
+ pool->mem->free_fcn(p);\r
+ p = tem;\r
+ }\r
+ p = pool->freeBlocks;\r
+ while (p) {\r
+ BLOCK *tem = p->next;\r
+ pool->mem->free_fcn(p);\r
+ p = tem;\r
+ }\r
+}\r
+\r
+static XML_Char *\r
+poolAppend(STRING_POOL *pool, const ENCODING *enc,\r
+ const char *ptr, const char *end)\r
+{\r
+ if (!pool->ptr && !poolGrow(pool))\r
+ return NULL;\r
+ for (;;) {\r
+ XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);\r
+ if (ptr == end)\r
+ break;\r
+ if (!poolGrow(pool))\r
+ return NULL;\r
+ }\r
+ return pool->start;\r
+}\r
+\r
+static const XML_Char * FASTCALL\r
+poolCopyString(STRING_POOL *pool, const XML_Char *s)\r
+{\r
+ do {\r
+ if (!poolAppendChar(pool, *s))\r
+ return NULL;\r
+ } while (*s++);\r
+ s = pool->start;\r
+ poolFinish(pool);\r
+ return s;\r
+}\r
+\r
+static const XML_Char *\r
+poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n)\r
+{\r
+ if (!pool->ptr && !poolGrow(pool))\r
+ return NULL;\r
+ for (; n > 0; --n, s++) {\r
+ if (!poolAppendChar(pool, *s))\r
+ return NULL;\r
+ }\r
+ s = pool->start;\r
+ poolFinish(pool);\r
+ return s;\r
+}\r
+\r
+static const XML_Char * FASTCALL\r
+poolAppendString(STRING_POOL *pool, const XML_Char *s)\r
+{\r
+ while (*s) {\r
+ if (!poolAppendChar(pool, *s))\r
+ return NULL;\r
+ s++;\r
+ }\r
+ return pool->start;\r
+}\r
+\r
+static XML_Char *\r
+poolStoreString(STRING_POOL *pool, const ENCODING *enc,\r
+ const char *ptr, const char *end)\r
+{\r
+ if (!poolAppend(pool, enc, ptr, end))\r
+ return NULL;\r
+ if (pool->ptr == pool->end && !poolGrow(pool))\r
+ return NULL;\r
+ *(pool->ptr)++ = 0;\r
+ return pool->start;\r
+}\r
+\r
+static XML_Bool FASTCALL\r
+poolGrow(STRING_POOL *pool)\r
+{\r
+ if (pool->freeBlocks) {\r
+ if (pool->start == 0) {\r
+ pool->blocks = pool->freeBlocks;\r
+ pool->freeBlocks = pool->freeBlocks->next;\r
+ pool->blocks->next = NULL;\r
+ pool->start = pool->blocks->s;\r
+ pool->end = pool->start + pool->blocks->size;\r
+ pool->ptr = pool->start;\r
+ return XML_TRUE;\r
+ }\r
+ if (pool->end - pool->start < pool->freeBlocks->size) {\r
+ BLOCK *tem = pool->freeBlocks->next;\r
+ pool->freeBlocks->next = pool->blocks;\r
+ pool->blocks = pool->freeBlocks;\r
+ pool->freeBlocks = tem;\r
+ memcpy(pool->blocks->s, pool->start,\r
+ (pool->end - pool->start) * sizeof(XML_Char));\r
+ pool->ptr = pool->blocks->s + (pool->ptr - pool->start);\r
+ pool->start = pool->blocks->s;\r
+ pool->end = pool->start + pool->blocks->size;\r
+ return XML_TRUE;\r
+ }\r
+ }\r
+ if (pool->blocks && pool->start == pool->blocks->s) {\r
+ int blockSize = (int)(pool->end - pool->start)*2;\r
+ pool->blocks = (BLOCK *)\r
+ pool->mem->realloc_fcn(pool->blocks,\r
+ (offsetof(BLOCK, s)\r
+ + blockSize * sizeof(XML_Char)));\r
+ if (pool->blocks == NULL)\r
+ return XML_FALSE;\r
+ pool->blocks->size = blockSize;\r
+ pool->ptr = pool->blocks->s + (pool->ptr - pool->start);\r
+ pool->start = pool->blocks->s;\r
+ pool->end = pool->start + blockSize;\r
+ }\r
+ else {\r
+ BLOCK *tem;\r
+ int blockSize = (int)(pool->end - pool->start);\r
+ if (blockSize < INIT_BLOCK_SIZE)\r
+ blockSize = INIT_BLOCK_SIZE;\r
+ else\r
+ blockSize *= 2;\r
+ tem = (BLOCK *)pool->mem->malloc_fcn(offsetof(BLOCK, s)\r
+ + blockSize * sizeof(XML_Char));\r
+ if (!tem)\r
+ return XML_FALSE;\r
+ tem->size = blockSize;\r
+ tem->next = pool->blocks;\r
+ pool->blocks = tem;\r
+ if (pool->ptr != pool->start)\r
+ memcpy(tem->s, pool->start,\r
+ (pool->ptr - pool->start) * sizeof(XML_Char));\r
+ pool->ptr = tem->s + (pool->ptr - pool->start);\r
+ pool->start = tem->s;\r
+ pool->end = tem->s + blockSize;\r
+ }\r
+ return XML_TRUE;\r
+}\r
+\r
+static int FASTCALL\r
+nextScaffoldPart(XML_Parser parser)\r
+{\r
+ DTD * const dtd = _dtd; /* save one level of indirection */\r
+ CONTENT_SCAFFOLD * me;\r
+ int next;\r
+\r
+ if (!dtd->scaffIndex) {\r
+ dtd->scaffIndex = (int *)MALLOC(groupSize * sizeof(int));\r
+ if (!dtd->scaffIndex)\r
+ return -1;\r
+ dtd->scaffIndex[0] = 0;\r
+ }\r
+\r
+ if (dtd->scaffCount >= dtd->scaffSize) {\r
+ CONTENT_SCAFFOLD *temp;\r
+ if (dtd->scaffold) {\r
+ temp = (CONTENT_SCAFFOLD *)\r
+ REALLOC(dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));\r
+ if (temp == NULL)\r
+ return -1;\r
+ dtd->scaffSize *= 2;\r
+ }\r
+ else {\r
+ temp = (CONTENT_SCAFFOLD *)MALLOC(INIT_SCAFFOLD_ELEMENTS\r
+ * sizeof(CONTENT_SCAFFOLD));\r
+ if (temp == NULL)\r
+ return -1;\r
+ dtd->scaffSize = INIT_SCAFFOLD_ELEMENTS;\r
+ }\r
+ dtd->scaffold = temp;\r
+ }\r
+ next = dtd->scaffCount++;\r
+ me = &dtd->scaffold[next];\r
+ if (dtd->scaffLevel) {\r
+ CONTENT_SCAFFOLD *parent = &dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel-1]];\r
+ if (parent->lastchild) {\r
+ dtd->scaffold[parent->lastchild].nextsib = next;\r
+ }\r
+ if (!parent->childcnt)\r
+ parent->firstchild = next;\r
+ parent->lastchild = next;\r
+ parent->childcnt++;\r
+ }\r
+ me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;\r
+ return next;\r
+}\r
+\r
+static void\r
+build_node(XML_Parser parser,\r
+ int src_node,\r
+ XML_Content *dest,\r
+ XML_Content **contpos,\r
+ XML_Char **strpos)\r
+{\r
+ DTD * const dtd = _dtd; /* save one level of indirection */\r
+ dest->type = dtd->scaffold[src_node].type;\r
+ dest->quant = dtd->scaffold[src_node].quant;\r
+ if (dest->type == XML_CTYPE_NAME) {\r
+ const XML_Char *src;\r
+ dest->name = *strpos;\r
+ src = dtd->scaffold[src_node].name;\r
+ for (;;) {\r
+ *(*strpos)++ = *src;\r
+ if (!*src)\r
+ break;\r
+ src++;\r
+ }\r
+ dest->numchildren = 0;\r
+ dest->children = NULL;\r
+ }\r
+ else {\r
+ unsigned int i;\r
+ int cn;\r
+ dest->numchildren = dtd->scaffold[src_node].childcnt;\r
+ dest->children = *contpos;\r
+ *contpos += dest->numchildren;\r
+ for (i = 0, cn = dtd->scaffold[src_node].firstchild;\r
+ i < dest->numchildren;\r
+ i++, cn = dtd->scaffold[cn].nextsib) {\r
+ build_node(parser, cn, &(dest->children[i]), contpos, strpos);\r
+ }\r
+ dest->name = NULL;\r
+ }\r
+}\r
+\r
+static XML_Content *\r
+build_model (XML_Parser parser)\r
+{\r
+ DTD * const dtd = _dtd; /* save one level of indirection */\r
+ XML_Content *ret;\r
+ XML_Content *cpos;\r
+ XML_Char * str;\r
+ int allocsize = (dtd->scaffCount * sizeof(XML_Content)\r
+ + (dtd->contentStringLen * sizeof(XML_Char)));\r
+\r
+ ret = (XML_Content *)MALLOC(allocsize);\r
+ if (!ret)\r
+ return NULL;\r
+\r
+ str = (XML_Char *) (&ret[dtd->scaffCount]);\r
+ cpos = &ret[1];\r
+\r
+ build_node(parser, 0, ret, &cpos, &str);\r
+ return ret;\r
+}\r
+\r
+static ELEMENT_TYPE *\r
+getElementType(XML_Parser parser,\r
+ const ENCODING *enc,\r
+ const char *ptr,\r
+ const char *end)\r
+{\r
+ DTD * const dtd = _dtd; /* save one level of indirection */\r
+ const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end);\r
+ ELEMENT_TYPE *ret;\r
+\r
+ if (!name)\r
+ return NULL;\r
+ ret = (ELEMENT_TYPE *) lookup(&dtd->elementTypes, name, sizeof(ELEMENT_TYPE));\r
+ if (!ret)\r
+ return NULL;\r
+ if (ret->name != name)\r
+ poolDiscard(&dtd->pool);\r
+ else {\r
+ poolFinish(&dtd->pool);\r
+ if (!setElementTypePrefix(parser, ret))\r
+ return NULL;\r
+ }\r
+ return ret;\r
+}\r
projects / mirror_edk2.git / commitdiff