Annotation of embedaddon/expat/lib/xmlparse.c, revision 1.1.1.1

1.1       misho       1: /* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
                      2:    See the file COPYING for copying permission.
                      3: */
                      4: 
                      5: #include <stddef.h>
                      6: #include <string.h>                     /* memset(), memcpy() */
                      7: #include <assert.h>
                      8: 
                      9: #define XML_BUILDING_EXPAT 1
                     10: 
                     11: #ifdef COMPILED_FROM_DSP
                     12: #include "winconfig.h"
                     13: #elif defined(MACOS_CLASSIC)
                     14: #include "macconfig.h"
                     15: #elif defined(__amigaos4__)
                     16: #include "amigaconfig.h"
                     17: #elif defined(__WATCOMC__)
                     18: #include "watcomconfig.h"
                     19: #elif defined(HAVE_EXPAT_CONFIG_H)
                     20: #include <expat_config.h>
                     21: #endif /* ndef COMPILED_FROM_DSP */
                     22: 
                     23: #include "ascii.h"
                     24: #include "expat.h"
                     25: 
                     26: #ifdef XML_UNICODE
                     27: #define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
                     28: #define XmlConvert XmlUtf16Convert
                     29: #define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
                     30: #define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
                     31: #define XmlEncode XmlUtf16Encode
                     32: /* Using pointer subtraction to convert to integer type. */
                     33: #define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((char *)(s) - (char *)NULL) & 1))
                     34: typedef unsigned short ICHAR;
                     35: #else
                     36: #define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
                     37: #define XmlConvert XmlUtf8Convert
                     38: #define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
                     39: #define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
                     40: #define XmlEncode XmlUtf8Encode
                     41: #define MUST_CONVERT(enc, s) (!(enc)->isUtf8)
                     42: typedef char ICHAR;
                     43: #endif
                     44: 
                     45: 
                     46: #ifndef XML_NS
                     47: 
                     48: #define XmlInitEncodingNS XmlInitEncoding
                     49: #define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
                     50: #undef XmlGetInternalEncodingNS
                     51: #define XmlGetInternalEncodingNS XmlGetInternalEncoding
                     52: #define XmlParseXmlDeclNS XmlParseXmlDecl
                     53: 
                     54: #endif
                     55: 
                     56: #ifdef XML_UNICODE
                     57: 
                     58: #ifdef XML_UNICODE_WCHAR_T
                     59: #define XML_T(x) (const wchar_t)x
                     60: #define XML_L(x) L ## x
                     61: #else
                     62: #define XML_T(x) (const unsigned short)x
                     63: #define XML_L(x) x
                     64: #endif
                     65: 
                     66: #else
                     67: 
                     68: #define XML_T(x) x
                     69: #define XML_L(x) x
                     70: 
                     71: #endif
                     72: 
                     73: /* Round up n to be a multiple of sz, where sz is a power of 2. */
                     74: #define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1))
                     75: 
                     76: /* Handle the case where memmove() doesn't exist. */
                     77: #ifndef HAVE_MEMMOVE
                     78: #ifdef HAVE_BCOPY
                     79: #define memmove(d,s,l) bcopy((s),(d),(l))
                     80: #else
                     81: #error memmove does not exist on this platform, nor is a substitute available
                     82: #endif /* HAVE_BCOPY */
                     83: #endif /* HAVE_MEMMOVE */
                     84: 
                     85: #include "internal.h"
                     86: #include "xmltok.h"
                     87: #include "xmlrole.h"
                     88: 
                     89: typedef const XML_Char *KEY;
                     90: 
                     91: typedef struct {
                     92:   KEY name;
                     93: } NAMED;
                     94: 
                     95: typedef struct {
                     96:   NAMED **v;
                     97:   unsigned char power;
                     98:   size_t size;
                     99:   size_t used;
                    100:   const XML_Memory_Handling_Suite *mem;
                    101: } HASH_TABLE;
                    102: 
                    103: /* Basic character hash algorithm, taken from Python's string hash:
                    104:    h = h * 1000003 ^ character, the constant being a prime number.
                    105: 
                    106: */
                    107: #ifdef XML_UNICODE
                    108: #define CHAR_HASH(h, c) \
                    109:   (((h) * 0xF4243) ^ (unsigned short)(c))
                    110: #else
                    111: #define CHAR_HASH(h, c) \
                    112:   (((h) * 0xF4243) ^ (unsigned char)(c))
                    113: #endif
                    114: 
                    115: /* For probing (after a collision) we need a step size relative prime
                    116:    to the hash table size, which is a power of 2. We use double-hashing,
                    117:    since we can calculate a second hash value cheaply by taking those bits
                    118:    of the first hash value that were discarded (masked out) when the table
                    119:    index was calculated: index = hash & mask, where mask = table->size - 1.
                    120:    We limit the maximum step size to table->size / 4 (mask >> 2) and make
                    121:    it odd, since odd numbers are always relative prime to a power of 2.
                    122: */
                    123: #define SECOND_HASH(hash, mask, power) \
                    124:   ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2))
                    125: #define PROBE_STEP(hash, mask, power) \
                    126:   ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))
                    127: 
                    128: typedef struct {
                    129:   NAMED **p;
                    130:   NAMED **end;
                    131: } HASH_TABLE_ITER;
                    132: 
                    133: #define INIT_TAG_BUF_SIZE 32  /* must be a multiple of sizeof(XML_Char) */
                    134: #define INIT_DATA_BUF_SIZE 1024
                    135: #define INIT_ATTS_SIZE 16
                    136: #define INIT_ATTS_VERSION 0xFFFFFFFF
                    137: #define INIT_BLOCK_SIZE 1024
                    138: #define INIT_BUFFER_SIZE 1024
                    139: 
                    140: #define EXPAND_SPARE 24
                    141: 
                    142: typedef struct binding {
                    143:   struct prefix *prefix;
                    144:   struct binding *nextTagBinding;
                    145:   struct binding *prevPrefixBinding;
                    146:   const struct attribute_id *attId;
                    147:   XML_Char *uri;
                    148:   int uriLen;
                    149:   int uriAlloc;
                    150: } BINDING;
                    151: 
                    152: typedef struct prefix {
                    153:   const XML_Char *name;
                    154:   BINDING *binding;
                    155: } PREFIX;
                    156: 
                    157: typedef struct {
                    158:   const XML_Char *str;
                    159:   const XML_Char *localPart;
                    160:   const XML_Char *prefix;
                    161:   int strLen;
                    162:   int uriLen;
                    163:   int prefixLen;
                    164: } TAG_NAME;
                    165: 
                    166: /* TAG represents an open element.
                    167:    The name of the element is stored in both the document and API
                    168:    encodings.  The memory buffer 'buf' is a separately-allocated
                    169:    memory area which stores the name.  During the XML_Parse()/
                    170:    XMLParseBuffer() when the element is open, the memory for the 'raw'
                    171:    version of the name (in the document encoding) is shared with the
                    172:    document buffer.  If the element is open across calls to
                    173:    XML_Parse()/XML_ParseBuffer(), the buffer is re-allocated to
                    174:    contain the 'raw' name as well.
                    175: 
                    176:    A parser re-uses these structures, maintaining a list of allocated
                    177:    TAG objects in a free list.
                    178: */
                    179: typedef struct tag {
                    180:   struct tag *parent;           /* parent of this element */
                    181:   const char *rawName;          /* tagName in the original encoding */
                    182:   int rawNameLength;
                    183:   TAG_NAME name;                /* tagName in the API encoding */
                    184:   char *buf;                    /* buffer for name components */
                    185:   char *bufEnd;                 /* end of the buffer */
                    186:   BINDING *bindings;
                    187: } TAG;
                    188: 
                    189: typedef struct {
                    190:   const XML_Char *name;
                    191:   const XML_Char *textPtr;
                    192:   int textLen;                  /* length in XML_Chars */
                    193:   int processed;                /* # of processed bytes - when suspended */
                    194:   const XML_Char *systemId;
                    195:   const XML_Char *base;
                    196:   const XML_Char *publicId;
                    197:   const XML_Char *notation;
                    198:   XML_Bool open;
                    199:   XML_Bool is_param;
                    200:   XML_Bool is_internal; /* true if declared in internal subset outside PE */
                    201: } ENTITY;
                    202: 
                    203: typedef struct {
                    204:   enum XML_Content_Type         type;
                    205:   enum XML_Content_Quant        quant;
                    206:   const XML_Char *              name;
                    207:   int                           firstchild;
                    208:   int                           lastchild;
                    209:   int                           childcnt;
                    210:   int                           nextsib;
                    211: } CONTENT_SCAFFOLD;
                    212: 
                    213: #define INIT_SCAFFOLD_ELEMENTS 32
                    214: 
                    215: typedef struct block {
                    216:   struct block *next;
                    217:   int size;
                    218:   XML_Char s[1];
                    219: } BLOCK;
                    220: 
                    221: typedef struct {
                    222:   BLOCK *blocks;
                    223:   BLOCK *freeBlocks;
                    224:   const XML_Char *end;
                    225:   XML_Char *ptr;
                    226:   XML_Char *start;
                    227:   const XML_Memory_Handling_Suite *mem;
                    228: } STRING_POOL;
                    229: 
                    230: /* The XML_Char before the name is used to determine whether
                    231:    an attribute has been specified. */
                    232: typedef struct attribute_id {
                    233:   XML_Char *name;
                    234:   PREFIX *prefix;
                    235:   XML_Bool maybeTokenized;
                    236:   XML_Bool xmlns;
                    237: } ATTRIBUTE_ID;
                    238: 
                    239: typedef struct {
                    240:   const ATTRIBUTE_ID *id;
                    241:   XML_Bool isCdata;
                    242:   const XML_Char *value;
                    243: } DEFAULT_ATTRIBUTE;
                    244: 
                    245: typedef struct {
                    246:   unsigned long version;
                    247:   unsigned long hash;
                    248:   const XML_Char *uriName;
                    249: } NS_ATT;
                    250: 
                    251: typedef struct {
                    252:   const XML_Char *name;
                    253:   PREFIX *prefix;
                    254:   const ATTRIBUTE_ID *idAtt;
                    255:   int nDefaultAtts;
                    256:   int allocDefaultAtts;
                    257:   DEFAULT_ATTRIBUTE *defaultAtts;
                    258: } ELEMENT_TYPE;
                    259: 
                    260: typedef struct {
                    261:   HASH_TABLE generalEntities;
                    262:   HASH_TABLE elementTypes;
                    263:   HASH_TABLE attributeIds;
                    264:   HASH_TABLE prefixes;
                    265:   STRING_POOL pool;
                    266:   STRING_POOL entityValuePool;
                    267:   /* false once a parameter entity reference has been skipped */
                    268:   XML_Bool keepProcessing;
                    269:   /* true once an internal or external PE reference has been encountered;
                    270:      this includes the reference to an external subset */
                    271:   XML_Bool hasParamEntityRefs;
                    272:   XML_Bool standalone;
                    273: #ifdef XML_DTD
                    274:   /* indicates if external PE has been read */
                    275:   XML_Bool paramEntityRead;
                    276:   HASH_TABLE paramEntities;
                    277: #endif /* XML_DTD */
                    278:   PREFIX defaultPrefix;
                    279:   /* === scaffolding for building content model === */
                    280:   XML_Bool in_eldecl;
                    281:   CONTENT_SCAFFOLD *scaffold;
                    282:   unsigned contentStringLen;
                    283:   unsigned scaffSize;
                    284:   unsigned scaffCount;
                    285:   int scaffLevel;
                    286:   int *scaffIndex;
                    287: } DTD;
                    288: 
                    289: typedef struct open_internal_entity {
                    290:   const char *internalEventPtr;
                    291:   const char *internalEventEndPtr;
                    292:   struct open_internal_entity *next;
                    293:   ENTITY *entity;
                    294:   int startTagLevel;
                    295:   XML_Bool betweenDecl; /* WFC: PE Between Declarations */
                    296: } OPEN_INTERNAL_ENTITY;
                    297: 
                    298: typedef enum XML_Error PTRCALL Processor(XML_Parser parser,
                    299:                                          const char *start,
                    300:                                          const char *end,
                    301:                                          const char **endPtr);
                    302: 
                    303: static Processor prologProcessor;
                    304: static Processor prologInitProcessor;
                    305: static Processor contentProcessor;
                    306: static Processor cdataSectionProcessor;
                    307: #ifdef XML_DTD
                    308: static Processor ignoreSectionProcessor;
                    309: static Processor externalParEntProcessor;
                    310: static Processor externalParEntInitProcessor;
                    311: static Processor entityValueProcessor;
                    312: static Processor entityValueInitProcessor;
                    313: #endif /* XML_DTD */
                    314: static Processor epilogProcessor;
                    315: static Processor errorProcessor;
                    316: static Processor externalEntityInitProcessor;
                    317: static Processor externalEntityInitProcessor2;
                    318: static Processor externalEntityInitProcessor3;
                    319: static Processor externalEntityContentProcessor;
                    320: static Processor internalEntityProcessor;
                    321: 
                    322: static enum XML_Error
                    323: handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);
                    324: static enum XML_Error
                    325: processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
                    326:                const char *s, const char *next);
                    327: static enum XML_Error
                    328: initializeEncoding(XML_Parser parser);
                    329: static enum XML_Error
                    330: doProlog(XML_Parser parser, const ENCODING *enc, const char *s, 
                    331:          const char *end, int tok, const char *next, const char **nextPtr, 
                    332:          XML_Bool haveMore);
                    333: static enum XML_Error
                    334: processInternalEntity(XML_Parser parser, ENTITY *entity, 
                    335:                       XML_Bool betweenDecl);
                    336: static enum XML_Error
                    337: doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
                    338:           const char *start, const char *end, const char **endPtr, 
                    339:           XML_Bool haveMore);
                    340: static enum XML_Error
                    341: doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr,
                    342:                const char *end, const char **nextPtr, XML_Bool haveMore);
                    343: #ifdef XML_DTD
                    344: static enum XML_Error
                    345: doIgnoreSection(XML_Parser parser, const ENCODING *, const char **startPtr,
                    346:                 const char *end, const char **nextPtr, XML_Bool haveMore);
                    347: #endif /* XML_DTD */
                    348: 
                    349: static enum XML_Error
                    350: storeAtts(XML_Parser parser, const ENCODING *, const char *s,
                    351:           TAG_NAME *tagNamePtr, BINDING **bindingsPtr);
                    352: static enum XML_Error
                    353: addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
                    354:            const XML_Char *uri, BINDING **bindingsPtr);
                    355: static int
                    356: defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata, 
                    357:                 XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser);
                    358: static enum XML_Error
                    359: storeAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,
                    360:                     const char *, const char *, STRING_POOL *);
                    361: static enum XML_Error
                    362: appendAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,
                    363:                      const char *, const char *, STRING_POOL *);
                    364: static ATTRIBUTE_ID *
                    365: getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,
                    366:                const char *end);
                    367: static int
                    368: setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
                    369: static enum XML_Error
                    370: storeEntityValue(XML_Parser parser, const ENCODING *enc, const char *start,
                    371:                  const char *end);
                    372: static int
                    373: reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
                    374:                             const char *start, const char *end);
                    375: static int
                    376: reportComment(XML_Parser parser, const ENCODING *enc, const char *start,
                    377:               const char *end);
                    378: static void
                    379: reportDefault(XML_Parser parser, const ENCODING *enc, const char *start,
                    380:               const char *end);
                    381: 
                    382: static const XML_Char * getContext(XML_Parser parser);
                    383: static XML_Bool
                    384: setContext(XML_Parser parser, const XML_Char *context);
                    385: 
                    386: static void FASTCALL normalizePublicId(XML_Char *s);
                    387: 
                    388: static DTD * dtdCreate(const XML_Memory_Handling_Suite *ms);
                    389: /* do not call if parentParser != NULL */
                    390: static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms);
                    391: static void
                    392: dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms);
                    393: static int
                    394: dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms);
                    395: static int
                    396: copyEntityTable(HASH_TABLE *, STRING_POOL *, const HASH_TABLE *);
                    397: 
                    398: static NAMED *
                    399: lookup(HASH_TABLE *table, KEY name, size_t createSize);
                    400: static void FASTCALL
                    401: hashTableInit(HASH_TABLE *, const XML_Memory_Handling_Suite *ms);
                    402: static void FASTCALL hashTableClear(HASH_TABLE *);
                    403: static void FASTCALL hashTableDestroy(HASH_TABLE *);
                    404: static void FASTCALL
                    405: hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);
                    406: static NAMED * FASTCALL hashTableIterNext(HASH_TABLE_ITER *);
                    407: 
                    408: static void FASTCALL
                    409: poolInit(STRING_POOL *, const XML_Memory_Handling_Suite *ms);
                    410: static void FASTCALL poolClear(STRING_POOL *);
                    411: static void FASTCALL poolDestroy(STRING_POOL *);
                    412: static XML_Char *
                    413: poolAppend(STRING_POOL *pool, const ENCODING *enc,
                    414:            const char *ptr, const char *end);
                    415: static XML_Char *
                    416: poolStoreString(STRING_POOL *pool, const ENCODING *enc,
                    417:                 const char *ptr, const char *end);
                    418: static XML_Bool FASTCALL poolGrow(STRING_POOL *pool);
                    419: static const XML_Char * FASTCALL
                    420: poolCopyString(STRING_POOL *pool, const XML_Char *s);
                    421: static const XML_Char *
                    422: poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n);
                    423: static const XML_Char * FASTCALL
                    424: poolAppendString(STRING_POOL *pool, const XML_Char *s);
                    425: 
                    426: static int FASTCALL nextScaffoldPart(XML_Parser parser);
                    427: static XML_Content * build_model(XML_Parser parser);
                    428: static ELEMENT_TYPE *
                    429: getElementType(XML_Parser parser, const ENCODING *enc,
                    430:                const char *ptr, const char *end);
                    431: 
                    432: static XML_Parser
                    433: parserCreate(const XML_Char *encodingName,
                    434:              const XML_Memory_Handling_Suite *memsuite,
                    435:              const XML_Char *nameSep,
                    436:              DTD *dtd);
                    437: static void
                    438: parserInit(XML_Parser parser, const XML_Char *encodingName);
                    439: 
                    440: #define poolStart(pool) ((pool)->start)
                    441: #define poolEnd(pool) ((pool)->ptr)
                    442: #define poolLength(pool) ((pool)->ptr - (pool)->start)
                    443: #define poolChop(pool) ((void)--(pool->ptr))
                    444: #define poolLastChar(pool) (((pool)->ptr)[-1])
                    445: #define poolDiscard(pool) ((pool)->ptr = (pool)->start)
                    446: #define poolFinish(pool) ((pool)->start = (pool)->ptr)
                    447: #define poolAppendChar(pool, c) \
                    448:   (((pool)->ptr == (pool)->end && !poolGrow(pool)) \
                    449:    ? 0 \
                    450:    : ((*((pool)->ptr)++ = c), 1))
                    451: 
                    452: struct XML_ParserStruct {
                    453:   /* The first member must be userData so that the XML_GetUserData
                    454:      macro works. */
                    455:   void *m_userData;
                    456:   void *m_handlerArg;
                    457:   char *m_buffer;
                    458:   const XML_Memory_Handling_Suite m_mem;
                    459:   /* first character to be parsed */
                    460:   const char *m_bufferPtr;
                    461:   /* past last character to be parsed */
                    462:   char *m_bufferEnd;
                    463:   /* allocated end of buffer */
                    464:   const char *m_bufferLim;
                    465:   XML_Index m_parseEndByteIndex;
                    466:   const char *m_parseEndPtr;
                    467:   XML_Char *m_dataBuf;
                    468:   XML_Char *m_dataBufEnd;
                    469:   XML_StartElementHandler m_startElementHandler;
                    470:   XML_EndElementHandler m_endElementHandler;
                    471:   XML_CharacterDataHandler m_characterDataHandler;
                    472:   XML_ProcessingInstructionHandler m_processingInstructionHandler;
                    473:   XML_CommentHandler m_commentHandler;
                    474:   XML_StartCdataSectionHandler m_startCdataSectionHandler;
                    475:   XML_EndCdataSectionHandler m_endCdataSectionHandler;
                    476:   XML_DefaultHandler m_defaultHandler;
                    477:   XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;
                    478:   XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;
                    479:   XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;
                    480:   XML_NotationDeclHandler m_notationDeclHandler;
                    481:   XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;
                    482:   XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;
                    483:   XML_NotStandaloneHandler m_notStandaloneHandler;
                    484:   XML_ExternalEntityRefHandler m_externalEntityRefHandler;
                    485:   XML_Parser m_externalEntityRefHandlerArg;
                    486:   XML_SkippedEntityHandler m_skippedEntityHandler;
                    487:   XML_UnknownEncodingHandler m_unknownEncodingHandler;
                    488:   XML_ElementDeclHandler m_elementDeclHandler;
                    489:   XML_AttlistDeclHandler m_attlistDeclHandler;
                    490:   XML_EntityDeclHandler m_entityDeclHandler;
                    491:   XML_XmlDeclHandler m_xmlDeclHandler;
                    492:   const ENCODING *m_encoding;
                    493:   INIT_ENCODING m_initEncoding;
                    494:   const ENCODING *m_internalEncoding;
                    495:   const XML_Char *m_protocolEncodingName;
                    496:   XML_Bool m_ns;
                    497:   XML_Bool m_ns_triplets;
                    498:   void *m_unknownEncodingMem;
                    499:   void *m_unknownEncodingData;
                    500:   void *m_unknownEncodingHandlerData;
                    501:   void (XMLCALL *m_unknownEncodingRelease)(void *);
                    502:   PROLOG_STATE m_prologState;
                    503:   Processor *m_processor;
                    504:   enum XML_Error m_errorCode;
                    505:   const char *m_eventPtr;
                    506:   const char *m_eventEndPtr;
                    507:   const char *m_positionPtr;
                    508:   OPEN_INTERNAL_ENTITY *m_openInternalEntities;
                    509:   OPEN_INTERNAL_ENTITY *m_freeInternalEntities;
                    510:   XML_Bool m_defaultExpandInternalEntities;
                    511:   int m_tagLevel;
                    512:   ENTITY *m_declEntity;
                    513:   const XML_Char *m_doctypeName;
                    514:   const XML_Char *m_doctypeSysid;
                    515:   const XML_Char *m_doctypePubid;
                    516:   const XML_Char *m_declAttributeType;
                    517:   const XML_Char *m_declNotationName;
                    518:   const XML_Char *m_declNotationPublicId;
                    519:   ELEMENT_TYPE *m_declElementType;
                    520:   ATTRIBUTE_ID *m_declAttributeId;
                    521:   XML_Bool m_declAttributeIsCdata;
                    522:   XML_Bool m_declAttributeIsId;
                    523:   DTD *m_dtd;
                    524:   const XML_Char *m_curBase;
                    525:   TAG *m_tagStack;
                    526:   TAG *m_freeTagList;
                    527:   BINDING *m_inheritedBindings;
                    528:   BINDING *m_freeBindingList;
                    529:   int m_attsSize;
                    530:   int m_nSpecifiedAtts;
                    531:   int m_idAttIndex;
                    532:   ATTRIBUTE *m_atts;
                    533:   NS_ATT *m_nsAtts;
                    534:   unsigned long m_nsAttsVersion;
                    535:   unsigned char m_nsAttsPower;
                    536:   POSITION m_position;
                    537:   STRING_POOL m_tempPool;
                    538:   STRING_POOL m_temp2Pool;
                    539:   char *m_groupConnector;
                    540:   unsigned int m_groupSize;
                    541:   XML_Char m_namespaceSeparator;
                    542:   XML_Parser m_parentParser;
                    543:   XML_ParsingStatus m_parsingStatus;
                    544: #ifdef XML_DTD
                    545:   XML_Bool m_isParamEntity;
                    546:   XML_Bool m_useForeignDTD;
                    547:   enum XML_ParamEntityParsing m_paramEntityParsing;
                    548: #endif
                    549: };
                    550: 
                    551: #define MALLOC(s) (parser->m_mem.malloc_fcn((s)))
                    552: #define REALLOC(p,s) (parser->m_mem.realloc_fcn((p),(s)))
                    553: #define FREE(p) (parser->m_mem.free_fcn((p)))
                    554: 
                    555: #define userData (parser->m_userData)
                    556: #define handlerArg (parser->m_handlerArg)
                    557: #define startElementHandler (parser->m_startElementHandler)
                    558: #define endElementHandler (parser->m_endElementHandler)
                    559: #define characterDataHandler (parser->m_characterDataHandler)
                    560: #define processingInstructionHandler \
                    561:         (parser->m_processingInstructionHandler)
                    562: #define commentHandler (parser->m_commentHandler)
                    563: #define startCdataSectionHandler \
                    564:         (parser->m_startCdataSectionHandler)
                    565: #define endCdataSectionHandler (parser->m_endCdataSectionHandler)
                    566: #define defaultHandler (parser->m_defaultHandler)
                    567: #define startDoctypeDeclHandler (parser->m_startDoctypeDeclHandler)
                    568: #define endDoctypeDeclHandler (parser->m_endDoctypeDeclHandler)
                    569: #define unparsedEntityDeclHandler \
                    570:         (parser->m_unparsedEntityDeclHandler)
                    571: #define notationDeclHandler (parser->m_notationDeclHandler)
                    572: #define startNamespaceDeclHandler \
                    573:         (parser->m_startNamespaceDeclHandler)
                    574: #define endNamespaceDeclHandler (parser->m_endNamespaceDeclHandler)
                    575: #define notStandaloneHandler (parser->m_notStandaloneHandler)
                    576: #define externalEntityRefHandler \
                    577:         (parser->m_externalEntityRefHandler)
                    578: #define externalEntityRefHandlerArg \
                    579:         (parser->m_externalEntityRefHandlerArg)
                    580: #define internalEntityRefHandler \
                    581:         (parser->m_internalEntityRefHandler)
                    582: #define skippedEntityHandler (parser->m_skippedEntityHandler)
                    583: #define unknownEncodingHandler (parser->m_unknownEncodingHandler)
                    584: #define elementDeclHandler (parser->m_elementDeclHandler)
                    585: #define attlistDeclHandler (parser->m_attlistDeclHandler)
                    586: #define entityDeclHandler (parser->m_entityDeclHandler)
                    587: #define xmlDeclHandler (parser->m_xmlDeclHandler)
                    588: #define encoding (parser->m_encoding)
                    589: #define initEncoding (parser->m_initEncoding)
                    590: #define internalEncoding (parser->m_internalEncoding)
                    591: #define unknownEncodingMem (parser->m_unknownEncodingMem)
                    592: #define unknownEncodingData (parser->m_unknownEncodingData)
                    593: #define unknownEncodingHandlerData \
                    594:   (parser->m_unknownEncodingHandlerData)
                    595: #define unknownEncodingRelease (parser->m_unknownEncodingRelease)
                    596: #define protocolEncodingName (parser->m_protocolEncodingName)
                    597: #define ns (parser->m_ns)
                    598: #define ns_triplets (parser->m_ns_triplets)
                    599: #define prologState (parser->m_prologState)
                    600: #define processor (parser->m_processor)
                    601: #define errorCode (parser->m_errorCode)
                    602: #define eventPtr (parser->m_eventPtr)
                    603: #define eventEndPtr (parser->m_eventEndPtr)
                    604: #define positionPtr (parser->m_positionPtr)
                    605: #define position (parser->m_position)
                    606: #define openInternalEntities (parser->m_openInternalEntities)
                    607: #define freeInternalEntities (parser->m_freeInternalEntities)
                    608: #define defaultExpandInternalEntities \
                    609:         (parser->m_defaultExpandInternalEntities)
                    610: #define tagLevel (parser->m_tagLevel)
                    611: #define buffer (parser->m_buffer)
                    612: #define bufferPtr (parser->m_bufferPtr)
                    613: #define bufferEnd (parser->m_bufferEnd)
                    614: #define parseEndByteIndex (parser->m_parseEndByteIndex)
                    615: #define parseEndPtr (parser->m_parseEndPtr)
                    616: #define bufferLim (parser->m_bufferLim)
                    617: #define dataBuf (parser->m_dataBuf)
                    618: #define dataBufEnd (parser->m_dataBufEnd)
                    619: #define _dtd (parser->m_dtd)
                    620: #define curBase (parser->m_curBase)
                    621: #define declEntity (parser->m_declEntity)
                    622: #define doctypeName (parser->m_doctypeName)
                    623: #define doctypeSysid (parser->m_doctypeSysid)
                    624: #define doctypePubid (parser->m_doctypePubid)
                    625: #define declAttributeType (parser->m_declAttributeType)
                    626: #define declNotationName (parser->m_declNotationName)
                    627: #define declNotationPublicId (parser->m_declNotationPublicId)
                    628: #define declElementType (parser->m_declElementType)
                    629: #define declAttributeId (parser->m_declAttributeId)
                    630: #define declAttributeIsCdata (parser->m_declAttributeIsCdata)
                    631: #define declAttributeIsId (parser->m_declAttributeIsId)
                    632: #define freeTagList (parser->m_freeTagList)
                    633: #define freeBindingList (parser->m_freeBindingList)
                    634: #define inheritedBindings (parser->m_inheritedBindings)
                    635: #define tagStack (parser->m_tagStack)
                    636: #define atts (parser->m_atts)
                    637: #define attsSize (parser->m_attsSize)
                    638: #define nSpecifiedAtts (parser->m_nSpecifiedAtts)
                    639: #define idAttIndex (parser->m_idAttIndex)
                    640: #define nsAtts (parser->m_nsAtts)
                    641: #define nsAttsVersion (parser->m_nsAttsVersion)
                    642: #define nsAttsPower (parser->m_nsAttsPower)
                    643: #define tempPool (parser->m_tempPool)
                    644: #define temp2Pool (parser->m_temp2Pool)
                    645: #define groupConnector (parser->m_groupConnector)
                    646: #define groupSize (parser->m_groupSize)
                    647: #define namespaceSeparator (parser->m_namespaceSeparator)
                    648: #define parentParser (parser->m_parentParser)
                    649: #define ps_parsing (parser->m_parsingStatus.parsing)
                    650: #define ps_finalBuffer (parser->m_parsingStatus.finalBuffer)
                    651: #ifdef XML_DTD
                    652: #define isParamEntity (parser->m_isParamEntity)
                    653: #define useForeignDTD (parser->m_useForeignDTD)
                    654: #define paramEntityParsing (parser->m_paramEntityParsing)
                    655: #endif /* XML_DTD */
                    656: 
                    657: XML_Parser XMLCALL
                    658: XML_ParserCreate(const XML_Char *encodingName)
                    659: {
                    660:   return XML_ParserCreate_MM(encodingName, NULL, NULL);
                    661: }
                    662: 
                    663: XML_Parser XMLCALL
                    664: XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)
                    665: {
                    666:   XML_Char tmp[2];
                    667:   *tmp = nsSep;
                    668:   return XML_ParserCreate_MM(encodingName, NULL, tmp);
                    669: }
                    670: 
                    671: static const XML_Char implicitContext[] = {
                    672:   ASCII_x, ASCII_m, ASCII_l, ASCII_EQUALS, ASCII_h, ASCII_t, ASCII_t, ASCII_p,
                    673:   ASCII_COLON, ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, 
                    674:   ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g,
                    675:   ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9,
                    676:   ASCII_9, ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ASCII_e,
                    677:   ASCII_s, ASCII_p, ASCII_a, ASCII_c, ASCII_e, '\0'
                    678: };
                    679: 
                    680: XML_Parser XMLCALL
                    681: XML_ParserCreate_MM(const XML_Char *encodingName,
                    682:                     const XML_Memory_Handling_Suite *memsuite,
                    683:                     const XML_Char *nameSep)
                    684: {
                    685:   XML_Parser parser = parserCreate(encodingName, memsuite, nameSep, NULL);
                    686:   if (parser != NULL && ns) {
                    687:     /* implicit context only set for root parser, since child
                    688:        parsers (i.e. external entity parsers) will inherit it
                    689:     */
                    690:     if (!setContext(parser, implicitContext)) {
                    691:       XML_ParserFree(parser);
                    692:       return NULL;
                    693:     }
                    694:   }
                    695:   return parser;
                    696: }
                    697: 
                    698: static XML_Parser
                    699: parserCreate(const XML_Char *encodingName,
                    700:              const XML_Memory_Handling_Suite *memsuite,
                    701:              const XML_Char *nameSep,
                    702:              DTD *dtd)
                    703: {
                    704:   XML_Parser parser;
                    705: 
                    706:   if (memsuite) {
                    707:     XML_Memory_Handling_Suite *mtemp;
                    708:     parser = (XML_Parser)
                    709:       memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));
                    710:     if (parser != NULL) {
                    711:       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
                    712:       mtemp->malloc_fcn = memsuite->malloc_fcn;
                    713:       mtemp->realloc_fcn = memsuite->realloc_fcn;
                    714:       mtemp->free_fcn = memsuite->free_fcn;
                    715:     }
                    716:   }
                    717:   else {
                    718:     XML_Memory_Handling_Suite *mtemp;
                    719:     parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));
                    720:     if (parser != NULL) {
                    721:       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
                    722:       mtemp->malloc_fcn = malloc;
                    723:       mtemp->realloc_fcn = realloc;
                    724:       mtemp->free_fcn = free;
                    725:     }
                    726:   }
                    727: 
                    728:   if (!parser)
                    729:     return parser;
                    730: 
                    731:   buffer = NULL;
                    732:   bufferLim = NULL;
                    733: 
                    734:   attsSize = INIT_ATTS_SIZE;
                    735:   atts = (ATTRIBUTE *)MALLOC(attsSize * sizeof(ATTRIBUTE));
                    736:   if (atts == NULL) {
                    737:     FREE(parser);
                    738:     return NULL;
                    739:   }
                    740:   dataBuf = (XML_Char *)MALLOC(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
                    741:   if (dataBuf == NULL) {
                    742:     FREE(atts);
                    743:     FREE(parser);
                    744:     return NULL;
                    745:   }
                    746:   dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;
                    747: 
                    748:   if (dtd)
                    749:     _dtd = dtd;
                    750:   else {
                    751:     _dtd = dtdCreate(&parser->m_mem);
                    752:     if (_dtd == NULL) {
                    753:       FREE(dataBuf);
                    754:       FREE(atts);
                    755:       FREE(parser);
                    756:       return NULL;
                    757:     }
                    758:   }
                    759: 
                    760:   freeBindingList = NULL;
                    761:   freeTagList = NULL;
                    762:   freeInternalEntities = NULL;
                    763: 
                    764:   groupSize = 0;
                    765:   groupConnector = NULL;
                    766: 
                    767:   unknownEncodingHandler = NULL;
                    768:   unknownEncodingHandlerData = NULL;
                    769: 
                    770:   namespaceSeparator = ASCII_EXCL;
                    771:   ns = XML_FALSE;
                    772:   ns_triplets = XML_FALSE;
                    773: 
                    774:   nsAtts = NULL;
                    775:   nsAttsVersion = 0;
                    776:   nsAttsPower = 0;
                    777: 
                    778:   poolInit(&tempPool, &(parser->m_mem));
                    779:   poolInit(&temp2Pool, &(parser->m_mem));
                    780:   parserInit(parser, encodingName);
                    781: 
                    782:   if (encodingName && !protocolEncodingName) {
                    783:     XML_ParserFree(parser);
                    784:     return NULL;
                    785:   }
                    786: 
                    787:   if (nameSep) {
                    788:     ns = XML_TRUE;
                    789:     internalEncoding = XmlGetInternalEncodingNS();
                    790:     namespaceSeparator = *nameSep;
                    791:   }
                    792:   else {
                    793:     internalEncoding = XmlGetInternalEncoding();
                    794:   }
                    795: 
                    796:   return parser;
                    797: }
                    798: 
                    799: static void
                    800: parserInit(XML_Parser parser, const XML_Char *encodingName)
                    801: {
                    802:   processor = prologInitProcessor;
                    803:   XmlPrologStateInit(&prologState);
                    804:   protocolEncodingName = (encodingName != NULL
                    805:                           ? poolCopyString(&tempPool, encodingName)
                    806:                           : NULL);
                    807:   curBase = NULL;
                    808:   XmlInitEncoding(&initEncoding, &encoding, 0);
                    809:   userData = NULL;
                    810:   handlerArg = NULL;
                    811:   startElementHandler = NULL;
                    812:   endElementHandler = NULL;
                    813:   characterDataHandler = NULL;
                    814:   processingInstructionHandler = NULL;
                    815:   commentHandler = NULL;
                    816:   startCdataSectionHandler = NULL;
                    817:   endCdataSectionHandler = NULL;
                    818:   defaultHandler = NULL;
                    819:   startDoctypeDeclHandler = NULL;
                    820:   endDoctypeDeclHandler = NULL;
                    821:   unparsedEntityDeclHandler = NULL;
                    822:   notationDeclHandler = NULL;
                    823:   startNamespaceDeclHandler = NULL;
                    824:   endNamespaceDeclHandler = NULL;
                    825:   notStandaloneHandler = NULL;
                    826:   externalEntityRefHandler = NULL;
                    827:   externalEntityRefHandlerArg = parser;
                    828:   skippedEntityHandler = NULL;
                    829:   elementDeclHandler = NULL;
                    830:   attlistDeclHandler = NULL;
                    831:   entityDeclHandler = NULL;
                    832:   xmlDeclHandler = NULL;
                    833:   bufferPtr = buffer;
                    834:   bufferEnd = buffer;
                    835:   parseEndByteIndex = 0;
                    836:   parseEndPtr = NULL;
                    837:   declElementType = NULL;
                    838:   declAttributeId = NULL;
                    839:   declEntity = NULL;
                    840:   doctypeName = NULL;
                    841:   doctypeSysid = NULL;
                    842:   doctypePubid = NULL;
                    843:   declAttributeType = NULL;
                    844:   declNotationName = NULL;
                    845:   declNotationPublicId = NULL;
                    846:   declAttributeIsCdata = XML_FALSE;
                    847:   declAttributeIsId = XML_FALSE;
                    848:   memset(&position, 0, sizeof(POSITION));
                    849:   errorCode = XML_ERROR_NONE;
                    850:   eventPtr = NULL;
                    851:   eventEndPtr = NULL;
                    852:   positionPtr = NULL;
                    853:   openInternalEntities = NULL;
                    854:   defaultExpandInternalEntities = XML_TRUE;
                    855:   tagLevel = 0;
                    856:   tagStack = NULL;
                    857:   inheritedBindings = NULL;
                    858:   nSpecifiedAtts = 0;
                    859:   unknownEncodingMem = NULL;
                    860:   unknownEncodingRelease = NULL;
                    861:   unknownEncodingData = NULL;
                    862:   parentParser = NULL;
                    863:   ps_parsing = XML_INITIALIZED;
                    864: #ifdef XML_DTD
                    865:   isParamEntity = XML_FALSE;
                    866:   useForeignDTD = XML_FALSE;
                    867:   paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
                    868: #endif
                    869: }
                    870: 
                    871: /* moves list of bindings to freeBindingList */
                    872: static void FASTCALL
                    873: moveToFreeBindingList(XML_Parser parser, BINDING *bindings)
                    874: {
                    875:   while (bindings) {
                    876:     BINDING *b = bindings;
                    877:     bindings = bindings->nextTagBinding;
                    878:     b->nextTagBinding = freeBindingList;
                    879:     freeBindingList = b;
                    880:   }
                    881: }
                    882: 
                    883: XML_Bool XMLCALL
                    884: XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)
                    885: {
                    886:   TAG *tStk;
                    887:   OPEN_INTERNAL_ENTITY *openEntityList;
                    888:   if (parentParser)
                    889:     return XML_FALSE;
                    890:   /* move tagStack to freeTagList */
                    891:   tStk = tagStack;
                    892:   while (tStk) {
                    893:     TAG *tag = tStk;
                    894:     tStk = tStk->parent;
                    895:     tag->parent = freeTagList;
                    896:     moveToFreeBindingList(parser, tag->bindings);
                    897:     tag->bindings = NULL;
                    898:     freeTagList = tag;
                    899:   }
                    900:   /* move openInternalEntities to freeInternalEntities */
                    901:   openEntityList = openInternalEntities;
                    902:   while (openEntityList) {
                    903:     OPEN_INTERNAL_ENTITY *openEntity = openEntityList;
                    904:     openEntityList = openEntity->next;
                    905:     openEntity->next = freeInternalEntities;
                    906:     freeInternalEntities = openEntity;
                    907:   }
                    908:   moveToFreeBindingList(parser, inheritedBindings);
                    909:   FREE(unknownEncodingMem);
                    910:   if (unknownEncodingRelease)
                    911:     unknownEncodingRelease(unknownEncodingData);
                    912:   poolClear(&tempPool);
                    913:   poolClear(&temp2Pool);
                    914:   parserInit(parser, encodingName);
                    915:   dtdReset(_dtd, &parser->m_mem);
                    916:   return setContext(parser, implicitContext);
                    917: }
                    918: 
                    919: enum XML_Status XMLCALL
                    920: XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)
                    921: {
                    922:   /* Block after XML_Parse()/XML_ParseBuffer() has been called.
                    923:      XXX There's no way for the caller to determine which of the
                    924:      XXX possible error cases caused the XML_STATUS_ERROR return.
                    925:   */
                    926:   if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
                    927:     return XML_STATUS_ERROR;
                    928:   if (encodingName == NULL)
                    929:     protocolEncodingName = NULL;
                    930:   else {
                    931:     protocolEncodingName = poolCopyString(&tempPool, encodingName);
                    932:     if (!protocolEncodingName)
                    933:       return XML_STATUS_ERROR;
                    934:   }
                    935:   return XML_STATUS_OK;
                    936: }
                    937: 
                    938: XML_Parser XMLCALL
                    939: XML_ExternalEntityParserCreate(XML_Parser oldParser,
                    940:                                const XML_Char *context,
                    941:                                const XML_Char *encodingName)
                    942: {
                    943:   XML_Parser parser = oldParser;
                    944:   DTD *newDtd = NULL;
                    945:   DTD *oldDtd = _dtd;
                    946:   XML_StartElementHandler oldStartElementHandler = startElementHandler;
                    947:   XML_EndElementHandler oldEndElementHandler = endElementHandler;
                    948:   XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;
                    949:   XML_ProcessingInstructionHandler oldProcessingInstructionHandler
                    950:       = processingInstructionHandler;
                    951:   XML_CommentHandler oldCommentHandler = commentHandler;
                    952:   XML_StartCdataSectionHandler oldStartCdataSectionHandler
                    953:       = startCdataSectionHandler;
                    954:   XML_EndCdataSectionHandler oldEndCdataSectionHandler
                    955:       = endCdataSectionHandler;
                    956:   XML_DefaultHandler oldDefaultHandler = defaultHandler;
                    957:   XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler
                    958:       = unparsedEntityDeclHandler;
                    959:   XML_NotationDeclHandler oldNotationDeclHandler = notationDeclHandler;
                    960:   XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler
                    961:       = startNamespaceDeclHandler;
                    962:   XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler
                    963:       = endNamespaceDeclHandler;
                    964:   XML_NotStandaloneHandler oldNotStandaloneHandler = notStandaloneHandler;
                    965:   XML_ExternalEntityRefHandler oldExternalEntityRefHandler
                    966:       = externalEntityRefHandler;
                    967:   XML_SkippedEntityHandler oldSkippedEntityHandler = skippedEntityHandler;
                    968:   XML_UnknownEncodingHandler oldUnknownEncodingHandler
                    969:       = unknownEncodingHandler;
                    970:   XML_ElementDeclHandler oldElementDeclHandler = elementDeclHandler;
                    971:   XML_AttlistDeclHandler oldAttlistDeclHandler = attlistDeclHandler;
                    972:   XML_EntityDeclHandler oldEntityDeclHandler = entityDeclHandler;
                    973:   XML_XmlDeclHandler oldXmlDeclHandler = xmlDeclHandler;
                    974:   ELEMENT_TYPE * oldDeclElementType = declElementType;
                    975: 
                    976:   void *oldUserData = userData;
                    977:   void *oldHandlerArg = handlerArg;
                    978:   XML_Bool oldDefaultExpandInternalEntities = defaultExpandInternalEntities;
                    979:   XML_Parser oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;
                    980: #ifdef XML_DTD
                    981:   enum XML_ParamEntityParsing oldParamEntityParsing = paramEntityParsing;
                    982:   int oldInEntityValue = prologState.inEntityValue;
                    983: #endif
                    984:   XML_Bool oldns_triplets = ns_triplets;
                    985: 
                    986: #ifdef XML_DTD
                    987:   if (!context)
                    988:     newDtd = oldDtd;
                    989: #endif /* XML_DTD */
                    990: 
                    991:   /* Note that the magical uses of the pre-processor to make field
                    992:      access look more like C++ require that `parser' be overwritten
                    993:      here.  This makes this function more painful to follow than it
                    994:      would be otherwise.
                    995:   */
                    996:   if (ns) {
                    997:     XML_Char tmp[2];
                    998:     *tmp = namespaceSeparator;
                    999:     parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);
                   1000:   }
                   1001:   else {
                   1002:     parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);
                   1003:   }
                   1004: 
                   1005:   if (!parser)
                   1006:     return NULL;
                   1007: 
                   1008:   startElementHandler = oldStartElementHandler;
                   1009:   endElementHandler = oldEndElementHandler;
                   1010:   characterDataHandler = oldCharacterDataHandler;
                   1011:   processingInstructionHandler = oldProcessingInstructionHandler;
                   1012:   commentHandler = oldCommentHandler;
                   1013:   startCdataSectionHandler = oldStartCdataSectionHandler;
                   1014:   endCdataSectionHandler = oldEndCdataSectionHandler;
                   1015:   defaultHandler = oldDefaultHandler;
                   1016:   unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;
                   1017:   notationDeclHandler = oldNotationDeclHandler;
                   1018:   startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
                   1019:   endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
                   1020:   notStandaloneHandler = oldNotStandaloneHandler;
                   1021:   externalEntityRefHandler = oldExternalEntityRefHandler;
                   1022:   skippedEntityHandler = oldSkippedEntityHandler;
                   1023:   unknownEncodingHandler = oldUnknownEncodingHandler;
                   1024:   elementDeclHandler = oldElementDeclHandler;
                   1025:   attlistDeclHandler = oldAttlistDeclHandler;
                   1026:   entityDeclHandler = oldEntityDeclHandler;
                   1027:   xmlDeclHandler = oldXmlDeclHandler;
                   1028:   declElementType = oldDeclElementType;
                   1029:   userData = oldUserData;
                   1030:   if (oldUserData == oldHandlerArg)
                   1031:     handlerArg = userData;
                   1032:   else
                   1033:     handlerArg = parser;
                   1034:   if (oldExternalEntityRefHandlerArg != oldParser)
                   1035:     externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
                   1036:   defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
                   1037:   ns_triplets = oldns_triplets;
                   1038:   parentParser = oldParser;
                   1039: #ifdef XML_DTD
                   1040:   paramEntityParsing = oldParamEntityParsing;
                   1041:   prologState.inEntityValue = oldInEntityValue;
                   1042:   if (context) {
                   1043: #endif /* XML_DTD */
                   1044:     if (!dtdCopy(_dtd, oldDtd, &parser->m_mem)
                   1045:       || !setContext(parser, context)) {
                   1046:       XML_ParserFree(parser);
                   1047:       return NULL;
                   1048:     }
                   1049:     processor = externalEntityInitProcessor;
                   1050: #ifdef XML_DTD
                   1051:   }
                   1052:   else {
                   1053:     /* The DTD instance referenced by _dtd is shared between the document's
                   1054:        root parser and external PE parsers, therefore one does not need to
                   1055:        call setContext. In addition, one also *must* not call setContext,
                   1056:        because this would overwrite existing prefix->binding pointers in
                   1057:        _dtd with ones that get destroyed with the external PE parser.
                   1058:        This would leave those prefixes with dangling pointers.
                   1059:     */
                   1060:     isParamEntity = XML_TRUE;
                   1061:     XmlPrologStateInitExternalEntity(&prologState);
                   1062:     processor = externalParEntInitProcessor;
                   1063:   }
                   1064: #endif /* XML_DTD */
                   1065:   return parser;
                   1066: }
                   1067: 
                   1068: static void FASTCALL
                   1069: destroyBindings(BINDING *bindings, XML_Parser parser)
                   1070: {
                   1071:   for (;;) {
                   1072:     BINDING *b = bindings;
                   1073:     if (!b)
                   1074:       break;
                   1075:     bindings = b->nextTagBinding;
                   1076:     FREE(b->uri);
                   1077:     FREE(b);
                   1078:   }
                   1079: }
                   1080: 
                   1081: void XMLCALL
                   1082: XML_ParserFree(XML_Parser parser)
                   1083: {
                   1084:   TAG *tagList;
                   1085:   OPEN_INTERNAL_ENTITY *entityList;
                   1086:   if (parser == NULL)
                   1087:     return;
                   1088:   /* free tagStack and freeTagList */
                   1089:   tagList = tagStack;
                   1090:   for (;;) {
                   1091:     TAG *p;
                   1092:     if (tagList == NULL) {
                   1093:       if (freeTagList == NULL)
                   1094:         break;
                   1095:       tagList = freeTagList;
                   1096:       freeTagList = NULL;
                   1097:     }
                   1098:     p = tagList;
                   1099:     tagList = tagList->parent;
                   1100:     FREE(p->buf);
                   1101:     destroyBindings(p->bindings, parser);
                   1102:     FREE(p);
                   1103:   }
                   1104:   /* free openInternalEntities and freeInternalEntities */
                   1105:   entityList = openInternalEntities;
                   1106:   for (;;) {
                   1107:     OPEN_INTERNAL_ENTITY *openEntity;
                   1108:     if (entityList == NULL) {
                   1109:       if (freeInternalEntities == NULL)
                   1110:         break;
                   1111:       entityList = freeInternalEntities;
                   1112:       freeInternalEntities = NULL;
                   1113:     }
                   1114:     openEntity = entityList;
                   1115:     entityList = entityList->next;
                   1116:     FREE(openEntity);
                   1117:   }
                   1118: 
                   1119:   destroyBindings(freeBindingList, parser);
                   1120:   destroyBindings(inheritedBindings, parser);
                   1121:   poolDestroy(&tempPool);
                   1122:   poolDestroy(&temp2Pool);
                   1123: #ifdef XML_DTD
                   1124:   /* external parameter entity parsers share the DTD structure
                   1125:      parser->m_dtd with the root parser, so we must not destroy it
                   1126:   */
                   1127:   if (!isParamEntity && _dtd)
                   1128: #else
                   1129:   if (_dtd)
                   1130: #endif /* XML_DTD */
                   1131:     dtdDestroy(_dtd, (XML_Bool)!parentParser, &parser->m_mem);
                   1132:   FREE((void *)atts);
                   1133:   FREE(groupConnector);
                   1134:   FREE(buffer);
                   1135:   FREE(dataBuf);
                   1136:   FREE(nsAtts);
                   1137:   FREE(unknownEncodingMem);
                   1138:   if (unknownEncodingRelease)
                   1139:     unknownEncodingRelease(unknownEncodingData);
                   1140:   FREE(parser);
                   1141: }
                   1142: 
                   1143: void XMLCALL
                   1144: XML_UseParserAsHandlerArg(XML_Parser parser)
                   1145: {
                   1146:   handlerArg = parser;
                   1147: }
                   1148: 
                   1149: enum XML_Error XMLCALL
                   1150: XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD)
                   1151: {
                   1152: #ifdef XML_DTD
                   1153:   /* block after XML_Parse()/XML_ParseBuffer() has been called */
                   1154:   if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
                   1155:     return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;
                   1156:   useForeignDTD = useDTD;
                   1157:   return XML_ERROR_NONE;
                   1158: #else
                   1159:   return XML_ERROR_FEATURE_REQUIRES_XML_DTD;
                   1160: #endif
                   1161: }
                   1162: 
                   1163: void XMLCALL
                   1164: XML_SetReturnNSTriplet(XML_Parser parser, int do_nst)
                   1165: {
                   1166:   /* block after XML_Parse()/XML_ParseBuffer() has been called */
                   1167:   if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
                   1168:     return;
                   1169:   ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
                   1170: }
                   1171: 
                   1172: void XMLCALL
                   1173: XML_SetUserData(XML_Parser parser, void *p)
                   1174: {
                   1175:   if (handlerArg == userData)
                   1176:     handlerArg = userData = p;
                   1177:   else
                   1178:     userData = p;
                   1179: }
                   1180: 
                   1181: enum XML_Status XMLCALL
                   1182: XML_SetBase(XML_Parser parser, const XML_Char *p)
                   1183: {
                   1184:   if (p) {
                   1185:     p = poolCopyString(&_dtd->pool, p);
                   1186:     if (!p)
                   1187:       return XML_STATUS_ERROR;
                   1188:     curBase = p;
                   1189:   }
                   1190:   else
                   1191:     curBase = NULL;
                   1192:   return XML_STATUS_OK;
                   1193: }
                   1194: 
                   1195: const XML_Char * XMLCALL
                   1196: XML_GetBase(XML_Parser parser)
                   1197: {
                   1198:   return curBase;
                   1199: }
                   1200: 
                   1201: int XMLCALL
                   1202: XML_GetSpecifiedAttributeCount(XML_Parser parser)
                   1203: {
                   1204:   return nSpecifiedAtts;
                   1205: }
                   1206: 
                   1207: int XMLCALL
                   1208: XML_GetIdAttributeIndex(XML_Parser parser)
                   1209: {
                   1210:   return idAttIndex;
                   1211: }
                   1212: 
                   1213: void XMLCALL
                   1214: XML_SetElementHandler(XML_Parser parser,
                   1215:                       XML_StartElementHandler start,
                   1216:                       XML_EndElementHandler end)
                   1217: {
                   1218:   startElementHandler = start;
                   1219:   endElementHandler = end;
                   1220: }
                   1221: 
                   1222: void XMLCALL
                   1223: XML_SetStartElementHandler(XML_Parser parser,
                   1224:                            XML_StartElementHandler start) {
                   1225:   startElementHandler = start;
                   1226: }
                   1227: 
                   1228: void XMLCALL
                   1229: XML_SetEndElementHandler(XML_Parser parser,
                   1230:                          XML_EndElementHandler end) {
                   1231:   endElementHandler = end;
                   1232: }
                   1233: 
                   1234: void XMLCALL
                   1235: XML_SetCharacterDataHandler(XML_Parser parser,
                   1236:                             XML_CharacterDataHandler handler)
                   1237: {
                   1238:   characterDataHandler = handler;
                   1239: }
                   1240: 
                   1241: void XMLCALL
                   1242: XML_SetProcessingInstructionHandler(XML_Parser parser,
                   1243:                                     XML_ProcessingInstructionHandler handler)
                   1244: {
                   1245:   processingInstructionHandler = handler;
                   1246: }
                   1247: 
                   1248: void XMLCALL
                   1249: XML_SetCommentHandler(XML_Parser parser,
                   1250:                       XML_CommentHandler handler)
                   1251: {
                   1252:   commentHandler = handler;
                   1253: }
                   1254: 
                   1255: void XMLCALL
                   1256: XML_SetCdataSectionHandler(XML_Parser parser,
                   1257:                            XML_StartCdataSectionHandler start,
                   1258:                            XML_EndCdataSectionHandler end)
                   1259: {
                   1260:   startCdataSectionHandler = start;
                   1261:   endCdataSectionHandler = end;
                   1262: }
                   1263: 
                   1264: void XMLCALL
                   1265: XML_SetStartCdataSectionHandler(XML_Parser parser,
                   1266:                                 XML_StartCdataSectionHandler start) {
                   1267:   startCdataSectionHandler = start;
                   1268: }
                   1269: 
                   1270: void XMLCALL
                   1271: XML_SetEndCdataSectionHandler(XML_Parser parser,
                   1272:                               XML_EndCdataSectionHandler end) {
                   1273:   endCdataSectionHandler = end;
                   1274: }
                   1275: 
                   1276: void XMLCALL
                   1277: XML_SetDefaultHandler(XML_Parser parser,
                   1278:                       XML_DefaultHandler handler)
                   1279: {
                   1280:   defaultHandler = handler;
                   1281:   defaultExpandInternalEntities = XML_FALSE;
                   1282: }
                   1283: 
                   1284: void XMLCALL
                   1285: XML_SetDefaultHandlerExpand(XML_Parser parser,
                   1286:                             XML_DefaultHandler handler)
                   1287: {
                   1288:   defaultHandler = handler;
                   1289:   defaultExpandInternalEntities = XML_TRUE;
                   1290: }
                   1291: 
                   1292: void XMLCALL
                   1293: XML_SetDoctypeDeclHandler(XML_Parser parser,
                   1294:                           XML_StartDoctypeDeclHandler start,
                   1295:                           XML_EndDoctypeDeclHandler end)
                   1296: {
                   1297:   startDoctypeDeclHandler = start;
                   1298:   endDoctypeDeclHandler = end;
                   1299: }
                   1300: 
                   1301: void XMLCALL
                   1302: XML_SetStartDoctypeDeclHandler(XML_Parser parser,
                   1303:                                XML_StartDoctypeDeclHandler start) {
                   1304:   startDoctypeDeclHandler = start;
                   1305: }
                   1306: 
                   1307: void XMLCALL
                   1308: XML_SetEndDoctypeDeclHandler(XML_Parser parser,
                   1309:                              XML_EndDoctypeDeclHandler end) {
                   1310:   endDoctypeDeclHandler = end;
                   1311: }
                   1312: 
                   1313: void XMLCALL
                   1314: XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
                   1315:                                  XML_UnparsedEntityDeclHandler handler)
                   1316: {
                   1317:   unparsedEntityDeclHandler = handler;
                   1318: }
                   1319: 
                   1320: void XMLCALL
                   1321: XML_SetNotationDeclHandler(XML_Parser parser,
                   1322:                            XML_NotationDeclHandler handler)
                   1323: {
                   1324:   notationDeclHandler = handler;
                   1325: }
                   1326: 
                   1327: void XMLCALL
                   1328: XML_SetNamespaceDeclHandler(XML_Parser parser,
                   1329:                             XML_StartNamespaceDeclHandler start,
                   1330:                             XML_EndNamespaceDeclHandler end)
                   1331: {
                   1332:   startNamespaceDeclHandler = start;
                   1333:   endNamespaceDeclHandler = end;
                   1334: }
                   1335: 
                   1336: void XMLCALL
                   1337: XML_SetStartNamespaceDeclHandler(XML_Parser parser,
                   1338:                                  XML_StartNamespaceDeclHandler start) {
                   1339:   startNamespaceDeclHandler = start;
                   1340: }
                   1341: 
                   1342: void XMLCALL
                   1343: XML_SetEndNamespaceDeclHandler(XML_Parser parser,
                   1344:                                XML_EndNamespaceDeclHandler end) {
                   1345:   endNamespaceDeclHandler = end;
                   1346: }
                   1347: 
                   1348: void XMLCALL
                   1349: XML_SetNotStandaloneHandler(XML_Parser parser,
                   1350:                             XML_NotStandaloneHandler handler)
                   1351: {
                   1352:   notStandaloneHandler = handler;
                   1353: }
                   1354: 
                   1355: void XMLCALL
                   1356: XML_SetExternalEntityRefHandler(XML_Parser parser,
                   1357:                                 XML_ExternalEntityRefHandler handler)
                   1358: {
                   1359:   externalEntityRefHandler = handler;
                   1360: }
                   1361: 
                   1362: void XMLCALL
                   1363: XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg)
                   1364: {
                   1365:   if (arg)
                   1366:     externalEntityRefHandlerArg = (XML_Parser)arg;
                   1367:   else
                   1368:     externalEntityRefHandlerArg = parser;
                   1369: }
                   1370: 
                   1371: void XMLCALL
                   1372: XML_SetSkippedEntityHandler(XML_Parser parser,
                   1373:                             XML_SkippedEntityHandler handler)
                   1374: {
                   1375:   skippedEntityHandler = handler;
                   1376: }
                   1377: 
                   1378: void XMLCALL
                   1379: XML_SetUnknownEncodingHandler(XML_Parser parser,
                   1380:                               XML_UnknownEncodingHandler handler,
                   1381:                               void *data)
                   1382: {
                   1383:   unknownEncodingHandler = handler;
                   1384:   unknownEncodingHandlerData = data;
                   1385: }
                   1386: 
                   1387: void XMLCALL
                   1388: XML_SetElementDeclHandler(XML_Parser parser,
                   1389:                           XML_ElementDeclHandler eldecl)
                   1390: {
                   1391:   elementDeclHandler = eldecl;
                   1392: }
                   1393: 
                   1394: void XMLCALL
                   1395: XML_SetAttlistDeclHandler(XML_Parser parser,
                   1396:                           XML_AttlistDeclHandler attdecl)
                   1397: {
                   1398:   attlistDeclHandler = attdecl;
                   1399: }
                   1400: 
                   1401: void XMLCALL
                   1402: XML_SetEntityDeclHandler(XML_Parser parser,
                   1403:                          XML_EntityDeclHandler handler)
                   1404: {
                   1405:   entityDeclHandler = handler;
                   1406: }
                   1407: 
                   1408: void XMLCALL
                   1409: XML_SetXmlDeclHandler(XML_Parser parser,
                   1410:                       XML_XmlDeclHandler handler) {
                   1411:   xmlDeclHandler = handler;
                   1412: }
                   1413: 
                   1414: int XMLCALL
                   1415: XML_SetParamEntityParsing(XML_Parser parser,
                   1416:                           enum XML_ParamEntityParsing peParsing)
                   1417: {
                   1418:   /* block after XML_Parse()/XML_ParseBuffer() has been called */
                   1419:   if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
                   1420:     return 0;
                   1421: #ifdef XML_DTD
                   1422:   paramEntityParsing = peParsing;
                   1423:   return 1;
                   1424: #else
                   1425:   return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;
                   1426: #endif
                   1427: }
                   1428: 
                   1429: enum XML_Status XMLCALL
                   1430: XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
                   1431: {
                   1432:   switch (ps_parsing) {
                   1433:   case XML_SUSPENDED:
                   1434:     errorCode = XML_ERROR_SUSPENDED;
                   1435:     return XML_STATUS_ERROR;
                   1436:   case XML_FINISHED:
                   1437:     errorCode = XML_ERROR_FINISHED;
                   1438:     return XML_STATUS_ERROR;
                   1439:   default:
                   1440:     ps_parsing = XML_PARSING;
                   1441:   }
                   1442: 
                   1443:   if (len == 0) {
                   1444:     ps_finalBuffer = (XML_Bool)isFinal;
                   1445:     if (!isFinal)
                   1446:       return XML_STATUS_OK;
                   1447:     positionPtr = bufferPtr;
                   1448:     parseEndPtr = bufferEnd;
                   1449: 
                   1450:     /* If data are left over from last buffer, and we now know that these
                   1451:        data are the final chunk of input, then we have to check them again
                   1452:        to detect errors based on that fact.
                   1453:     */
                   1454:     errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);
                   1455: 
                   1456:     if (errorCode == XML_ERROR_NONE) {
                   1457:       switch (ps_parsing) {
                   1458:       case XML_SUSPENDED:
                   1459:         XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
                   1460:         positionPtr = bufferPtr;
                   1461:         return XML_STATUS_SUSPENDED;
                   1462:       case XML_INITIALIZED: 
                   1463:       case XML_PARSING:
                   1464:         ps_parsing = XML_FINISHED;
                   1465:         /* fall through */
                   1466:       default:
                   1467:         return XML_STATUS_OK;
                   1468:       }
                   1469:     }
                   1470:     eventEndPtr = eventPtr;
                   1471:     processor = errorProcessor;
                   1472:     return XML_STATUS_ERROR;
                   1473:   }
                   1474: #ifndef XML_CONTEXT_BYTES
                   1475:   else if (bufferPtr == bufferEnd) {
                   1476:     const char *end;
                   1477:     int nLeftOver;
                   1478:     enum XML_Error result;
                   1479:     parseEndByteIndex += len;
                   1480:     positionPtr = s;
                   1481:     ps_finalBuffer = (XML_Bool)isFinal;
                   1482: 
                   1483:     errorCode = processor(parser, s, parseEndPtr = s + len, &end);
                   1484: 
                   1485:     if (errorCode != XML_ERROR_NONE) {
                   1486:       eventEndPtr = eventPtr;
                   1487:       processor = errorProcessor;
                   1488:       return XML_STATUS_ERROR;
                   1489:     }
                   1490:     else {
                   1491:       switch (ps_parsing) {
                   1492:       case XML_SUSPENDED:
                   1493:         result = XML_STATUS_SUSPENDED;
                   1494:         break;
                   1495:       case XML_INITIALIZED:
                   1496:       case XML_PARSING:
                   1497:         result = XML_STATUS_OK;
                   1498:         if (isFinal) {
                   1499:           ps_parsing = XML_FINISHED;
                   1500:           return result;
                   1501:         }
                   1502:       }
                   1503:     }
                   1504: 
                   1505:     XmlUpdatePosition(encoding, positionPtr, end, &position);
                   1506:     nLeftOver = s + len - end;
                   1507:     if (nLeftOver) {
                   1508:       if (buffer == NULL || nLeftOver > bufferLim - buffer) {
                   1509:         /* FIXME avoid integer overflow */
                   1510:         char *temp;
                   1511:         temp = (buffer == NULL
                   1512:                 ? (char *)MALLOC(len * 2)
                   1513:                 : (char *)REALLOC(buffer, len * 2));
                   1514:         if (temp == NULL) {
                   1515:           errorCode = XML_ERROR_NO_MEMORY;
                   1516:           return XML_STATUS_ERROR;
                   1517:         }
                   1518:         buffer = temp;
                   1519:         if (!buffer) {
                   1520:           errorCode = XML_ERROR_NO_MEMORY;
                   1521:           eventPtr = eventEndPtr = NULL;
                   1522:           processor = errorProcessor;
                   1523:           return XML_STATUS_ERROR;
                   1524:         }
                   1525:         bufferLim = buffer + len * 2;
                   1526:       }
                   1527:       memcpy(buffer, end, nLeftOver);
                   1528:     }
                   1529:     bufferPtr = buffer;
                   1530:     bufferEnd = buffer + nLeftOver;
                   1531:     positionPtr = bufferPtr;
                   1532:     parseEndPtr = bufferEnd;
                   1533:     eventPtr = bufferPtr;
                   1534:     eventEndPtr = bufferPtr;
                   1535:     return result;
                   1536:   }
                   1537: #endif  /* not defined XML_CONTEXT_BYTES */
                   1538:   else {
                   1539:     void *buff = XML_GetBuffer(parser, len);
                   1540:     if (buff == NULL)
                   1541:       return XML_STATUS_ERROR;
                   1542:     else {
                   1543:       memcpy(buff, s, len);
                   1544:       return XML_ParseBuffer(parser, len, isFinal);
                   1545:     }
                   1546:   }
                   1547: }
                   1548: 
                   1549: enum XML_Status XMLCALL
                   1550: XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
                   1551: {
                   1552:   const char *start;
                   1553:   enum XML_Status result = XML_STATUS_OK;
                   1554: 
                   1555:   switch (ps_parsing) {
                   1556:   case XML_SUSPENDED:
                   1557:     errorCode = XML_ERROR_SUSPENDED;
                   1558:     return XML_STATUS_ERROR;
                   1559:   case XML_FINISHED:
                   1560:     errorCode = XML_ERROR_FINISHED;
                   1561:     return XML_STATUS_ERROR;
                   1562:   default:
                   1563:     ps_parsing = XML_PARSING;
                   1564:   }
                   1565: 
                   1566:   start = bufferPtr;
                   1567:   positionPtr = start;
                   1568:   bufferEnd += len;
                   1569:   parseEndPtr = bufferEnd;
                   1570:   parseEndByteIndex += len;
                   1571:   ps_finalBuffer = (XML_Bool)isFinal;
                   1572: 
                   1573:   errorCode = processor(parser, start, parseEndPtr, &bufferPtr);
                   1574: 
                   1575:   if (errorCode != XML_ERROR_NONE) {
                   1576:     eventEndPtr = eventPtr;
                   1577:     processor = errorProcessor;
                   1578:     return XML_STATUS_ERROR;
                   1579:   }
                   1580:   else {
                   1581:     switch (ps_parsing) {
                   1582:     case XML_SUSPENDED:
                   1583:       result = XML_STATUS_SUSPENDED;
                   1584:       break;
                   1585:     case XML_INITIALIZED: 
                   1586:     case XML_PARSING:
                   1587:       if (isFinal) {
                   1588:         ps_parsing = XML_FINISHED;
                   1589:         return result;
                   1590:       }
                   1591:     default: ;  /* should not happen */
                   1592:     }
                   1593:   }
                   1594: 
                   1595:   XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
                   1596:   positionPtr = bufferPtr;
                   1597:   return result;
                   1598: }
                   1599: 
                   1600: void * XMLCALL
                   1601: XML_GetBuffer(XML_Parser parser, int len)
                   1602: {
                   1603:   switch (ps_parsing) {
                   1604:   case XML_SUSPENDED:
                   1605:     errorCode = XML_ERROR_SUSPENDED;
                   1606:     return NULL;
                   1607:   case XML_FINISHED:
                   1608:     errorCode = XML_ERROR_FINISHED;
                   1609:     return NULL;
                   1610:   default: ;
                   1611:   }
                   1612: 
                   1613:   if (len > bufferLim - bufferEnd) {
                   1614:     /* FIXME avoid integer overflow */
                   1615:     int neededSize = len + (int)(bufferEnd - bufferPtr);
                   1616: #ifdef XML_CONTEXT_BYTES
                   1617:     int keep = (int)(bufferPtr - buffer);
                   1618: 
                   1619:     if (keep > XML_CONTEXT_BYTES)
                   1620:       keep = XML_CONTEXT_BYTES;
                   1621:     neededSize += keep;
                   1622: #endif  /* defined XML_CONTEXT_BYTES */
                   1623:     if (neededSize  <= bufferLim - buffer) {
                   1624: #ifdef XML_CONTEXT_BYTES
                   1625:       if (keep < bufferPtr - buffer) {
                   1626:         int offset = (int)(bufferPtr - buffer) - keep;
                   1627:         memmove(buffer, &buffer[offset], bufferEnd - bufferPtr + keep);
                   1628:         bufferEnd -= offset;
                   1629:         bufferPtr -= offset;
                   1630:       }
                   1631: #else
                   1632:       memmove(buffer, bufferPtr, bufferEnd - bufferPtr);
                   1633:       bufferEnd = buffer + (bufferEnd - bufferPtr);
                   1634:       bufferPtr = buffer;
                   1635: #endif  /* not defined XML_CONTEXT_BYTES */
                   1636:     }
                   1637:     else {
                   1638:       char *newBuf;
                   1639:       int bufferSize = (int)(bufferLim - bufferPtr);
                   1640:       if (bufferSize == 0)
                   1641:         bufferSize = INIT_BUFFER_SIZE;
                   1642:       do {
                   1643:         bufferSize *= 2;
                   1644:       } while (bufferSize < neededSize);
                   1645:       newBuf = (char *)MALLOC(bufferSize);
                   1646:       if (newBuf == 0) {
                   1647:         errorCode = XML_ERROR_NO_MEMORY;
                   1648:         return NULL;
                   1649:       }
                   1650:       bufferLim = newBuf + bufferSize;
                   1651: #ifdef XML_CONTEXT_BYTES
                   1652:       if (bufferPtr) {
                   1653:         int keep = (int)(bufferPtr - buffer);
                   1654:         if (keep > XML_CONTEXT_BYTES)
                   1655:           keep = XML_CONTEXT_BYTES;
                   1656:         memcpy(newBuf, &bufferPtr[-keep], bufferEnd - bufferPtr + keep);
                   1657:         FREE(buffer);
                   1658:         buffer = newBuf;
                   1659:         bufferEnd = buffer + (bufferEnd - bufferPtr) + keep;
                   1660:         bufferPtr = buffer + keep;
                   1661:       }
                   1662:       else {
                   1663:         bufferEnd = newBuf + (bufferEnd - bufferPtr);
                   1664:         bufferPtr = buffer = newBuf;
                   1665:       }
                   1666: #else
                   1667:       if (bufferPtr) {
                   1668:         memcpy(newBuf, bufferPtr, bufferEnd - bufferPtr);
                   1669:         FREE(buffer);
                   1670:       }
                   1671:       bufferEnd = newBuf + (bufferEnd - bufferPtr);
                   1672:       bufferPtr = buffer = newBuf;
                   1673: #endif  /* not defined XML_CONTEXT_BYTES */
                   1674:     }
                   1675:   }
                   1676:   return bufferEnd;
                   1677: }
                   1678: 
                   1679: enum XML_Status XMLCALL
                   1680: XML_StopParser(XML_Parser parser, XML_Bool resumable)
                   1681: {
                   1682:   switch (ps_parsing) {
                   1683:   case XML_SUSPENDED:
                   1684:     if (resumable) {
                   1685:       errorCode = XML_ERROR_SUSPENDED;
                   1686:       return XML_STATUS_ERROR;
                   1687:     }
                   1688:     ps_parsing = XML_FINISHED;
                   1689:     break;
                   1690:   case XML_FINISHED:
                   1691:     errorCode = XML_ERROR_FINISHED;
                   1692:     return XML_STATUS_ERROR;
                   1693:   default:
                   1694:     if (resumable) {
                   1695: #ifdef XML_DTD
                   1696:       if (isParamEntity) {
                   1697:         errorCode = XML_ERROR_SUSPEND_PE;
                   1698:         return XML_STATUS_ERROR;
                   1699:       }
                   1700: #endif
                   1701:       ps_parsing = XML_SUSPENDED;
                   1702:     }
                   1703:     else
                   1704:       ps_parsing = XML_FINISHED;
                   1705:   }
                   1706:   return XML_STATUS_OK;
                   1707: }
                   1708: 
                   1709: enum XML_Status XMLCALL
                   1710: XML_ResumeParser(XML_Parser parser)
                   1711: {
                   1712:   enum XML_Status result = XML_STATUS_OK;
                   1713: 
                   1714:   if (ps_parsing != XML_SUSPENDED) {
                   1715:     errorCode = XML_ERROR_NOT_SUSPENDED;
                   1716:     return XML_STATUS_ERROR;
                   1717:   }
                   1718:   ps_parsing = XML_PARSING;
                   1719: 
                   1720:   errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);
                   1721: 
                   1722:   if (errorCode != XML_ERROR_NONE) {
                   1723:     eventEndPtr = eventPtr;
                   1724:     processor = errorProcessor;
                   1725:     return XML_STATUS_ERROR;
                   1726:   }
                   1727:   else {
                   1728:     switch (ps_parsing) {
                   1729:     case XML_SUSPENDED:
                   1730:       result = XML_STATUS_SUSPENDED;
                   1731:       break;
                   1732:     case XML_INITIALIZED: 
                   1733:     case XML_PARSING:
                   1734:       if (ps_finalBuffer) {
                   1735:         ps_parsing = XML_FINISHED;
                   1736:         return result;
                   1737:       }
                   1738:     default: ;
                   1739:     }
                   1740:   }
                   1741: 
                   1742:   XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
                   1743:   positionPtr = bufferPtr;
                   1744:   return result;
                   1745: }
                   1746: 
                   1747: void XMLCALL
                   1748: XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status)
                   1749: {
                   1750:   assert(status != NULL);
                   1751:   *status = parser->m_parsingStatus;
                   1752: }
                   1753: 
                   1754: enum XML_Error XMLCALL
                   1755: XML_GetErrorCode(XML_Parser parser)
                   1756: {
                   1757:   return errorCode;
                   1758: }
                   1759: 
                   1760: XML_Index XMLCALL
                   1761: XML_GetCurrentByteIndex(XML_Parser parser)
                   1762: {
                   1763:   if (eventPtr)
                   1764:     return parseEndByteIndex - (parseEndPtr - eventPtr);
                   1765:   return -1;
                   1766: }
                   1767: 
                   1768: int XMLCALL
                   1769: XML_GetCurrentByteCount(XML_Parser parser)
                   1770: {
                   1771:   if (eventEndPtr && eventPtr)
                   1772:     return (int)(eventEndPtr - eventPtr);
                   1773:   return 0;
                   1774: }
                   1775: 
                   1776: const char * XMLCALL
                   1777: XML_GetInputContext(XML_Parser parser, int *offset, int *size)
                   1778: {
                   1779: #ifdef XML_CONTEXT_BYTES
                   1780:   if (eventPtr && buffer) {
                   1781:     *offset = (int)(eventPtr - buffer);
                   1782:     *size   = (int)(bufferEnd - buffer);
                   1783:     return buffer;
                   1784:   }
                   1785: #endif /* defined XML_CONTEXT_BYTES */
                   1786:   return (char *) 0;
                   1787: }
                   1788: 
                   1789: XML_Size XMLCALL
                   1790: XML_GetCurrentLineNumber(XML_Parser parser)
                   1791: {
                   1792:   if (eventPtr && eventPtr >= positionPtr) {
                   1793:     XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
                   1794:     positionPtr = eventPtr;
                   1795:   }
                   1796:   return position.lineNumber + 1;
                   1797: }
                   1798: 
                   1799: XML_Size XMLCALL
                   1800: XML_GetCurrentColumnNumber(XML_Parser parser)
                   1801: {
                   1802:   if (eventPtr && eventPtr >= positionPtr) {
                   1803:     XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
                   1804:     positionPtr = eventPtr;
                   1805:   }
                   1806:   return position.columnNumber;
                   1807: }
                   1808: 
                   1809: void XMLCALL
                   1810: XML_FreeContentModel(XML_Parser parser, XML_Content *model)
                   1811: {
                   1812:   FREE(model);
                   1813: }
                   1814: 
                   1815: void * XMLCALL
                   1816: XML_MemMalloc(XML_Parser parser, size_t size)
                   1817: {
                   1818:   return MALLOC(size);
                   1819: }
                   1820: 
                   1821: void * XMLCALL
                   1822: XML_MemRealloc(XML_Parser parser, void *ptr, size_t size)
                   1823: {
                   1824:   return REALLOC(ptr, size);
                   1825: }
                   1826: 
                   1827: void XMLCALL
                   1828: XML_MemFree(XML_Parser parser, void *ptr)
                   1829: {
                   1830:   FREE(ptr);
                   1831: }
                   1832: 
                   1833: void XMLCALL
                   1834: XML_DefaultCurrent(XML_Parser parser)
                   1835: {
                   1836:   if (defaultHandler) {
                   1837:     if (openInternalEntities)
                   1838:       reportDefault(parser,
                   1839:                     internalEncoding,
                   1840:                     openInternalEntities->internalEventPtr,
                   1841:                     openInternalEntities->internalEventEndPtr);
                   1842:     else
                   1843:       reportDefault(parser, encoding, eventPtr, eventEndPtr);
                   1844:   }
                   1845: }
                   1846: 
                   1847: const XML_LChar * XMLCALL
                   1848: XML_ErrorString(enum XML_Error code)
                   1849: {
                   1850:   static const XML_LChar* const message[] = {
                   1851:     0,
                   1852:     XML_L("out of memory"),
                   1853:     XML_L("syntax error"),
                   1854:     XML_L("no element found"),
                   1855:     XML_L("not well-formed (invalid token)"),
                   1856:     XML_L("unclosed token"),
                   1857:     XML_L("partial character"),
                   1858:     XML_L("mismatched tag"),
                   1859:     XML_L("duplicate attribute"),
                   1860:     XML_L("junk after document element"),
                   1861:     XML_L("illegal parameter entity reference"),
                   1862:     XML_L("undefined entity"),
                   1863:     XML_L("recursive entity reference"),
                   1864:     XML_L("asynchronous entity"),
                   1865:     XML_L("reference to invalid character number"),
                   1866:     XML_L("reference to binary entity"),
                   1867:     XML_L("reference to external entity in attribute"),
                   1868:     XML_L("XML or text declaration not at start of entity"),
                   1869:     XML_L("unknown encoding"),
                   1870:     XML_L("encoding specified in XML declaration is incorrect"),
                   1871:     XML_L("unclosed CDATA section"),
                   1872:     XML_L("error in processing external entity reference"),
                   1873:     XML_L("document is not standalone"),
                   1874:     XML_L("unexpected parser state - please send a bug report"),
                   1875:     XML_L("entity declared in parameter entity"),
                   1876:     XML_L("requested feature requires XML_DTD support in Expat"),
                   1877:     XML_L("cannot change setting once parsing has begun"),
                   1878:     XML_L("unbound prefix"),
                   1879:     XML_L("must not undeclare prefix"),
                   1880:     XML_L("incomplete markup in parameter entity"),
                   1881:     XML_L("XML declaration not well-formed"),
                   1882:     XML_L("text declaration not well-formed"),
                   1883:     XML_L("illegal character(s) in public id"),
                   1884:     XML_L("parser suspended"),
                   1885:     XML_L("parser not suspended"),
                   1886:     XML_L("parsing aborted"),
                   1887:     XML_L("parsing finished"),
                   1888:     XML_L("cannot suspend in external parameter entity"),
                   1889:     XML_L("reserved prefix (xml) must not be undeclared or bound to another namespace name"),
                   1890:     XML_L("reserved prefix (xmlns) must not be declared or undeclared"),
                   1891:     XML_L("prefix must not be bound to one of the reserved namespace names")
                   1892:   };
                   1893:   if (code > 0 && code < sizeof(message)/sizeof(message[0]))
                   1894:     return message[code];
                   1895:   return NULL;
                   1896: }
                   1897: 
                   1898: const XML_LChar * XMLCALL
                   1899: XML_ExpatVersion(void) {
                   1900: 
                   1901:   /* V1 is used to string-ize the version number. However, it would
                   1902:      string-ize the actual version macro *names* unless we get them
                   1903:      substituted before being passed to V1. CPP is defined to expand
                   1904:      a macro, then rescan for more expansions. Thus, we use V2 to expand
                   1905:      the version macros, then CPP will expand the resulting V1() macro
                   1906:      with the correct numerals. */
                   1907:   /* ### I'm assuming cpp is portable in this respect... */
                   1908: 
                   1909: #define V1(a,b,c) XML_L(#a)XML_L(".")XML_L(#b)XML_L(".")XML_L(#c)
                   1910: #define V2(a,b,c) XML_L("expat_")V1(a,b,c)
                   1911: 
                   1912:   return V2(XML_MAJOR_VERSION, XML_MINOR_VERSION, XML_MICRO_VERSION);
                   1913: 
                   1914: #undef V1
                   1915: #undef V2
                   1916: }
                   1917: 
                   1918: XML_Expat_Version XMLCALL
                   1919: XML_ExpatVersionInfo(void)
                   1920: {
                   1921:   XML_Expat_Version version;
                   1922: 
                   1923:   version.major = XML_MAJOR_VERSION;
                   1924:   version.minor = XML_MINOR_VERSION;
                   1925:   version.micro = XML_MICRO_VERSION;
                   1926: 
                   1927:   return version;
                   1928: }
                   1929: 
                   1930: const XML_Feature * XMLCALL
                   1931: XML_GetFeatureList(void)
                   1932: {
                   1933:   static const XML_Feature features[] = {
                   1934:     {XML_FEATURE_SIZEOF_XML_CHAR,  XML_L("sizeof(XML_Char)"),
                   1935:      sizeof(XML_Char)},
                   1936:     {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"),
                   1937:      sizeof(XML_LChar)},
                   1938: #ifdef XML_UNICODE
                   1939:     {XML_FEATURE_UNICODE,          XML_L("XML_UNICODE"), 0},
                   1940: #endif
                   1941: #ifdef XML_UNICODE_WCHAR_T
                   1942:     {XML_FEATURE_UNICODE_WCHAR_T,  XML_L("XML_UNICODE_WCHAR_T"), 0},
                   1943: #endif
                   1944: #ifdef XML_DTD
                   1945:     {XML_FEATURE_DTD,              XML_L("XML_DTD"), 0},
                   1946: #endif
                   1947: #ifdef XML_CONTEXT_BYTES
                   1948:     {XML_FEATURE_CONTEXT_BYTES,    XML_L("XML_CONTEXT_BYTES"),
                   1949:      XML_CONTEXT_BYTES},
                   1950: #endif
                   1951: #ifdef XML_MIN_SIZE
                   1952:     {XML_FEATURE_MIN_SIZE,         XML_L("XML_MIN_SIZE"), 0},
                   1953: #endif
                   1954: #ifdef XML_NS
                   1955:     {XML_FEATURE_NS,               XML_L("XML_NS"), 0},
                   1956: #endif
                   1957: #ifdef XML_LARGE_SIZE
                   1958:     {XML_FEATURE_LARGE_SIZE,       XML_L("XML_LARGE_SIZE"), 0},
                   1959: #endif    
                   1960:     {XML_FEATURE_END,              NULL, 0}
                   1961:   };
                   1962: 
                   1963:   return features;
                   1964: }
                   1965: 
                   1966: /* Initially tag->rawName always points into the parse buffer;
                   1967:    for those TAG instances opened while the current parse buffer was
                   1968:    processed, and not yet closed, we need to store tag->rawName in a more
                   1969:    permanent location, since the parse buffer is about to be discarded.
                   1970: */
                   1971: static XML_Bool
                   1972: storeRawNames(XML_Parser parser)
                   1973: {
                   1974:   TAG *tag = tagStack;
                   1975:   while (tag) {
                   1976:     int bufSize;
                   1977:     int nameLen = sizeof(XML_Char) * (tag->name.strLen + 1);
                   1978:     char *rawNameBuf = tag->buf + nameLen;
                   1979:     /* Stop if already stored.  Since tagStack is a stack, we can stop
                   1980:        at the first entry that has already been copied; everything
                   1981:        below it in the stack is already been accounted for in a
                   1982:        previous call to this function.
                   1983:     */
                   1984:     if (tag->rawName == rawNameBuf)
                   1985:       break;
                   1986:     /* For re-use purposes we need to ensure that the
                   1987:        size of tag->buf is a multiple of sizeof(XML_Char).
                   1988:     */
                   1989:     bufSize = nameLen + ROUND_UP(tag->rawNameLength, sizeof(XML_Char));
                   1990:     if (bufSize > tag->bufEnd - tag->buf) {
                   1991:       char *temp = (char *)REALLOC(tag->buf, bufSize);
                   1992:       if (temp == NULL)
                   1993:         return XML_FALSE;
                   1994:       /* if tag->name.str points to tag->buf (only when namespace
                   1995:          processing is off) then we have to update it
                   1996:       */
                   1997:       if (tag->name.str == (XML_Char *)tag->buf)
                   1998:         tag->name.str = (XML_Char *)temp;
                   1999:       /* if tag->name.localPart is set (when namespace processing is on)
                   2000:          then update it as well, since it will always point into tag->buf
                   2001:       */
                   2002:       if (tag->name.localPart)
                   2003:         tag->name.localPart = (XML_Char *)temp + (tag->name.localPart -
                   2004:                                                   (XML_Char *)tag->buf);
                   2005:       tag->buf = temp;
                   2006:       tag->bufEnd = temp + bufSize;
                   2007:       rawNameBuf = temp + nameLen;
                   2008:     }
                   2009:     memcpy(rawNameBuf, tag->rawName, tag->rawNameLength);
                   2010:     tag->rawName = rawNameBuf;
                   2011:     tag = tag->parent;
                   2012:   }
                   2013:   return XML_TRUE;
                   2014: }
                   2015: 
                   2016: static enum XML_Error PTRCALL
                   2017: contentProcessor(XML_Parser parser,
                   2018:                  const char *start,
                   2019:                  const char *end,
                   2020:                  const char **endPtr)
                   2021: {
                   2022:   enum XML_Error result = doContent(parser, 0, encoding, start, end, 
                   2023:                                     endPtr, (XML_Bool)!ps_finalBuffer);
                   2024:   if (result == XML_ERROR_NONE) {
                   2025:     if (!storeRawNames(parser))
                   2026:       return XML_ERROR_NO_MEMORY;
                   2027:   }
                   2028:   return result;
                   2029: }
                   2030: 
                   2031: static enum XML_Error PTRCALL
                   2032: externalEntityInitProcessor(XML_Parser parser,
                   2033:                             const char *start,
                   2034:                             const char *end,
                   2035:                             const char **endPtr)
                   2036: {
                   2037:   enum XML_Error result = initializeEncoding(parser);
                   2038:   if (result != XML_ERROR_NONE)
                   2039:     return result;
                   2040:   processor = externalEntityInitProcessor2;
                   2041:   return externalEntityInitProcessor2(parser, start, end, endPtr);
                   2042: }
                   2043: 
                   2044: static enum XML_Error PTRCALL
                   2045: externalEntityInitProcessor2(XML_Parser parser,
                   2046:                              const char *start,
                   2047:                              const char *end,
                   2048:                              const char **endPtr)
                   2049: {
                   2050:   const char *next = start; /* XmlContentTok doesn't always set the last arg */
                   2051:   int tok = XmlContentTok(encoding, start, end, &next);
                   2052:   switch (tok) {
                   2053:   case XML_TOK_BOM:
                   2054:     /* If we are at the end of the buffer, this would cause the next stage,
                   2055:        i.e. externalEntityInitProcessor3, to pass control directly to
                   2056:        doContent (by detecting XML_TOK_NONE) without processing any xml text
                   2057:        declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.
                   2058:     */
                   2059:     if (next == end && !ps_finalBuffer) {
                   2060:       *endPtr = next;
                   2061:       return XML_ERROR_NONE;
                   2062:     }
                   2063:     start = next;
                   2064:     break;
                   2065:   case XML_TOK_PARTIAL:
                   2066:     if (!ps_finalBuffer) {
                   2067:       *endPtr = start;
                   2068:       return XML_ERROR_NONE;
                   2069:     }
                   2070:     eventPtr = start;
                   2071:     return XML_ERROR_UNCLOSED_TOKEN;
                   2072:   case XML_TOK_PARTIAL_CHAR:
                   2073:     if (!ps_finalBuffer) {
                   2074:       *endPtr = start;
                   2075:       return XML_ERROR_NONE;
                   2076:     }
                   2077:     eventPtr = start;
                   2078:     return XML_ERROR_PARTIAL_CHAR;
                   2079:   }
                   2080:   processor = externalEntityInitProcessor3;
                   2081:   return externalEntityInitProcessor3(parser, start, end, endPtr);
                   2082: }
                   2083: 
                   2084: static enum XML_Error PTRCALL
                   2085: externalEntityInitProcessor3(XML_Parser parser,
                   2086:                              const char *start,
                   2087:                              const char *end,
                   2088:                              const char **endPtr)
                   2089: {
                   2090:   int tok;
                   2091:   const char *next = start; /* XmlContentTok doesn't always set the last arg */
                   2092:   eventPtr = start;
                   2093:   tok = XmlContentTok(encoding, start, end, &next);
                   2094:   eventEndPtr = next;
                   2095: 
                   2096:   switch (tok) {
                   2097:   case XML_TOK_XML_DECL:
                   2098:     {
                   2099:       enum XML_Error result;
                   2100:       result = processXmlDecl(parser, 1, start, next);
                   2101:       if (result != XML_ERROR_NONE)
                   2102:         return result;
                   2103:       switch (ps_parsing) {
                   2104:       case XML_SUSPENDED: 
                   2105:         *endPtr = next;
                   2106:         return XML_ERROR_NONE;
                   2107:       case XML_FINISHED:
                   2108:         return XML_ERROR_ABORTED;
                   2109:       default:
                   2110:         start = next;
                   2111:       }
                   2112:     }
                   2113:     break;
                   2114:   case XML_TOK_PARTIAL:
                   2115:     if (!ps_finalBuffer) {
                   2116:       *endPtr = start;
                   2117:       return XML_ERROR_NONE;
                   2118:     }
                   2119:     return XML_ERROR_UNCLOSED_TOKEN;
                   2120:   case XML_TOK_PARTIAL_CHAR:
                   2121:     if (!ps_finalBuffer) {
                   2122:       *endPtr = start;
                   2123:       return XML_ERROR_NONE;
                   2124:     }
                   2125:     return XML_ERROR_PARTIAL_CHAR;
                   2126:   }
                   2127:   processor = externalEntityContentProcessor;
                   2128:   tagLevel = 1;
                   2129:   return externalEntityContentProcessor(parser, start, end, endPtr);
                   2130: }
                   2131: 
                   2132: static enum XML_Error PTRCALL
                   2133: externalEntityContentProcessor(XML_Parser parser,
                   2134:                                const char *start,
                   2135:                                const char *end,
                   2136:                                const char **endPtr)
                   2137: {
                   2138:   enum XML_Error result = doContent(parser, 1, encoding, start, end, 
                   2139:                                     endPtr, (XML_Bool)!ps_finalBuffer);
                   2140:   if (result == XML_ERROR_NONE) {
                   2141:     if (!storeRawNames(parser))
                   2142:       return XML_ERROR_NO_MEMORY;
                   2143:   }
                   2144:   return result;
                   2145: }
                   2146: 
                   2147: static enum XML_Error
                   2148: doContent(XML_Parser parser,
                   2149:           int startTagLevel,
                   2150:           const ENCODING *enc,
                   2151:           const char *s,
                   2152:           const char *end,
                   2153:           const char **nextPtr,
                   2154:           XML_Bool haveMore)
                   2155: {
                   2156:   /* save one level of indirection */
                   2157:   DTD * const dtd = _dtd;  
                   2158: 
                   2159:   const char **eventPP;
                   2160:   const char **eventEndPP;
                   2161:   if (enc == encoding) {
                   2162:     eventPP = &eventPtr;
                   2163:     eventEndPP = &eventEndPtr;
                   2164:   }
                   2165:   else {
                   2166:     eventPP = &(openInternalEntities->internalEventPtr);
                   2167:     eventEndPP = &(openInternalEntities->internalEventEndPtr);
                   2168:   }
                   2169:   *eventPP = s;
                   2170: 
                   2171:   for (;;) {
                   2172:     const char *next = s; /* XmlContentTok doesn't always set the last arg */
                   2173:     int tok = XmlContentTok(enc, s, end, &next);
                   2174:     *eventEndPP = next;
                   2175:     switch (tok) {
                   2176:     case XML_TOK_TRAILING_CR:
                   2177:       if (haveMore) {
                   2178:         *nextPtr = s;
                   2179:         return XML_ERROR_NONE;
                   2180:       }
                   2181:       *eventEndPP = end;
                   2182:       if (characterDataHandler) {
                   2183:         XML_Char c = 0xA;
                   2184:         characterDataHandler(handlerArg, &c, 1);
                   2185:       }
                   2186:       else if (defaultHandler)
                   2187:         reportDefault(parser, enc, s, end);
                   2188:       /* We are at the end of the final buffer, should we check for 
                   2189:          XML_SUSPENDED, XML_FINISHED? 
                   2190:       */
                   2191:       if (startTagLevel == 0)
                   2192:         return XML_ERROR_NO_ELEMENTS;
                   2193:       if (tagLevel != startTagLevel)
                   2194:         return XML_ERROR_ASYNC_ENTITY;
                   2195:       *nextPtr = end;
                   2196:       return XML_ERROR_NONE;
                   2197:     case XML_TOK_NONE:
                   2198:       if (haveMore) {
                   2199:         *nextPtr = s;
                   2200:         return XML_ERROR_NONE;
                   2201:       }
                   2202:       if (startTagLevel > 0) {
                   2203:         if (tagLevel != startTagLevel)
                   2204:           return XML_ERROR_ASYNC_ENTITY;
                   2205:         *nextPtr = s;
                   2206:         return XML_ERROR_NONE;
                   2207:       }
                   2208:       return XML_ERROR_NO_ELEMENTS;
                   2209:     case XML_TOK_INVALID:
                   2210:       *eventPP = next;
                   2211:       return XML_ERROR_INVALID_TOKEN;
                   2212:     case XML_TOK_PARTIAL:
                   2213:       if (haveMore) {
                   2214:         *nextPtr = s;
                   2215:         return XML_ERROR_NONE;
                   2216:       }
                   2217:       return XML_ERROR_UNCLOSED_TOKEN;
                   2218:     case XML_TOK_PARTIAL_CHAR:
                   2219:       if (haveMore) {
                   2220:         *nextPtr = s;
                   2221:         return XML_ERROR_NONE;
                   2222:       }
                   2223:       return XML_ERROR_PARTIAL_CHAR;
                   2224:     case XML_TOK_ENTITY_REF:
                   2225:       {
                   2226:         const XML_Char *name;
                   2227:         ENTITY *entity;
                   2228:         XML_Char ch = (XML_Char) XmlPredefinedEntityName(enc,
                   2229:                                               s + enc->minBytesPerChar,
                   2230:                                               next - enc->minBytesPerChar);
                   2231:         if (ch) {
                   2232:           if (characterDataHandler)
                   2233:             characterDataHandler(handlerArg, &ch, 1);
                   2234:           else if (defaultHandler)
                   2235:             reportDefault(parser, enc, s, next);
                   2236:           break;
                   2237:         }
                   2238:         name = poolStoreString(&dtd->pool, enc,
                   2239:                                 s + enc->minBytesPerChar,
                   2240:                                 next - enc->minBytesPerChar);
                   2241:         if (!name)
                   2242:           return XML_ERROR_NO_MEMORY;
                   2243:         entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);
                   2244:         poolDiscard(&dtd->pool);
                   2245:         /* First, determine if a check for an existing declaration is needed;
                   2246:            if yes, check that the entity exists, and that it is internal,
                   2247:            otherwise call the skipped entity or default handler.
                   2248:         */
                   2249:         if (!dtd->hasParamEntityRefs || dtd->standalone) {
                   2250:           if (!entity)
                   2251:             return XML_ERROR_UNDEFINED_ENTITY;
                   2252:           else if (!entity->is_internal)
                   2253:             return XML_ERROR_ENTITY_DECLARED_IN_PE;
                   2254:         }
                   2255:         else if (!entity) {
                   2256:           if (skippedEntityHandler)
                   2257:             skippedEntityHandler(handlerArg, name, 0);
                   2258:           else if (defaultHandler)
                   2259:             reportDefault(parser, enc, s, next);
                   2260:           break;
                   2261:         }
                   2262:         if (entity->open)
                   2263:           return XML_ERROR_RECURSIVE_ENTITY_REF;
                   2264:         if (entity->notation)
                   2265:           return XML_ERROR_BINARY_ENTITY_REF;
                   2266:         if (entity->textPtr) {
                   2267:           enum XML_Error result;
                   2268:           if (!defaultExpandInternalEntities) {
                   2269:             if (skippedEntityHandler)
                   2270:               skippedEntityHandler(handlerArg, entity->name, 0);
                   2271:             else if (defaultHandler)
                   2272:               reportDefault(parser, enc, s, next);
                   2273:             break;
                   2274:           }
                   2275:           result = processInternalEntity(parser, entity, XML_FALSE);
                   2276:           if (result != XML_ERROR_NONE)
                   2277:             return result;
                   2278:         }
                   2279:         else if (externalEntityRefHandler) {
                   2280:           const XML_Char *context;
                   2281:           entity->open = XML_TRUE;
                   2282:           context = getContext(parser);
                   2283:           entity->open = XML_FALSE;
                   2284:           if (!context)
                   2285:             return XML_ERROR_NO_MEMORY;
                   2286:           if (!externalEntityRefHandler(externalEntityRefHandlerArg,
                   2287:                                         context,
                   2288:                                         entity->base,
                   2289:                                         entity->systemId,
                   2290:                                         entity->publicId))
                   2291:             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
                   2292:           poolDiscard(&tempPool);
                   2293:         }
                   2294:         else if (defaultHandler)
                   2295:           reportDefault(parser, enc, s, next);
                   2296:         break;
                   2297:       }
                   2298:     case XML_TOK_START_TAG_NO_ATTS:
                   2299:       /* fall through */
                   2300:     case XML_TOK_START_TAG_WITH_ATTS:
                   2301:       {
                   2302:         TAG *tag;
                   2303:         enum XML_Error result;
                   2304:         XML_Char *toPtr;
                   2305:         if (freeTagList) {
                   2306:           tag = freeTagList;
                   2307:           freeTagList = freeTagList->parent;
                   2308:         }
                   2309:         else {
                   2310:           tag = (TAG *)MALLOC(sizeof(TAG));
                   2311:           if (!tag)
                   2312:             return XML_ERROR_NO_MEMORY;
                   2313:           tag->buf = (char *)MALLOC(INIT_TAG_BUF_SIZE);
                   2314:           if (!tag->buf) {
                   2315:             FREE(tag);
                   2316:             return XML_ERROR_NO_MEMORY;
                   2317:           }
                   2318:           tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
                   2319:         }
                   2320:         tag->bindings = NULL;
                   2321:         tag->parent = tagStack;
                   2322:         tagStack = tag;
                   2323:         tag->name.localPart = NULL;
                   2324:         tag->name.prefix = NULL;
                   2325:         tag->rawName = s + enc->minBytesPerChar;
                   2326:         tag->rawNameLength = XmlNameLength(enc, tag->rawName);
                   2327:         ++tagLevel;
                   2328:         {
                   2329:           const char *rawNameEnd = tag->rawName + tag->rawNameLength;
                   2330:           const char *fromPtr = tag->rawName;
                   2331:           toPtr = (XML_Char *)tag->buf;
                   2332:           for (;;) {
                   2333:             int bufSize;
                   2334:             int convLen;
                   2335:             XmlConvert(enc,
                   2336:                        &fromPtr, rawNameEnd,
                   2337:                        (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);
                   2338:             convLen = (int)(toPtr - (XML_Char *)tag->buf);
                   2339:             if (fromPtr == rawNameEnd) {
                   2340:               tag->name.strLen = convLen;
                   2341:               break;
                   2342:             }
                   2343:             bufSize = (int)(tag->bufEnd - tag->buf) << 1;
                   2344:             {
                   2345:               char *temp = (char *)REALLOC(tag->buf, bufSize);
                   2346:               if (temp == NULL)
                   2347:                 return XML_ERROR_NO_MEMORY;
                   2348:               tag->buf = temp;
                   2349:               tag->bufEnd = temp + bufSize;
                   2350:               toPtr = (XML_Char *)temp + convLen;
                   2351:             }
                   2352:           }
                   2353:         }
                   2354:         tag->name.str = (XML_Char *)tag->buf;
                   2355:         *toPtr = XML_T('\0');
                   2356:         result = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings));
                   2357:         if (result)
                   2358:           return result;
                   2359:         if (startElementHandler)
                   2360:           startElementHandler(handlerArg, tag->name.str,
                   2361:                               (const XML_Char **)atts);
                   2362:         else if (defaultHandler)
                   2363:           reportDefault(parser, enc, s, next);
                   2364:         poolClear(&tempPool);
                   2365:         break;
                   2366:       }
                   2367:     case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
                   2368:       /* fall through */
                   2369:     case XML_TOK_EMPTY_ELEMENT_WITH_ATTS:
                   2370:       {
                   2371:         const char *rawName = s + enc->minBytesPerChar;
                   2372:         enum XML_Error result;
                   2373:         BINDING *bindings = NULL;
                   2374:         XML_Bool noElmHandlers = XML_TRUE;
                   2375:         TAG_NAME name;
                   2376:         name.str = poolStoreString(&tempPool, enc, rawName,
                   2377:                                    rawName + XmlNameLength(enc, rawName));
                   2378:         if (!name.str)
                   2379:           return XML_ERROR_NO_MEMORY;
                   2380:         poolFinish(&tempPool);
                   2381:         result = storeAtts(parser, enc, s, &name, &bindings);
                   2382:         if (result)
                   2383:           return result;
                   2384:         poolFinish(&tempPool);
                   2385:         if (startElementHandler) {
                   2386:           startElementHandler(handlerArg, name.str, (const XML_Char **)atts);
                   2387:           noElmHandlers = XML_FALSE;
                   2388:         }
                   2389:         if (endElementHandler) {
                   2390:           if (startElementHandler)
                   2391:             *eventPP = *eventEndPP;
                   2392:           endElementHandler(handlerArg, name.str);
                   2393:           noElmHandlers = XML_FALSE;
                   2394:         }
                   2395:         if (noElmHandlers && defaultHandler)
                   2396:           reportDefault(parser, enc, s, next);
                   2397:         poolClear(&tempPool);
                   2398:         while (bindings) {
                   2399:           BINDING *b = bindings;
                   2400:           if (endNamespaceDeclHandler)
                   2401:             endNamespaceDeclHandler(handlerArg, b->prefix->name);
                   2402:           bindings = bindings->nextTagBinding;
                   2403:           b->nextTagBinding = freeBindingList;
                   2404:           freeBindingList = b;
                   2405:           b->prefix->binding = b->prevPrefixBinding;
                   2406:         }
                   2407:       }
                   2408:       if (tagLevel == 0)
                   2409:         return epilogProcessor(parser, next, end, nextPtr);
                   2410:       break;
                   2411:     case XML_TOK_END_TAG:
                   2412:       if (tagLevel == startTagLevel)
                   2413:         return XML_ERROR_ASYNC_ENTITY;
                   2414:       else {
                   2415:         int len;
                   2416:         const char *rawName;
                   2417:         TAG *tag = tagStack;
                   2418:         tagStack = tag->parent;
                   2419:         tag->parent = freeTagList;
                   2420:         freeTagList = tag;
                   2421:         rawName = s + enc->minBytesPerChar*2;
                   2422:         len = XmlNameLength(enc, rawName);
                   2423:         if (len != tag->rawNameLength
                   2424:             || memcmp(tag->rawName, rawName, len) != 0) {
                   2425:           *eventPP = rawName;
                   2426:           return XML_ERROR_TAG_MISMATCH;
                   2427:         }
                   2428:         --tagLevel;
                   2429:         if (endElementHandler) {
                   2430:           const XML_Char *localPart;
                   2431:           const XML_Char *prefix;
                   2432:           XML_Char *uri;
                   2433:           localPart = tag->name.localPart;
                   2434:           if (ns && localPart) {
                   2435:             /* localPart and prefix may have been overwritten in
                   2436:                tag->name.str, since this points to the binding->uri
                   2437:                buffer which gets re-used; so we have to add them again
                   2438:             */
                   2439:             uri = (XML_Char *)tag->name.str + tag->name.uriLen;
                   2440:             /* don't need to check for space - already done in storeAtts() */
                   2441:             while (*localPart) *uri++ = *localPart++;
                   2442:             prefix = (XML_Char *)tag->name.prefix;
                   2443:             if (ns_triplets && prefix) {
                   2444:               *uri++ = namespaceSeparator;
                   2445:               while (*prefix) *uri++ = *prefix++;
                   2446:              }
                   2447:             *uri = XML_T('\0');
                   2448:           }
                   2449:           endElementHandler(handlerArg, tag->name.str);
                   2450:         }
                   2451:         else if (defaultHandler)
                   2452:           reportDefault(parser, enc, s, next);
                   2453:         while (tag->bindings) {
                   2454:           BINDING *b = tag->bindings;
                   2455:           if (endNamespaceDeclHandler)
                   2456:             endNamespaceDeclHandler(handlerArg, b->prefix->name);
                   2457:           tag->bindings = tag->bindings->nextTagBinding;
                   2458:           b->nextTagBinding = freeBindingList;
                   2459:           freeBindingList = b;
                   2460:           b->prefix->binding = b->prevPrefixBinding;
                   2461:         }
                   2462:         if (tagLevel == 0)
                   2463:           return epilogProcessor(parser, next, end, nextPtr);
                   2464:       }
                   2465:       break;
                   2466:     case XML_TOK_CHAR_REF:
                   2467:       {
                   2468:         int n = XmlCharRefNumber(enc, s);
                   2469:         if (n < 0)
                   2470:           return XML_ERROR_BAD_CHAR_REF;
                   2471:         if (characterDataHandler) {
                   2472:           XML_Char buf[XML_ENCODE_MAX];
                   2473:           characterDataHandler(handlerArg, buf, XmlEncode(n, (ICHAR *)buf));
                   2474:         }
                   2475:         else if (defaultHandler)
                   2476:           reportDefault(parser, enc, s, next);
                   2477:       }
                   2478:       break;
                   2479:     case XML_TOK_XML_DECL:
                   2480:       return XML_ERROR_MISPLACED_XML_PI;
                   2481:     case XML_TOK_DATA_NEWLINE:
                   2482:       if (characterDataHandler) {
                   2483:         XML_Char c = 0xA;
                   2484:         characterDataHandler(handlerArg, &c, 1);
                   2485:       }
                   2486:       else if (defaultHandler)
                   2487:         reportDefault(parser, enc, s, next);
                   2488:       break;
                   2489:     case XML_TOK_CDATA_SECT_OPEN:
                   2490:       {
                   2491:         enum XML_Error result;
                   2492:         if (startCdataSectionHandler)
                   2493:           startCdataSectionHandler(handlerArg);
                   2494: #if 0
                   2495:         /* Suppose you doing a transformation on a document that involves
                   2496:            changing only the character data.  You set up a defaultHandler
                   2497:            and a characterDataHandler.  The defaultHandler simply copies
                   2498:            characters through.  The characterDataHandler does the
                   2499:            transformation and writes the characters out escaping them as
                   2500:            necessary.  This case will fail to work if we leave out the
                   2501:            following two lines (because & and < inside CDATA sections will
                   2502:            be incorrectly escaped).
                   2503: 
                   2504:            However, now we have a start/endCdataSectionHandler, so it seems
                   2505:            easier to let the user deal with this.
                   2506:         */
                   2507:         else if (characterDataHandler)
                   2508:           characterDataHandler(handlerArg, dataBuf, 0);
                   2509: #endif
                   2510:         else if (defaultHandler)
                   2511:           reportDefault(parser, enc, s, next);
                   2512:         result = doCdataSection(parser, enc, &next, end, nextPtr, haveMore);
                   2513:         if (result != XML_ERROR_NONE)
                   2514:           return result;
                   2515:         else if (!next) {
                   2516:           processor = cdataSectionProcessor;
                   2517:           return result;
                   2518:         }
                   2519:       }
                   2520:       break;
                   2521:     case XML_TOK_TRAILING_RSQB:
                   2522:       if (haveMore) {
                   2523:         *nextPtr = s;
                   2524:         return XML_ERROR_NONE;
                   2525:       }
                   2526:       if (characterDataHandler) {
                   2527:         if (MUST_CONVERT(enc, s)) {
                   2528:           ICHAR *dataPtr = (ICHAR *)dataBuf;
                   2529:           XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
                   2530:           characterDataHandler(handlerArg, dataBuf,
                   2531:                                (int)(dataPtr - (ICHAR *)dataBuf));
                   2532:         }
                   2533:         else
                   2534:           characterDataHandler(handlerArg,
                   2535:                                (XML_Char *)s,
                   2536:                                (int)((XML_Char *)end - (XML_Char *)s));
                   2537:       }
                   2538:       else if (defaultHandler)
                   2539:         reportDefault(parser, enc, s, end);
                   2540:       /* We are at the end of the final buffer, should we check for 
                   2541:          XML_SUSPENDED, XML_FINISHED? 
                   2542:       */
                   2543:       if (startTagLevel == 0) {
                   2544:         *eventPP = end;
                   2545:         return XML_ERROR_NO_ELEMENTS;
                   2546:       }
                   2547:       if (tagLevel != startTagLevel) {
                   2548:         *eventPP = end;
                   2549:         return XML_ERROR_ASYNC_ENTITY;
                   2550:       }
                   2551:       *nextPtr = end;
                   2552:       return XML_ERROR_NONE;
                   2553:     case XML_TOK_DATA_CHARS: 
                   2554:       {
                   2555:         XML_CharacterDataHandler charDataHandler = characterDataHandler;
                   2556:         if (charDataHandler) {
                   2557:           if (MUST_CONVERT(enc, s)) {
                   2558:             for (;;) {
                   2559:               ICHAR *dataPtr = (ICHAR *)dataBuf;
                   2560:               XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
                   2561:               *eventEndPP = s;
                   2562:               charDataHandler(handlerArg, dataBuf,
                   2563:                               (int)(dataPtr - (ICHAR *)dataBuf));
                   2564:               if (s == next)
                   2565:                 break;
                   2566:               *eventPP = s;
                   2567:             }
                   2568:           }
                   2569:           else
                   2570:             charDataHandler(handlerArg,
                   2571:                             (XML_Char *)s,
                   2572:                             (int)((XML_Char *)next - (XML_Char *)s));
                   2573:         }
                   2574:         else if (defaultHandler)
                   2575:           reportDefault(parser, enc, s, next);
                   2576:       }
                   2577:       break;
                   2578:     case XML_TOK_PI:
                   2579:       if (!reportProcessingInstruction(parser, enc, s, next))
                   2580:         return XML_ERROR_NO_MEMORY;
                   2581:       break;
                   2582:     case XML_TOK_COMMENT:
                   2583:       if (!reportComment(parser, enc, s, next))
                   2584:         return XML_ERROR_NO_MEMORY;
                   2585:       break;
                   2586:     default:
                   2587:       if (defaultHandler)
                   2588:         reportDefault(parser, enc, s, next);
                   2589:       break;
                   2590:     }
                   2591:     *eventPP = s = next;
                   2592:     switch (ps_parsing) {
                   2593:     case XML_SUSPENDED: 
                   2594:       *nextPtr = next;
                   2595:       return XML_ERROR_NONE;
                   2596:     case XML_FINISHED:
                   2597:       return XML_ERROR_ABORTED;
                   2598:     default: ;
                   2599:     }
                   2600:   }
                   2601:   /* not reached */
                   2602: }
                   2603: 
                   2604: /* Precondition: all arguments must be non-NULL;
                   2605:    Purpose:
                   2606:    - normalize attributes
                   2607:    - check attributes for well-formedness
                   2608:    - generate namespace aware attribute names (URI, prefix)
                   2609:    - build list of attributes for startElementHandler
                   2610:    - default attributes
                   2611:    - process namespace declarations (check and report them)
                   2612:    - generate namespace aware element name (URI, prefix)
                   2613: */
                   2614: static enum XML_Error
                   2615: storeAtts(XML_Parser parser, const ENCODING *enc,
                   2616:           const char *attStr, TAG_NAME *tagNamePtr,
                   2617:           BINDING **bindingsPtr)
                   2618: {
                   2619:   DTD * const dtd = _dtd;  /* save one level of indirection */
                   2620:   ELEMENT_TYPE *elementType;
                   2621:   int nDefaultAtts;
                   2622:   const XML_Char **appAtts;   /* the attribute list for the application */
                   2623:   int attIndex = 0;
                   2624:   int prefixLen;
                   2625:   int i;
                   2626:   int n;
                   2627:   XML_Char *uri;
                   2628:   int nPrefixes = 0;
                   2629:   BINDING *binding;
                   2630:   const XML_Char *localPart;
                   2631: 
                   2632:   /* lookup the element type name */
                   2633:   elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, tagNamePtr->str,0);
                   2634:   if (!elementType) {
                   2635:     const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);
                   2636:     if (!name)
                   2637:       return XML_ERROR_NO_MEMORY;
                   2638:     elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, name,
                   2639:                                          sizeof(ELEMENT_TYPE));
                   2640:     if (!elementType)
                   2641:       return XML_ERROR_NO_MEMORY;
                   2642:     if (ns && !setElementTypePrefix(parser, elementType))
                   2643:       return XML_ERROR_NO_MEMORY;
                   2644:   }
                   2645:   nDefaultAtts = elementType->nDefaultAtts;
                   2646: 
                   2647:   /* get the attributes from the tokenizer */
                   2648:   n = XmlGetAttributes(enc, attStr, attsSize, atts);
                   2649:   if (n + nDefaultAtts > attsSize) {
                   2650:     int oldAttsSize = attsSize;
                   2651:     ATTRIBUTE *temp;
                   2652:     attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
                   2653:     temp = (ATTRIBUTE *)REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
                   2654:     if (temp == NULL)
                   2655:       return XML_ERROR_NO_MEMORY;
                   2656:     atts = temp;
                   2657:     if (n > oldAttsSize)
                   2658:       XmlGetAttributes(enc, attStr, n, atts);
                   2659:   }
                   2660: 
                   2661:   appAtts = (const XML_Char **)atts;
                   2662:   for (i = 0; i < n; i++) {
                   2663:     /* add the name and value to the attribute list */
                   2664:     ATTRIBUTE_ID *attId = getAttributeId(parser, enc, atts[i].name,
                   2665:                                          atts[i].name
                   2666:                                          + XmlNameLength(enc, atts[i].name));
                   2667:     if (!attId)
                   2668:       return XML_ERROR_NO_MEMORY;
                   2669:     /* Detect duplicate attributes by their QNames. This does not work when
                   2670:        namespace processing is turned on and different prefixes for the same
                   2671:        namespace are used. For this case we have a check further down.
                   2672:     */
                   2673:     if ((attId->name)[-1]) {
                   2674:       if (enc == encoding)
                   2675:         eventPtr = atts[i].name;
                   2676:       return XML_ERROR_DUPLICATE_ATTRIBUTE;
                   2677:     }
                   2678:     (attId->name)[-1] = 1;
                   2679:     appAtts[attIndex++] = attId->name;
                   2680:     if (!atts[i].normalized) {
                   2681:       enum XML_Error result;
                   2682:       XML_Bool isCdata = XML_TRUE;
                   2683: 
                   2684:       /* figure out whether declared as other than CDATA */
                   2685:       if (attId->maybeTokenized) {
                   2686:         int j;
                   2687:         for (j = 0; j < nDefaultAtts; j++) {
                   2688:           if (attId == elementType->defaultAtts[j].id) {
                   2689:             isCdata = elementType->defaultAtts[j].isCdata;
                   2690:             break;
                   2691:           }
                   2692:         }
                   2693:       }
                   2694: 
                   2695:       /* normalize the attribute value */
                   2696:       result = storeAttributeValue(parser, enc, isCdata,
                   2697:                                    atts[i].valuePtr, atts[i].valueEnd,
                   2698:                                    &tempPool);
                   2699:       if (result)
                   2700:         return result;
                   2701:       appAtts[attIndex] = poolStart(&tempPool);
                   2702:       poolFinish(&tempPool);
                   2703:     }
                   2704:     else {
                   2705:       /* the value did not need normalizing */
                   2706:       appAtts[attIndex] = poolStoreString(&tempPool, enc, atts[i].valuePtr,
                   2707:                                           atts[i].valueEnd);
                   2708:       if (appAtts[attIndex] == 0)
                   2709:         return XML_ERROR_NO_MEMORY;
                   2710:       poolFinish(&tempPool);
                   2711:     }
                   2712:     /* handle prefixed attribute names */
                   2713:     if (attId->prefix) {
                   2714:       if (attId->xmlns) {
                   2715:         /* deal with namespace declarations here */
                   2716:         enum XML_Error result = addBinding(parser, attId->prefix, attId,
                   2717:                                            appAtts[attIndex], bindingsPtr);
                   2718:         if (result)
                   2719:           return result;
                   2720:         --attIndex;
                   2721:       }
                   2722:       else {
                   2723:         /* deal with other prefixed names later */
                   2724:         attIndex++;
                   2725:         nPrefixes++;
                   2726:         (attId->name)[-1] = 2;
                   2727:       }
                   2728:     }
                   2729:     else
                   2730:       attIndex++;
                   2731:   }
                   2732: 
                   2733:   /* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */
                   2734:   nSpecifiedAtts = attIndex;
                   2735:   if (elementType->idAtt && (elementType->idAtt->name)[-1]) {
                   2736:     for (i = 0; i < attIndex; i += 2)
                   2737:       if (appAtts[i] == elementType->idAtt->name) {
                   2738:         idAttIndex = i;
                   2739:         break;
                   2740:       }
                   2741:   }
                   2742:   else
                   2743:     idAttIndex = -1;
                   2744: 
                   2745:   /* do attribute defaulting */
                   2746:   for (i = 0; i < nDefaultAtts; i++) {
                   2747:     const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i;
                   2748:     if (!(da->id->name)[-1] && da->value) {
                   2749:       if (da->id->prefix) {
                   2750:         if (da->id->xmlns) {
                   2751:           enum XML_Error result = addBinding(parser, da->id->prefix, da->id,
                   2752:                                              da->value, bindingsPtr);
                   2753:           if (result)
                   2754:             return result;
                   2755:         }
                   2756:         else {
                   2757:           (da->id->name)[-1] = 2;
                   2758:           nPrefixes++;
                   2759:           appAtts[attIndex++] = da->id->name;
                   2760:           appAtts[attIndex++] = da->value;
                   2761:         }
                   2762:       }
                   2763:       else {
                   2764:         (da->id->name)[-1] = 1;
                   2765:         appAtts[attIndex++] = da->id->name;
                   2766:         appAtts[attIndex++] = da->value;
                   2767:       }
                   2768:     }
                   2769:   }
                   2770:   appAtts[attIndex] = 0;
                   2771: 
                   2772:   /* expand prefixed attribute names, check for duplicates,
                   2773:      and clear flags that say whether attributes were specified */
                   2774:   i = 0;
                   2775:   if (nPrefixes) {
                   2776:     int j;  /* hash table index */
                   2777:     unsigned long version = nsAttsVersion;
                   2778:     int nsAttsSize = (int)1 << nsAttsPower;
                   2779:     /* size of hash table must be at least 2 * (# of prefixed attributes) */
                   2780:     if ((nPrefixes << 1) >> nsAttsPower) {  /* true for nsAttsPower = 0 */
                   2781:       NS_ATT *temp;
                   2782:       /* hash table size must also be a power of 2 and >= 8 */
                   2783:       while (nPrefixes >> nsAttsPower++);
                   2784:       if (nsAttsPower < 3)
                   2785:         nsAttsPower = 3;
                   2786:       nsAttsSize = (int)1 << nsAttsPower;
                   2787:       temp = (NS_ATT *)REALLOC(nsAtts, nsAttsSize * sizeof(NS_ATT));
                   2788:       if (!temp)
                   2789:         return XML_ERROR_NO_MEMORY;
                   2790:       nsAtts = temp;
                   2791:       version = 0;  /* force re-initialization of nsAtts hash table */
                   2792:     }
                   2793:     /* using a version flag saves us from initializing nsAtts every time */
                   2794:     if (!version) {  /* initialize version flags when version wraps around */
                   2795:       version = INIT_ATTS_VERSION;
                   2796:       for (j = nsAttsSize; j != 0; )
                   2797:         nsAtts[--j].version = version;
                   2798:     }
                   2799:     nsAttsVersion = --version;
                   2800: 
                   2801:     /* expand prefixed names and check for duplicates */
                   2802:     for (; i < attIndex; i += 2) {
                   2803:       const XML_Char *s = appAtts[i];
                   2804:       if (s[-1] == 2) {  /* prefixed */
                   2805:         ATTRIBUTE_ID *id;
                   2806:         const BINDING *b;
                   2807:         unsigned long uriHash = 0;
                   2808:         ((XML_Char *)s)[-1] = 0;  /* clear flag */
                   2809:         id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, s, 0);
                   2810:         b = id->prefix->binding;
                   2811:         if (!b)
                   2812:           return XML_ERROR_UNBOUND_PREFIX;
                   2813: 
                   2814:         /* as we expand the name we also calculate its hash value */
                   2815:         for (j = 0; j < b->uriLen; j++) {
                   2816:           const XML_Char c = b->uri[j];
                   2817:           if (!poolAppendChar(&tempPool, c))
                   2818:             return XML_ERROR_NO_MEMORY;
                   2819:           uriHash = CHAR_HASH(uriHash, c);
                   2820:         }
                   2821:         while (*s++ != XML_T(ASCII_COLON))
                   2822:           ;
                   2823:         do {  /* copies null terminator */
                   2824:           const XML_Char c = *s;
                   2825:           if (!poolAppendChar(&tempPool, *s))
                   2826:             return XML_ERROR_NO_MEMORY;
                   2827:           uriHash = CHAR_HASH(uriHash, c);
                   2828:         } while (*s++);
                   2829: 
                   2830:         { /* Check hash table for duplicate of expanded name (uriName).
                   2831:              Derived from code in lookup(HASH_TABLE *table, ...).
                   2832:           */
                   2833:           unsigned char step = 0;
                   2834:           unsigned long mask = nsAttsSize - 1;
                   2835:           j = uriHash & mask;  /* index into hash table */
                   2836:           while (nsAtts[j].version == version) {
                   2837:             /* for speed we compare stored hash values first */
                   2838:             if (uriHash == nsAtts[j].hash) {
                   2839:               const XML_Char *s1 = poolStart(&tempPool);
                   2840:               const XML_Char *s2 = nsAtts[j].uriName;
                   2841:               /* s1 is null terminated, but not s2 */
                   2842:               for (; *s1 == *s2 && *s1 != 0; s1++, s2++);
                   2843:               if (*s1 == 0)
                   2844:                 return XML_ERROR_DUPLICATE_ATTRIBUTE;
                   2845:             }
                   2846:             if (!step)
                   2847:               step = PROBE_STEP(uriHash, mask, nsAttsPower);
                   2848:             j < step ? (j += nsAttsSize - step) : (j -= step);
                   2849:           }
                   2850:         }
                   2851: 
                   2852:         if (ns_triplets) {  /* append namespace separator and prefix */
                   2853:           tempPool.ptr[-1] = namespaceSeparator;
                   2854:           s = b->prefix->name;
                   2855:           do {
                   2856:             if (!poolAppendChar(&tempPool, *s))
                   2857:               return XML_ERROR_NO_MEMORY;
                   2858:           } while (*s++);
                   2859:         }
                   2860: 
                   2861:         /* store expanded name in attribute list */
                   2862:         s = poolStart(&tempPool);
                   2863:         poolFinish(&tempPool);
                   2864:         appAtts[i] = s;
                   2865: 
                   2866:         /* fill empty slot with new version, uriName and hash value */
                   2867:         nsAtts[j].version = version;
                   2868:         nsAtts[j].hash = uriHash;
                   2869:         nsAtts[j].uriName = s;
                   2870: 
                   2871:         if (!--nPrefixes) {
                   2872:           i += 2;
                   2873:           break;
                   2874:         }
                   2875:       }
                   2876:       else  /* not prefixed */
                   2877:         ((XML_Char *)s)[-1] = 0;  /* clear flag */
                   2878:     }
                   2879:   }
                   2880:   /* clear flags for the remaining attributes */
                   2881:   for (; i < attIndex; i += 2)
                   2882:     ((XML_Char *)(appAtts[i]))[-1] = 0;
                   2883:   for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)
                   2884:     binding->attId->name[-1] = 0;
                   2885: 
                   2886:   if (!ns)
                   2887:     return XML_ERROR_NONE;
                   2888: 
                   2889:   /* expand the element type name */
                   2890:   if (elementType->prefix) {
                   2891:     binding = elementType->prefix->binding;
                   2892:     if (!binding)
                   2893:       return XML_ERROR_UNBOUND_PREFIX;
                   2894:     localPart = tagNamePtr->str;
                   2895:     while (*localPart++ != XML_T(ASCII_COLON))
                   2896:       ;
                   2897:   }
                   2898:   else if (dtd->defaultPrefix.binding) {
                   2899:     binding = dtd->defaultPrefix.binding;
                   2900:     localPart = tagNamePtr->str;
                   2901:   }
                   2902:   else
                   2903:     return XML_ERROR_NONE;
                   2904:   prefixLen = 0;
                   2905:   if (ns_triplets && binding->prefix->name) {
                   2906:     for (; binding->prefix->name[prefixLen++];)
                   2907:       ;  /* prefixLen includes null terminator */
                   2908:   }
                   2909:   tagNamePtr->localPart = localPart;
                   2910:   tagNamePtr->uriLen = binding->uriLen;
                   2911:   tagNamePtr->prefix = binding->prefix->name;
                   2912:   tagNamePtr->prefixLen = prefixLen;
                   2913:   for (i = 0; localPart[i++];)
                   2914:     ;  /* i includes null terminator */
                   2915:   n = i + binding->uriLen + prefixLen;
                   2916:   if (n > binding->uriAlloc) {
                   2917:     TAG *p;
                   2918:     uri = (XML_Char *)MALLOC((n + EXPAND_SPARE) * sizeof(XML_Char));
                   2919:     if (!uri)
                   2920:       return XML_ERROR_NO_MEMORY;
                   2921:     binding->uriAlloc = n + EXPAND_SPARE;
                   2922:     memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));
                   2923:     for (p = tagStack; p; p = p->parent)
                   2924:       if (p->name.str == binding->uri)
                   2925:         p->name.str = uri;
                   2926:     FREE(binding->uri);
                   2927:     binding->uri = uri;
                   2928:   }
                   2929:   /* if namespaceSeparator != '\0' then uri includes it already */
                   2930:   uri = binding->uri + binding->uriLen;
                   2931:   memcpy(uri, localPart, i * sizeof(XML_Char));
                   2932:   /* we always have a namespace separator between localPart and prefix */
                   2933:   if (prefixLen) {
                   2934:     uri += i - 1;
                   2935:     *uri = namespaceSeparator;  /* replace null terminator */
                   2936:     memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));
                   2937:   }
                   2938:   tagNamePtr->str = binding->uri;
                   2939:   return XML_ERROR_NONE;
                   2940: }
                   2941: 
                   2942: /* addBinding() overwrites the value of prefix->binding without checking.
                   2943:    Therefore one must keep track of the old value outside of addBinding().
                   2944: */
                   2945: static enum XML_Error
                   2946: addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
                   2947:            const XML_Char *uri, BINDING **bindingsPtr)
                   2948: {
                   2949:   static const XML_Char xmlNamespace[] = {
                   2950:     ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,
                   2951:     ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD,
                   2952:     ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L, 
                   2953:     ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9, ASCII_8, ASCII_SLASH,
                   2954:     ASCII_n, ASCII_a, ASCII_m, ASCII_e, ASCII_s, ASCII_p, ASCII_a, ASCII_c,
                   2955:     ASCII_e, '\0'
                   2956:   };
                   2957:   static const int xmlLen = 
                   2958:     (int)sizeof(xmlNamespace)/sizeof(XML_Char) - 1;
                   2959:   static const XML_Char xmlnsNamespace[] = {
                   2960:     ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,
                   2961:     ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD,
                   2962:     ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_2, ASCII_0, ASCII_0, 
                   2963:     ASCII_0, ASCII_SLASH, ASCII_x, ASCII_m, ASCII_l, ASCII_n, ASCII_s, 
                   2964:     ASCII_SLASH, '\0'
                   2965:   };
                   2966:   static const int xmlnsLen = 
                   2967:     (int)sizeof(xmlnsNamespace)/sizeof(XML_Char) - 1;
                   2968: 
                   2969:   XML_Bool mustBeXML = XML_FALSE;
                   2970:   XML_Bool isXML = XML_TRUE;
                   2971:   XML_Bool isXMLNS = XML_TRUE;
                   2972:   
                   2973:   BINDING *b;
                   2974:   int len;
                   2975: 
                   2976:   /* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */
                   2977:   if (*uri == XML_T('\0') && prefix->name)
                   2978:     return XML_ERROR_UNDECLARING_PREFIX;
                   2979: 
                   2980:   if (prefix->name
                   2981:       && prefix->name[0] == XML_T(ASCII_x)
                   2982:       && prefix->name[1] == XML_T(ASCII_m)
                   2983:       && prefix->name[2] == XML_T(ASCII_l)) {
                   2984: 
                   2985:     /* Not allowed to bind xmlns */
                   2986:     if (prefix->name[3] == XML_T(ASCII_n)
                   2987:         && prefix->name[4] == XML_T(ASCII_s)
                   2988:         && prefix->name[5] == XML_T('\0'))
                   2989:       return XML_ERROR_RESERVED_PREFIX_XMLNS;
                   2990: 
                   2991:     if (prefix->name[3] == XML_T('\0'))
                   2992:       mustBeXML = XML_TRUE;
                   2993:   }
                   2994: 
                   2995:   for (len = 0; uri[len]; len++) {
                   2996:     if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))
                   2997:       isXML = XML_FALSE;
                   2998: 
                   2999:     if (!mustBeXML && isXMLNS 
                   3000:         && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))
                   3001:       isXMLNS = XML_FALSE;
                   3002:   }
                   3003:   isXML = isXML && len == xmlLen;
                   3004:   isXMLNS = isXMLNS && len == xmlnsLen;
                   3005: 
                   3006:   if (mustBeXML != isXML)
                   3007:     return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML
                   3008:                      : XML_ERROR_RESERVED_NAMESPACE_URI;
                   3009: 
                   3010:   if (isXMLNS)
                   3011:     return XML_ERROR_RESERVED_NAMESPACE_URI;
                   3012: 
                   3013:   if (namespaceSeparator)
                   3014:     len++;
                   3015:   if (freeBindingList) {
                   3016:     b = freeBindingList;
                   3017:     if (len > b->uriAlloc) {
                   3018:       XML_Char *temp = (XML_Char *)REALLOC(b->uri,
                   3019:                           sizeof(XML_Char) * (len + EXPAND_SPARE));
                   3020:       if (temp == NULL)
                   3021:         return XML_ERROR_NO_MEMORY;
                   3022:       b->uri = temp;
                   3023:       b->uriAlloc = len + EXPAND_SPARE;
                   3024:     }
                   3025:     freeBindingList = b->nextTagBinding;
                   3026:   }
                   3027:   else {
                   3028:     b = (BINDING *)MALLOC(sizeof(BINDING));
                   3029:     if (!b)
                   3030:       return XML_ERROR_NO_MEMORY;
                   3031:     b->uri = (XML_Char *)MALLOC(sizeof(XML_Char) * (len + EXPAND_SPARE));
                   3032:     if (!b->uri) {
                   3033:       FREE(b);
                   3034:       return XML_ERROR_NO_MEMORY;
                   3035:     }
                   3036:     b->uriAlloc = len + EXPAND_SPARE;
                   3037:   }
                   3038:   b->uriLen = len;
                   3039:   memcpy(b->uri, uri, len * sizeof(XML_Char));
                   3040:   if (namespaceSeparator)
                   3041:     b->uri[len - 1] = namespaceSeparator;
                   3042:   b->prefix = prefix;
                   3043:   b->attId = attId;
                   3044:   b->prevPrefixBinding = prefix->binding;
                   3045:   /* NULL binding when default namespace undeclared */
                   3046:   if (*uri == XML_T('\0') && prefix == &_dtd->defaultPrefix)
                   3047:     prefix->binding = NULL;
                   3048:   else
                   3049:     prefix->binding = b;
                   3050:   b->nextTagBinding = *bindingsPtr;
                   3051:   *bindingsPtr = b;
                   3052:   /* if attId == NULL then we are not starting a namespace scope */
                   3053:   if (attId && startNamespaceDeclHandler)
                   3054:     startNamespaceDeclHandler(handlerArg, prefix->name,
                   3055:                               prefix->binding ? uri : 0);
                   3056:   return XML_ERROR_NONE;
                   3057: }
                   3058: 
                   3059: /* The idea here is to avoid using stack for each CDATA section when
                   3060:    the whole file is parsed with one call.
                   3061: */
                   3062: static enum XML_Error PTRCALL
                   3063: cdataSectionProcessor(XML_Parser parser,
                   3064:                       const char *start,
                   3065:                       const char *end,
                   3066:                       const char **endPtr)
                   3067: {
                   3068:   enum XML_Error result = doCdataSection(parser, encoding, &start, end,
                   3069:                                          endPtr, (XML_Bool)!ps_finalBuffer);
                   3070:   if (result != XML_ERROR_NONE)
                   3071:     return result;
                   3072:   if (start) {
                   3073:     if (parentParser) {  /* we are parsing an external entity */
                   3074:       processor = externalEntityContentProcessor;
                   3075:       return externalEntityContentProcessor(parser, start, end, endPtr);
                   3076:     }
                   3077:     else {
                   3078:       processor = contentProcessor;
                   3079:       return contentProcessor(parser, start, end, endPtr);
                   3080:     }
                   3081:   }
                   3082:   return result;
                   3083: }
                   3084: 
                   3085: /* startPtr gets set to non-null if the section is closed, and to null if
                   3086:    the section is not yet closed.
                   3087: */
                   3088: static enum XML_Error
                   3089: doCdataSection(XML_Parser parser,
                   3090:                const ENCODING *enc,
                   3091:                const char **startPtr,
                   3092:                const char *end,
                   3093:                const char **nextPtr,
                   3094:                XML_Bool haveMore)
                   3095: {
                   3096:   const char *s = *startPtr;
                   3097:   const char **eventPP;
                   3098:   const char **eventEndPP;
                   3099:   if (enc == encoding) {
                   3100:     eventPP = &eventPtr;
                   3101:     *eventPP = s;
                   3102:     eventEndPP = &eventEndPtr;
                   3103:   }
                   3104:   else {
                   3105:     eventPP = &(openInternalEntities->internalEventPtr);
                   3106:     eventEndPP = &(openInternalEntities->internalEventEndPtr);
                   3107:   }
                   3108:   *eventPP = s;
                   3109:   *startPtr = NULL;
                   3110: 
                   3111:   for (;;) {
                   3112:     const char *next;
                   3113:     int tok = XmlCdataSectionTok(enc, s, end, &next);
                   3114:     *eventEndPP = next;
                   3115:     switch (tok) {
                   3116:     case XML_TOK_CDATA_SECT_CLOSE:
                   3117:       if (endCdataSectionHandler)
                   3118:         endCdataSectionHandler(handlerArg);
                   3119: #if 0
                   3120:       /* see comment under XML_TOK_CDATA_SECT_OPEN */
                   3121:       else if (characterDataHandler)
                   3122:         characterDataHandler(handlerArg, dataBuf, 0);
                   3123: #endif
                   3124:       else if (defaultHandler)
                   3125:         reportDefault(parser, enc, s, next);
                   3126:       *startPtr = next;
                   3127:       *nextPtr = next;
                   3128:       if (ps_parsing == XML_FINISHED)
                   3129:         return XML_ERROR_ABORTED;
                   3130:       else
                   3131:         return XML_ERROR_NONE;
                   3132:     case XML_TOK_DATA_NEWLINE:
                   3133:       if (characterDataHandler) {
                   3134:         XML_Char c = 0xA;
                   3135:         characterDataHandler(handlerArg, &c, 1);
                   3136:       }
                   3137:       else if (defaultHandler)
                   3138:         reportDefault(parser, enc, s, next);
                   3139:       break;
                   3140:     case XML_TOK_DATA_CHARS:
                   3141:       {
                   3142:         XML_CharacterDataHandler charDataHandler = characterDataHandler;
                   3143:         if (charDataHandler) {
                   3144:           if (MUST_CONVERT(enc, s)) {
                   3145:             for (;;) {
                   3146:               ICHAR *dataPtr = (ICHAR *)dataBuf;
                   3147:               XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
                   3148:               *eventEndPP = next;
                   3149:               charDataHandler(handlerArg, dataBuf,
                   3150:                               (int)(dataPtr - (ICHAR *)dataBuf));
                   3151:               if (s == next)
                   3152:                 break;
                   3153:               *eventPP = s;
                   3154:             }
                   3155:           }
                   3156:           else
                   3157:             charDataHandler(handlerArg,
                   3158:                             (XML_Char *)s,
                   3159:                             (int)((XML_Char *)next - (XML_Char *)s));
                   3160:         }
                   3161:         else if (defaultHandler)
                   3162:           reportDefault(parser, enc, s, next);
                   3163:       }
                   3164:       break;
                   3165:     case XML_TOK_INVALID:
                   3166:       *eventPP = next;
                   3167:       return XML_ERROR_INVALID_TOKEN;
                   3168:     case XML_TOK_PARTIAL_CHAR:
                   3169:       if (haveMore) {
                   3170:         *nextPtr = s;
                   3171:         return XML_ERROR_NONE;
                   3172:       }
                   3173:       return XML_ERROR_PARTIAL_CHAR;
                   3174:     case XML_TOK_PARTIAL:
                   3175:     case XML_TOK_NONE:
                   3176:       if (haveMore) {
                   3177:         *nextPtr = s;
                   3178:         return XML_ERROR_NONE;
                   3179:       }
                   3180:       return XML_ERROR_UNCLOSED_CDATA_SECTION;
                   3181:     default:
                   3182:       *eventPP = next;
                   3183:       return XML_ERROR_UNEXPECTED_STATE;
                   3184:     }
                   3185: 
                   3186:     *eventPP = s = next;
                   3187:     switch (ps_parsing) {
                   3188:     case XML_SUSPENDED:
                   3189:       *nextPtr = next;
                   3190:       return XML_ERROR_NONE;
                   3191:     case XML_FINISHED:
                   3192:       return XML_ERROR_ABORTED;
                   3193:     default: ;
                   3194:     }
                   3195:   }
                   3196:   /* not reached */
                   3197: }
                   3198: 
                   3199: #ifdef XML_DTD
                   3200: 
                   3201: /* The idea here is to avoid using stack for each IGNORE section when
                   3202:    the whole file is parsed with one call.
                   3203: */
                   3204: static enum XML_Error PTRCALL
                   3205: ignoreSectionProcessor(XML_Parser parser,
                   3206:                        const char *start,
                   3207:                        const char *end,
                   3208:                        const char **endPtr)
                   3209: {
                   3210:   enum XML_Error result = doIgnoreSection(parser, encoding, &start, end, 
                   3211:                                           endPtr, (XML_Bool)!ps_finalBuffer);
                   3212:   if (result != XML_ERROR_NONE)
                   3213:     return result;
                   3214:   if (start) {
                   3215:     processor = prologProcessor;
                   3216:     return prologProcessor(parser, start, end, endPtr);
                   3217:   }
                   3218:   return result;
                   3219: }
                   3220: 
                   3221: /* startPtr gets set to non-null is the section is closed, and to null
                   3222:    if the section is not yet closed.
                   3223: */
                   3224: static enum XML_Error
                   3225: doIgnoreSection(XML_Parser parser,
                   3226:                 const ENCODING *enc,
                   3227:                 const char **startPtr,
                   3228:                 const char *end,
                   3229:                 const char **nextPtr,
                   3230:                 XML_Bool haveMore)
                   3231: {
                   3232:   const char *next;
                   3233:   int tok;
                   3234:   const char *s = *startPtr;
                   3235:   const char **eventPP;
                   3236:   const char **eventEndPP;
                   3237:   if (enc == encoding) {
                   3238:     eventPP = &eventPtr;
                   3239:     *eventPP = s;
                   3240:     eventEndPP = &eventEndPtr;
                   3241:   }
                   3242:   else {
                   3243:     eventPP = &(openInternalEntities->internalEventPtr);
                   3244:     eventEndPP = &(openInternalEntities->internalEventEndPtr);
                   3245:   }
                   3246:   *eventPP = s;
                   3247:   *startPtr = NULL;
                   3248:   tok = XmlIgnoreSectionTok(enc, s, end, &next);
                   3249:   *eventEndPP = next;
                   3250:   switch (tok) {
                   3251:   case XML_TOK_IGNORE_SECT:
                   3252:     if (defaultHandler)
                   3253:       reportDefault(parser, enc, s, next);
                   3254:     *startPtr = next;
                   3255:     *nextPtr = next;
                   3256:     if (ps_parsing == XML_FINISHED)
                   3257:       return XML_ERROR_ABORTED;
                   3258:     else
                   3259:       return XML_ERROR_NONE;
                   3260:   case XML_TOK_INVALID:
                   3261:     *eventPP = next;
                   3262:     return XML_ERROR_INVALID_TOKEN;
                   3263:   case XML_TOK_PARTIAL_CHAR:
                   3264:     if (haveMore) {
                   3265:       *nextPtr = s;
                   3266:       return XML_ERROR_NONE;
                   3267:     }
                   3268:     return XML_ERROR_PARTIAL_CHAR;
                   3269:   case XML_TOK_PARTIAL:
                   3270:   case XML_TOK_NONE:
                   3271:     if (haveMore) {
                   3272:       *nextPtr = s;
                   3273:       return XML_ERROR_NONE;
                   3274:     }
                   3275:     return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */
                   3276:   default:
                   3277:     *eventPP = next;
                   3278:     return XML_ERROR_UNEXPECTED_STATE;
                   3279:   }
                   3280:   /* not reached */
                   3281: }
                   3282: 
                   3283: #endif /* XML_DTD */
                   3284: 
                   3285: static enum XML_Error
                   3286: initializeEncoding(XML_Parser parser)
                   3287: {
                   3288:   const char *s;
                   3289: #ifdef XML_UNICODE
                   3290:   char encodingBuf[128];
                   3291:   if (!protocolEncodingName)
                   3292:     s = NULL;
                   3293:   else {
                   3294:     int i;
                   3295:     for (i = 0; protocolEncodingName[i]; i++) {
                   3296:       if (i == sizeof(encodingBuf) - 1
                   3297:           || (protocolEncodingName[i] & ~0x7f) != 0) {
                   3298:         encodingBuf[0] = '\0';
                   3299:         break;
                   3300:       }
                   3301:       encodingBuf[i] = (char)protocolEncodingName[i];
                   3302:     }
                   3303:     encodingBuf[i] = '\0';
                   3304:     s = encodingBuf;
                   3305:   }
                   3306: #else
                   3307:   s = protocolEncodingName;
                   3308: #endif
                   3309:   if ((ns ? XmlInitEncodingNS : XmlInitEncoding)(&initEncoding, &encoding, s))
                   3310:     return XML_ERROR_NONE;
                   3311:   return handleUnknownEncoding(parser, protocolEncodingName);
                   3312: }
                   3313: 
                   3314: static enum XML_Error
                   3315: processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
                   3316:                const char *s, const char *next)
                   3317: {
                   3318:   const char *encodingName = NULL;
                   3319:   const XML_Char *storedEncName = NULL;
                   3320:   const ENCODING *newEncoding = NULL;
                   3321:   const char *version = NULL;
                   3322:   const char *versionend;
                   3323:   const XML_Char *storedversion = NULL;
                   3324:   int standalone = -1;
                   3325:   if (!(ns
                   3326:         ? XmlParseXmlDeclNS
                   3327:         : XmlParseXmlDecl)(isGeneralTextEntity,
                   3328:                            encoding,
                   3329:                            s,
                   3330:                            next,
                   3331:                            &eventPtr,
                   3332:                            &version,
                   3333:                            &versionend,
                   3334:                            &encodingName,
                   3335:                            &newEncoding,
                   3336:                            &standalone)) {
                   3337:     if (isGeneralTextEntity)
                   3338:       return XML_ERROR_TEXT_DECL;
                   3339:     else
                   3340:       return XML_ERROR_XML_DECL;
                   3341:   }
                   3342:   if (!isGeneralTextEntity && standalone == 1) {
                   3343:     _dtd->standalone = XML_TRUE;
                   3344: #ifdef XML_DTD
                   3345:     if (paramEntityParsing == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
                   3346:       paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
                   3347: #endif /* XML_DTD */
                   3348:   }
                   3349:   if (xmlDeclHandler) {
                   3350:     if (encodingName != NULL) {
                   3351:       storedEncName = poolStoreString(&temp2Pool,
                   3352:                                       encoding,
                   3353:                                       encodingName,
                   3354:                                       encodingName
                   3355:                                       + XmlNameLength(encoding, encodingName));
                   3356:       if (!storedEncName)
                   3357:               return XML_ERROR_NO_MEMORY;
                   3358:       poolFinish(&temp2Pool);
                   3359:     }
                   3360:     if (version) {
                   3361:       storedversion = poolStoreString(&temp2Pool,
                   3362:                                       encoding,
                   3363:                                       version,
                   3364:                                       versionend - encoding->minBytesPerChar);
                   3365:       if (!storedversion)
                   3366:         return XML_ERROR_NO_MEMORY;
                   3367:     }
                   3368:     xmlDeclHandler(handlerArg, storedversion, storedEncName, standalone);
                   3369:   }
                   3370:   else if (defaultHandler)
                   3371:     reportDefault(parser, encoding, s, next);
                   3372:   if (protocolEncodingName == NULL) {
                   3373:     if (newEncoding) {
                   3374:       if (newEncoding->minBytesPerChar != encoding->minBytesPerChar) {
                   3375:         eventPtr = encodingName;
                   3376:         return XML_ERROR_INCORRECT_ENCODING;
                   3377:       }
                   3378:       encoding = newEncoding;
                   3379:     }
                   3380:     else if (encodingName) {
                   3381:       enum XML_Error result;
                   3382:       if (!storedEncName) {
                   3383:         storedEncName = poolStoreString(
                   3384:           &temp2Pool, encoding, encodingName,
                   3385:           encodingName + XmlNameLength(encoding, encodingName));
                   3386:         if (!storedEncName)
                   3387:           return XML_ERROR_NO_MEMORY;
                   3388:       }
                   3389:       result = handleUnknownEncoding(parser, storedEncName);
                   3390:       poolClear(&temp2Pool);
                   3391:       if (result == XML_ERROR_UNKNOWN_ENCODING)
                   3392:         eventPtr = encodingName;
                   3393:       return result;
                   3394:     }
                   3395:   }
                   3396: 
                   3397:   if (storedEncName || storedversion)
                   3398:     poolClear(&temp2Pool);
                   3399: 
                   3400:   return XML_ERROR_NONE;
                   3401: }
                   3402: 
                   3403: static enum XML_Error
                   3404: handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName)
                   3405: {
                   3406:   if (unknownEncodingHandler) {
                   3407:     XML_Encoding info;
                   3408:     int i;
                   3409:     for (i = 0; i < 256; i++)
                   3410:       info.map[i] = -1;
                   3411:     info.convert = NULL;
                   3412:     info.data = NULL;
                   3413:     info.release = NULL;
                   3414:     if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName,
                   3415:                                &info)) {
                   3416:       ENCODING *enc;
                   3417:       unknownEncodingMem = MALLOC(XmlSizeOfUnknownEncoding());
                   3418:       if (!unknownEncodingMem) {
                   3419:         if (info.release)
                   3420:           info.release(info.data);
                   3421:         return XML_ERROR_NO_MEMORY;
                   3422:       }
                   3423:       enc = (ns
                   3424:              ? XmlInitUnknownEncodingNS
                   3425:              : XmlInitUnknownEncoding)(unknownEncodingMem,
                   3426:                                        info.map,
                   3427:                                        info.convert,
                   3428:                                        info.data);
                   3429:       if (enc) {
                   3430:         unknownEncodingData = info.data;
                   3431:         unknownEncodingRelease = info.release;
                   3432:         encoding = enc;
                   3433:         return XML_ERROR_NONE;
                   3434:       }
                   3435:     }
                   3436:     if (info.release != NULL)
                   3437:       info.release(info.data);
                   3438:   }
                   3439:   return XML_ERROR_UNKNOWN_ENCODING;
                   3440: }
                   3441: 
                   3442: static enum XML_Error PTRCALL
                   3443: prologInitProcessor(XML_Parser parser,
                   3444:                     const char *s,
                   3445:                     const char *end,
                   3446:                     const char **nextPtr)
                   3447: {
                   3448:   enum XML_Error result = initializeEncoding(parser);
                   3449:   if (result != XML_ERROR_NONE)
                   3450:     return result;
                   3451:   processor = prologProcessor;
                   3452:   return prologProcessor(parser, s, end, nextPtr);
                   3453: }
                   3454: 
                   3455: #ifdef XML_DTD
                   3456: 
                   3457: static enum XML_Error PTRCALL
                   3458: externalParEntInitProcessor(XML_Parser parser,
                   3459:                             const char *s,
                   3460:                             const char *end,
                   3461:                             const char **nextPtr)
                   3462: {
                   3463:   enum XML_Error result = initializeEncoding(parser);
                   3464:   if (result != XML_ERROR_NONE)
                   3465:     return result;
                   3466: 
                   3467:   /* we know now that XML_Parse(Buffer) has been called,
                   3468:      so we consider the external parameter entity read */
                   3469:   _dtd->paramEntityRead = XML_TRUE;
                   3470: 
                   3471:   if (prologState.inEntityValue) {
                   3472:     processor = entityValueInitProcessor;
                   3473:     return entityValueInitProcessor(parser, s, end, nextPtr);
                   3474:   }
                   3475:   else {
                   3476:     processor = externalParEntProcessor;
                   3477:     return externalParEntProcessor(parser, s, end, nextPtr);
                   3478:   }
                   3479: }
                   3480: 
                   3481: static enum XML_Error PTRCALL
                   3482: entityValueInitProcessor(XML_Parser parser,
                   3483:                          const char *s,
                   3484:                          const char *end,
                   3485:                          const char **nextPtr)
                   3486: {
                   3487:   int tok;
                   3488:   const char *start = s;
                   3489:   const char *next = start;
                   3490:   eventPtr = start;
                   3491: 
                   3492:   for (;;) {  
                   3493:     tok = XmlPrologTok(encoding, start, end, &next);
                   3494:     eventEndPtr = next;
                   3495:     if (tok <= 0) {
                   3496:       if (!ps_finalBuffer && tok != XML_TOK_INVALID) {
                   3497:         *nextPtr = s;
                   3498:         return XML_ERROR_NONE;
                   3499:       }
                   3500:       switch (tok) {
                   3501:       case XML_TOK_INVALID:
                   3502:         return XML_ERROR_INVALID_TOKEN;
                   3503:       case XML_TOK_PARTIAL:
                   3504:         return XML_ERROR_UNCLOSED_TOKEN;
                   3505:       case XML_TOK_PARTIAL_CHAR:
                   3506:         return XML_ERROR_PARTIAL_CHAR;
                   3507:       case XML_TOK_NONE:   /* start == end */
                   3508:       default:
                   3509:         break;
                   3510:       }
                   3511:       /* found end of entity value - can store it now */
                   3512:       return storeEntityValue(parser, encoding, s, end);
                   3513:     }
                   3514:     else if (tok == XML_TOK_XML_DECL) {
                   3515:       enum XML_Error result;
                   3516:       result = processXmlDecl(parser, 0, start, next);
                   3517:       if (result != XML_ERROR_NONE)
                   3518:         return result;
                   3519:       switch (ps_parsing) {
                   3520:       case XML_SUSPENDED: 
                   3521:         *nextPtr = next;
                   3522:         return XML_ERROR_NONE;
                   3523:       case XML_FINISHED:
                   3524:         return XML_ERROR_ABORTED;
                   3525:       default:
                   3526:         *nextPtr = next;
                   3527:       }
                   3528:       /* stop scanning for text declaration - we found one */
                   3529:       processor = entityValueProcessor;
                   3530:       return entityValueProcessor(parser, next, end, nextPtr);
                   3531:     }
                   3532:     /* If we are at the end of the buffer, this would cause XmlPrologTok to
                   3533:        return XML_TOK_NONE on the next call, which would then cause the
                   3534:        function to exit with *nextPtr set to s - that is what we want for other
                   3535:        tokens, but not for the BOM - we would rather like to skip it;
                   3536:        then, when this routine is entered the next time, XmlPrologTok will
                   3537:        return XML_TOK_INVALID, since the BOM is still in the buffer
                   3538:     */
                   3539:     else if (tok == XML_TOK_BOM && next == end && !ps_finalBuffer) {
                   3540:       *nextPtr = next;
                   3541:       return XML_ERROR_NONE;
                   3542:     }
                   3543:     start = next;
                   3544:     eventPtr = start;
                   3545:   }
                   3546: }
                   3547: 
                   3548: static enum XML_Error PTRCALL
                   3549: externalParEntProcessor(XML_Parser parser,
                   3550:                         const char *s,
                   3551:                         const char *end,
                   3552:                         const char **nextPtr)
                   3553: {
                   3554:   const char *next = s;
                   3555:   int tok;
                   3556: 
                   3557:   tok = XmlPrologTok(encoding, s, end, &next);
                   3558:   if (tok <= 0) {
                   3559:     if (!ps_finalBuffer && tok != XML_TOK_INVALID) {
                   3560:       *nextPtr = s;
                   3561:       return XML_ERROR_NONE;
                   3562:     }
                   3563:     switch (tok) {
                   3564:     case XML_TOK_INVALID:
                   3565:       return XML_ERROR_INVALID_TOKEN;
                   3566:     case XML_TOK_PARTIAL:
                   3567:       return XML_ERROR_UNCLOSED_TOKEN;
                   3568:     case XML_TOK_PARTIAL_CHAR:
                   3569:       return XML_ERROR_PARTIAL_CHAR;
                   3570:     case XML_TOK_NONE:   /* start == end */
                   3571:     default:
                   3572:       break;
                   3573:     }
                   3574:   }
                   3575:   /* This would cause the next stage, i.e. doProlog to be passed XML_TOK_BOM.
                   3576:      However, when parsing an external subset, doProlog will not accept a BOM
                   3577:      as valid, and report a syntax error, so we have to skip the BOM
                   3578:   */
                   3579:   else if (tok == XML_TOK_BOM) {
                   3580:     s = next;
                   3581:     tok = XmlPrologTok(encoding, s, end, &next);
                   3582:   }
                   3583: 
                   3584:   processor = prologProcessor;
                   3585:   return doProlog(parser, encoding, s, end, tok, next, 
                   3586:                   nextPtr, (XML_Bool)!ps_finalBuffer);
                   3587: }
                   3588: 
                   3589: static enum XML_Error PTRCALL
                   3590: entityValueProcessor(XML_Parser parser,
                   3591:                      const char *s,
                   3592:                      const char *end,
                   3593:                      const char **nextPtr)
                   3594: {
                   3595:   const char *start = s;
                   3596:   const char *next = s;
                   3597:   const ENCODING *enc = encoding;
                   3598:   int tok;
                   3599: 
                   3600:   for (;;) {
                   3601:     tok = XmlPrologTok(enc, start, end, &next);
                   3602:     if (tok <= 0) {
                   3603:       if (!ps_finalBuffer && tok != XML_TOK_INVALID) {
                   3604:         *nextPtr = s;
                   3605:         return XML_ERROR_NONE;
                   3606:       }
                   3607:       switch (tok) {
                   3608:       case XML_TOK_INVALID:
                   3609:         return XML_ERROR_INVALID_TOKEN;
                   3610:       case XML_TOK_PARTIAL:
                   3611:         return XML_ERROR_UNCLOSED_TOKEN;
                   3612:       case XML_TOK_PARTIAL_CHAR:
                   3613:         return XML_ERROR_PARTIAL_CHAR;
                   3614:       case XML_TOK_NONE:   /* start == end */
                   3615:       default:
                   3616:         break;
                   3617:       }
                   3618:       /* found end of entity value - can store it now */
                   3619:       return storeEntityValue(parser, enc, s, end);
                   3620:     }
                   3621:     start = next;
                   3622:   }
                   3623: }
                   3624: 
                   3625: #endif /* XML_DTD */
                   3626: 
                   3627: static enum XML_Error PTRCALL
                   3628: prologProcessor(XML_Parser parser,
                   3629:                 const char *s,
                   3630:                 const char *end,
                   3631:                 const char **nextPtr)
                   3632: {
                   3633:   const char *next = s;
                   3634:   int tok = XmlPrologTok(encoding, s, end, &next);
                   3635:   return doProlog(parser, encoding, s, end, tok, next, 
                   3636:                   nextPtr, (XML_Bool)!ps_finalBuffer);
                   3637: }
                   3638: 
                   3639: static enum XML_Error
                   3640: doProlog(XML_Parser parser,
                   3641:          const ENCODING *enc,
                   3642:          const char *s,
                   3643:          const char *end,
                   3644:          int tok,
                   3645:          const char *next,
                   3646:          const char **nextPtr,
                   3647:          XML_Bool haveMore)
                   3648: {
                   3649: #ifdef XML_DTD
                   3650:   static const XML_Char externalSubsetName[] = { ASCII_HASH , '\0' };
                   3651: #endif /* XML_DTD */
                   3652:   static const XML_Char atypeCDATA[] = 
                   3653:       { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
                   3654:   static const XML_Char atypeID[] = { ASCII_I, ASCII_D, '\0' };
                   3655:   static const XML_Char atypeIDREF[] =
                   3656:       { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
                   3657:   static const XML_Char atypeIDREFS[] =
                   3658:       { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
                   3659:   static const XML_Char atypeENTITY[] =
                   3660:       { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
                   3661:   static const XML_Char atypeENTITIES[] = { ASCII_E, ASCII_N,
                   3662:       ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, '\0' };
                   3663:   static const XML_Char atypeNMTOKEN[] = {
                   3664:       ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
                   3665:   static const XML_Char atypeNMTOKENS[] = { ASCII_N, ASCII_M, ASCII_T,
                   3666:       ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, '\0' };
                   3667:   static const XML_Char notationPrefix[] = { ASCII_N, ASCII_O, ASCII_T,
                   3668:       ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0' };
                   3669:   static const XML_Char enumValueSep[] = { ASCII_PIPE, '\0' };
                   3670:   static const XML_Char enumValueStart[] = { ASCII_LPAREN, '\0' };
                   3671: 
                   3672:   /* save one level of indirection */
                   3673:   DTD * const dtd = _dtd; 
                   3674: 
                   3675:   const char **eventPP;
                   3676:   const char **eventEndPP;
                   3677:   enum XML_Content_Quant quant;
                   3678: 
                   3679:   if (enc == encoding) {
                   3680:     eventPP = &eventPtr;
                   3681:     eventEndPP = &eventEndPtr;
                   3682:   }
                   3683:   else {
                   3684:     eventPP = &(openInternalEntities->internalEventPtr);
                   3685:     eventEndPP = &(openInternalEntities->internalEventEndPtr);
                   3686:   }
                   3687: 
                   3688:   for (;;) {
                   3689:     int role;
                   3690:     XML_Bool handleDefault = XML_TRUE;
                   3691:     *eventPP = s;
                   3692:     *eventEndPP = next;
                   3693:     if (tok <= 0) {
                   3694:       if (haveMore && tok != XML_TOK_INVALID) {
                   3695:         *nextPtr = s;
                   3696:         return XML_ERROR_NONE;
                   3697:       }
                   3698:       switch (tok) {
                   3699:       case XML_TOK_INVALID:
                   3700:         *eventPP = next;
                   3701:         return XML_ERROR_INVALID_TOKEN;
                   3702:       case XML_TOK_PARTIAL:
                   3703:         return XML_ERROR_UNCLOSED_TOKEN;
                   3704:       case XML_TOK_PARTIAL_CHAR:
                   3705:         return XML_ERROR_PARTIAL_CHAR;
                   3706:       case XML_TOK_NONE:
                   3707: #ifdef XML_DTD
                   3708:         /* for internal PE NOT referenced between declarations */
                   3709:         if (enc != encoding && !openInternalEntities->betweenDecl) {
                   3710:           *nextPtr = s;
                   3711:           return XML_ERROR_NONE;
                   3712:         }
                   3713:         /* WFC: PE Between Declarations - must check that PE contains
                   3714:            complete markup, not only for external PEs, but also for
                   3715:            internal PEs if the reference occurs between declarations.
                   3716:         */
                   3717:         if (isParamEntity || enc != encoding) {
                   3718:           if (XmlTokenRole(&prologState, XML_TOK_NONE, end, end, enc)
                   3719:               == XML_ROLE_ERROR)
                   3720:             return XML_ERROR_INCOMPLETE_PE;
                   3721:           *nextPtr = s;
                   3722:           return XML_ERROR_NONE;
                   3723:         }
                   3724: #endif /* XML_DTD */
                   3725:         return XML_ERROR_NO_ELEMENTS;
                   3726:       default:
                   3727:         tok = -tok;
                   3728:         next = end;
                   3729:         break;
                   3730:       }
                   3731:     }
                   3732:     role = XmlTokenRole(&prologState, tok, s, next, enc);
                   3733:     switch (role) {
                   3734:     case XML_ROLE_XML_DECL:
                   3735:       {
                   3736:         enum XML_Error result = processXmlDecl(parser, 0, s, next);
                   3737:         if (result != XML_ERROR_NONE)
                   3738:           return result;
                   3739:         enc = encoding;
                   3740:         handleDefault = XML_FALSE;
                   3741:       }
                   3742:       break;
                   3743:     case XML_ROLE_DOCTYPE_NAME:
                   3744:       if (startDoctypeDeclHandler) {
                   3745:         doctypeName = poolStoreString(&tempPool, enc, s, next);
                   3746:         if (!doctypeName)
                   3747:           return XML_ERROR_NO_MEMORY;
                   3748:         poolFinish(&tempPool);
                   3749:         doctypePubid = NULL;
                   3750:         handleDefault = XML_FALSE;
                   3751:       }
                   3752:       doctypeSysid = NULL; /* always initialize to NULL */
                   3753:       break;
                   3754:     case XML_ROLE_DOCTYPE_INTERNAL_SUBSET:
                   3755:       if (startDoctypeDeclHandler) {
                   3756:         startDoctypeDeclHandler(handlerArg, doctypeName, doctypeSysid,
                   3757:                                 doctypePubid, 1);
                   3758:         doctypeName = NULL;
                   3759:         poolClear(&tempPool);
                   3760:         handleDefault = XML_FALSE;
                   3761:       }
                   3762:       break;
                   3763: #ifdef XML_DTD
                   3764:     case XML_ROLE_TEXT_DECL:
                   3765:       {
                   3766:         enum XML_Error result = processXmlDecl(parser, 1, s, next);
                   3767:         if (result != XML_ERROR_NONE)
                   3768:           return result;
                   3769:         enc = encoding;
                   3770:         handleDefault = XML_FALSE;
                   3771:       }
                   3772:       break;
                   3773: #endif /* XML_DTD */
                   3774:     case XML_ROLE_DOCTYPE_PUBLIC_ID:
                   3775: #ifdef XML_DTD
                   3776:       useForeignDTD = XML_FALSE;
                   3777:       declEntity = (ENTITY *)lookup(&dtd->paramEntities,
                   3778:                                     externalSubsetName,
                   3779:                                     sizeof(ENTITY));
                   3780:       if (!declEntity)
                   3781:         return XML_ERROR_NO_MEMORY;
                   3782: #endif /* XML_DTD */
                   3783:       dtd->hasParamEntityRefs = XML_TRUE;
                   3784:       if (startDoctypeDeclHandler) {
                   3785:         if (!XmlIsPublicId(enc, s, next, eventPP))
                   3786:           return XML_ERROR_PUBLICID;
                   3787:         doctypePubid = poolStoreString(&tempPool, enc,
                   3788:                                        s + enc->minBytesPerChar,
                   3789:                                        next - enc->minBytesPerChar);
                   3790:         if (!doctypePubid)
                   3791:           return XML_ERROR_NO_MEMORY;
                   3792:         normalizePublicId((XML_Char *)doctypePubid);
                   3793:         poolFinish(&tempPool);
                   3794:         handleDefault = XML_FALSE;
                   3795:         goto alreadyChecked;
                   3796:       }
                   3797:       /* fall through */
                   3798:     case XML_ROLE_ENTITY_PUBLIC_ID:
                   3799:       if (!XmlIsPublicId(enc, s, next, eventPP))
                   3800:         return XML_ERROR_PUBLICID;
                   3801:     alreadyChecked:
                   3802:       if (dtd->keepProcessing && declEntity) {
                   3803:         XML_Char *tem = poolStoreString(&dtd->pool,
                   3804:                                         enc,
                   3805:                                         s + enc->minBytesPerChar,
                   3806:                                         next - enc->minBytesPerChar);
                   3807:         if (!tem)
                   3808:           return XML_ERROR_NO_MEMORY;
                   3809:         normalizePublicId(tem);
                   3810:         declEntity->publicId = tem;
                   3811:         poolFinish(&dtd->pool);
                   3812:         if (entityDeclHandler)
                   3813:           handleDefault = XML_FALSE;
                   3814:       }
                   3815:       break;
                   3816:     case XML_ROLE_DOCTYPE_CLOSE:
                   3817:       if (doctypeName) {
                   3818:         startDoctypeDeclHandler(handlerArg, doctypeName,
                   3819:                                 doctypeSysid, doctypePubid, 0);
                   3820:         poolClear(&tempPool);
                   3821:         handleDefault = XML_FALSE;
                   3822:       }
                   3823:       /* doctypeSysid will be non-NULL in the case of a previous
                   3824:          XML_ROLE_DOCTYPE_SYSTEM_ID, even if startDoctypeDeclHandler
                   3825:          was not set, indicating an external subset
                   3826:       */
                   3827: #ifdef XML_DTD
                   3828:       if (doctypeSysid || useForeignDTD) {
                   3829:         XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
                   3830:         dtd->hasParamEntityRefs = XML_TRUE;
                   3831:         if (paramEntityParsing && externalEntityRefHandler) {
                   3832:           ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,
                   3833:                                             externalSubsetName,
                   3834:                                             sizeof(ENTITY));
                   3835:           if (!entity)
                   3836:             return XML_ERROR_NO_MEMORY;
                   3837:           if (useForeignDTD)
                   3838:             entity->base = curBase;
                   3839:           dtd->paramEntityRead = XML_FALSE;
                   3840:           if (!externalEntityRefHandler(externalEntityRefHandlerArg,
                   3841:                                         0,
                   3842:                                         entity->base,
                   3843:                                         entity->systemId,
                   3844:                                         entity->publicId))
                   3845:             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
                   3846:           if (dtd->paramEntityRead) {
                   3847:             if (!dtd->standalone && 
                   3848:                 notStandaloneHandler && 
                   3849:                 !notStandaloneHandler(handlerArg))
                   3850:               return XML_ERROR_NOT_STANDALONE;
                   3851:           }
                   3852:           /* if we didn't read the foreign DTD then this means that there
                   3853:              is no external subset and we must reset dtd->hasParamEntityRefs
                   3854:           */
                   3855:           else if (!doctypeSysid)
                   3856:             dtd->hasParamEntityRefs = hadParamEntityRefs;
                   3857:           /* end of DTD - no need to update dtd->keepProcessing */
                   3858:         }
                   3859:         useForeignDTD = XML_FALSE;
                   3860:       }
                   3861: #endif /* XML_DTD */
                   3862:       if (endDoctypeDeclHandler) {
                   3863:         endDoctypeDeclHandler(handlerArg);
                   3864:         handleDefault = XML_FALSE;
                   3865:       }
                   3866:       break;
                   3867:     case XML_ROLE_INSTANCE_START:
                   3868: #ifdef XML_DTD
                   3869:       /* if there is no DOCTYPE declaration then now is the
                   3870:          last chance to read the foreign DTD
                   3871:       */
                   3872:       if (useForeignDTD) {
                   3873:         XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
                   3874:         dtd->hasParamEntityRefs = XML_TRUE;
                   3875:         if (paramEntityParsing && externalEntityRefHandler) {
                   3876:           ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,
                   3877:                                             externalSubsetName,
                   3878:                                             sizeof(ENTITY));
                   3879:           if (!entity)
                   3880:             return XML_ERROR_NO_MEMORY;
                   3881:           entity->base = curBase;
                   3882:           dtd->paramEntityRead = XML_FALSE;
                   3883:           if (!externalEntityRefHandler(externalEntityRefHandlerArg,
                   3884:                                         0,
                   3885:                                         entity->base,
                   3886:                                         entity->systemId,
                   3887:                                         entity->publicId))
                   3888:             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
                   3889:           if (dtd->paramEntityRead) {
                   3890:             if (!dtd->standalone &&
                   3891:                 notStandaloneHandler &&
                   3892:                 !notStandaloneHandler(handlerArg))
                   3893:               return XML_ERROR_NOT_STANDALONE;
                   3894:           }
                   3895:           /* if we didn't read the foreign DTD then this means that there
                   3896:              is no external subset and we must reset dtd->hasParamEntityRefs
                   3897:           */
                   3898:           else
                   3899:             dtd->hasParamEntityRefs = hadParamEntityRefs;
                   3900:           /* end of DTD - no need to update dtd->keepProcessing */
                   3901:         }
                   3902:       }
                   3903: #endif /* XML_DTD */
                   3904:       processor = contentProcessor;
                   3905:       return contentProcessor(parser, s, end, nextPtr);
                   3906:     case XML_ROLE_ATTLIST_ELEMENT_NAME:
                   3907:       declElementType = getElementType(parser, enc, s, next);
                   3908:       if (!declElementType)
                   3909:         return XML_ERROR_NO_MEMORY;
                   3910:       goto checkAttListDeclHandler;
                   3911:     case XML_ROLE_ATTRIBUTE_NAME:
                   3912:       declAttributeId = getAttributeId(parser, enc, s, next);
                   3913:       if (!declAttributeId)
                   3914:         return XML_ERROR_NO_MEMORY;
                   3915:       declAttributeIsCdata = XML_FALSE;
                   3916:       declAttributeType = NULL;
                   3917:       declAttributeIsId = XML_FALSE;
                   3918:       goto checkAttListDeclHandler;
                   3919:     case XML_ROLE_ATTRIBUTE_TYPE_CDATA:
                   3920:       declAttributeIsCdata = XML_TRUE;
                   3921:       declAttributeType = atypeCDATA;
                   3922:       goto checkAttListDeclHandler;
                   3923:     case XML_ROLE_ATTRIBUTE_TYPE_ID:
                   3924:       declAttributeIsId = XML_TRUE;
                   3925:       declAttributeType = atypeID;
                   3926:       goto checkAttListDeclHandler;
                   3927:     case XML_ROLE_ATTRIBUTE_TYPE_IDREF:
                   3928:       declAttributeType = atypeIDREF;
                   3929:       goto checkAttListDeclHandler;
                   3930:     case XML_ROLE_ATTRIBUTE_TYPE_IDREFS:
                   3931:       declAttributeType = atypeIDREFS;
                   3932:       goto checkAttListDeclHandler;
                   3933:     case XML_ROLE_ATTRIBUTE_TYPE_ENTITY:
                   3934:       declAttributeType = atypeENTITY;
                   3935:       goto checkAttListDeclHandler;
                   3936:     case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES:
                   3937:       declAttributeType = atypeENTITIES;
                   3938:       goto checkAttListDeclHandler;
                   3939:     case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN:
                   3940:       declAttributeType = atypeNMTOKEN;
                   3941:       goto checkAttListDeclHandler;
                   3942:     case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS:
                   3943:       declAttributeType = atypeNMTOKENS;
                   3944:     checkAttListDeclHandler:
                   3945:       if (dtd->keepProcessing && attlistDeclHandler)
                   3946:         handleDefault = XML_FALSE;
                   3947:       break;
                   3948:     case XML_ROLE_ATTRIBUTE_ENUM_VALUE:
                   3949:     case XML_ROLE_ATTRIBUTE_NOTATION_VALUE:
                   3950:       if (dtd->keepProcessing && attlistDeclHandler) {
                   3951:         const XML_Char *prefix;
                   3952:         if (declAttributeType) {
                   3953:           prefix = enumValueSep;
                   3954:         }
                   3955:         else {
                   3956:           prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE
                   3957:                     ? notationPrefix
                   3958:                     : enumValueStart);
                   3959:         }
                   3960:         if (!poolAppendString(&tempPool, prefix))
                   3961:           return XML_ERROR_NO_MEMORY;
                   3962:         if (!poolAppend(&tempPool, enc, s, next))
                   3963:           return XML_ERROR_NO_MEMORY;
                   3964:         declAttributeType = tempPool.start;
                   3965:         handleDefault = XML_FALSE;
                   3966:       }
                   3967:       break;
                   3968:     case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:
                   3969:     case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:
                   3970:       if (dtd->keepProcessing) {
                   3971:         if (!defineAttribute(declElementType, declAttributeId,
                   3972:                              declAttributeIsCdata, declAttributeIsId,
                   3973:                              0, parser))
                   3974:           return XML_ERROR_NO_MEMORY;
                   3975:         if (attlistDeclHandler && declAttributeType) {
                   3976:           if (*declAttributeType == XML_T(ASCII_LPAREN)
                   3977:               || (*declAttributeType == XML_T(ASCII_N)
                   3978:                   && declAttributeType[1] == XML_T(ASCII_O))) {
                   3979:             /* Enumerated or Notation type */
                   3980:             if (!poolAppendChar(&tempPool, XML_T(ASCII_RPAREN))
                   3981:                 || !poolAppendChar(&tempPool, XML_T('\0')))
                   3982:               return XML_ERROR_NO_MEMORY;
                   3983:             declAttributeType = tempPool.start;
                   3984:             poolFinish(&tempPool);
                   3985:           }
                   3986:           *eventEndPP = s;
                   3987:           attlistDeclHandler(handlerArg, declElementType->name,
                   3988:                              declAttributeId->name, declAttributeType,
                   3989:                              0, role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);
                   3990:           poolClear(&tempPool);
                   3991:           handleDefault = XML_FALSE;
                   3992:         }
                   3993:       }
                   3994:       break;
                   3995:     case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
                   3996:     case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
                   3997:       if (dtd->keepProcessing) {
                   3998:         const XML_Char *attVal;
                   3999:         enum XML_Error result =
                   4000:           storeAttributeValue(parser, enc, declAttributeIsCdata,
                   4001:                               s + enc->minBytesPerChar,
                   4002:                               next - enc->minBytesPerChar,
                   4003:                               &dtd->pool);
                   4004:         if (result)
                   4005:           return result;
                   4006:         attVal = poolStart(&dtd->pool);
                   4007:         poolFinish(&dtd->pool);
                   4008:         /* ID attributes aren't allowed to have a default */
                   4009:         if (!defineAttribute(declElementType, declAttributeId,
                   4010:                              declAttributeIsCdata, XML_FALSE, attVal, parser))
                   4011:           return XML_ERROR_NO_MEMORY;
                   4012:         if (attlistDeclHandler && declAttributeType) {
                   4013:           if (*declAttributeType == XML_T(ASCII_LPAREN)
                   4014:               || (*declAttributeType == XML_T(ASCII_N)
                   4015:                   && declAttributeType[1] == XML_T(ASCII_O))) {
                   4016:             /* Enumerated or Notation type */
                   4017:             if (!poolAppendChar(&tempPool, XML_T(ASCII_RPAREN))
                   4018:                 || !poolAppendChar(&tempPool, XML_T('\0')))
                   4019:               return XML_ERROR_NO_MEMORY;
                   4020:             declAttributeType = tempPool.start;
                   4021:             poolFinish(&tempPool);
                   4022:           }
                   4023:           *eventEndPP = s;
                   4024:           attlistDeclHandler(handlerArg, declElementType->name,
                   4025:                              declAttributeId->name, declAttributeType,
                   4026:                              attVal,
                   4027:                              role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);
                   4028:           poolClear(&tempPool);
                   4029:           handleDefault = XML_FALSE;
                   4030:         }
                   4031:       }
                   4032:       break;
                   4033:     case XML_ROLE_ENTITY_VALUE:
                   4034:       if (dtd->keepProcessing) {
                   4035:         enum XML_Error result = storeEntityValue(parser, enc,
                   4036:                                             s + enc->minBytesPerChar,
                   4037:                                             next - enc->minBytesPerChar);
                   4038:         if (declEntity) {
                   4039:           declEntity->textPtr = poolStart(&dtd->entityValuePool);
                   4040:           declEntity->textLen = (int)(poolLength(&dtd->entityValuePool));
                   4041:           poolFinish(&dtd->entityValuePool);
                   4042:           if (entityDeclHandler) {
                   4043:             *eventEndPP = s;
                   4044:             entityDeclHandler(handlerArg,
                   4045:                               declEntity->name,
                   4046:                               declEntity->is_param,
                   4047:                               declEntity->textPtr,
                   4048:                               declEntity->textLen,
                   4049:                               curBase, 0, 0, 0);
                   4050:             handleDefault = XML_FALSE;
                   4051:           }
                   4052:         }
                   4053:         else
                   4054:           poolDiscard(&dtd->entityValuePool);
                   4055:         if (result != XML_ERROR_NONE)
                   4056:           return result;
                   4057:       }
                   4058:       break;
                   4059:     case XML_ROLE_DOCTYPE_SYSTEM_ID:
                   4060: #ifdef XML_DTD
                   4061:       useForeignDTD = XML_FALSE;
                   4062: #endif /* XML_DTD */
                   4063:       dtd->hasParamEntityRefs = XML_TRUE;
                   4064:       if (startDoctypeDeclHandler) {
                   4065:         doctypeSysid = poolStoreString(&tempPool, enc,
                   4066:                                        s + enc->minBytesPerChar,
                   4067:                                        next - enc->minBytesPerChar);
                   4068:         if (doctypeSysid == NULL)
                   4069:           return XML_ERROR_NO_MEMORY;
                   4070:         poolFinish(&tempPool);
                   4071:         handleDefault = XML_FALSE;
                   4072:       }
                   4073: #ifdef XML_DTD
                   4074:       else
                   4075:         /* use externalSubsetName to make doctypeSysid non-NULL
                   4076:            for the case where no startDoctypeDeclHandler is set */
                   4077:         doctypeSysid = externalSubsetName;
                   4078: #endif /* XML_DTD */
                   4079:       if (!dtd->standalone
                   4080: #ifdef XML_DTD
                   4081:           && !paramEntityParsing
                   4082: #endif /* XML_DTD */
                   4083:           && notStandaloneHandler
                   4084:           && !notStandaloneHandler(handlerArg))
                   4085:         return XML_ERROR_NOT_STANDALONE;
                   4086: #ifndef XML_DTD
                   4087:       break;
                   4088: #else /* XML_DTD */
                   4089:       if (!declEntity) {
                   4090:         declEntity = (ENTITY *)lookup(&dtd->paramEntities,
                   4091:                                       externalSubsetName,
                   4092:                                       sizeof(ENTITY));
                   4093:         if (!declEntity)
                   4094:           return XML_ERROR_NO_MEMORY;
                   4095:         declEntity->publicId = NULL;
                   4096:       }
                   4097:       /* fall through */
                   4098: #endif /* XML_DTD */
                   4099:     case XML_ROLE_ENTITY_SYSTEM_ID:
                   4100:       if (dtd->keepProcessing && declEntity) {
                   4101:         declEntity->systemId = poolStoreString(&dtd->pool, enc,
                   4102:                                                s + enc->minBytesPerChar,
                   4103:                                                next - enc->minBytesPerChar);
                   4104:         if (!declEntity->systemId)
                   4105:           return XML_ERROR_NO_MEMORY;
                   4106:         declEntity->base = curBase;
                   4107:         poolFinish(&dtd->pool);
                   4108:         if (entityDeclHandler)
                   4109:           handleDefault = XML_FALSE;
                   4110:       }
                   4111:       break;
                   4112:     case XML_ROLE_ENTITY_COMPLETE:
                   4113:       if (dtd->keepProcessing && declEntity && entityDeclHandler) {
                   4114:         *eventEndPP = s;
                   4115:         entityDeclHandler(handlerArg,
                   4116:                           declEntity->name,
                   4117:                           declEntity->is_param,
                   4118:                           0,0,
                   4119:                           declEntity->base,
                   4120:                           declEntity->systemId,
                   4121:                           declEntity->publicId,
                   4122:                           0);
                   4123:         handleDefault = XML_FALSE;
                   4124:       }
                   4125:       break;
                   4126:     case XML_ROLE_ENTITY_NOTATION_NAME:
                   4127:       if (dtd->keepProcessing && declEntity) {
                   4128:         declEntity->notation = poolStoreString(&dtd->pool, enc, s, next);
                   4129:         if (!declEntity->notation)
                   4130:           return XML_ERROR_NO_MEMORY;
                   4131:         poolFinish(&dtd->pool);
                   4132:         if (unparsedEntityDeclHandler) {
                   4133:           *eventEndPP = s;
                   4134:           unparsedEntityDeclHandler(handlerArg,
                   4135:                                     declEntity->name,
                   4136:                                     declEntity->base,
                   4137:                                     declEntity->systemId,
                   4138:                                     declEntity->publicId,
                   4139:                                     declEntity->notation);
                   4140:           handleDefault = XML_FALSE;
                   4141:         }
                   4142:         else if (entityDeclHandler) {
                   4143:           *eventEndPP = s;
                   4144:           entityDeclHandler(handlerArg,
                   4145:                             declEntity->name,
                   4146:                             0,0,0,
                   4147:                             declEntity->base,
                   4148:                             declEntity->systemId,
                   4149:                             declEntity->publicId,
                   4150:                             declEntity->notation);
                   4151:           handleDefault = XML_FALSE;
                   4152:         }
                   4153:       }
                   4154:       break;
                   4155:     case XML_ROLE_GENERAL_ENTITY_NAME:
                   4156:       {
                   4157:         if (XmlPredefinedEntityName(enc, s, next)) {
                   4158:           declEntity = NULL;
                   4159:           break;
                   4160:         }
                   4161:         if (dtd->keepProcessing) {
                   4162:           const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
                   4163:           if (!name)
                   4164:             return XML_ERROR_NO_MEMORY;
                   4165:           declEntity = (ENTITY *)lookup(&dtd->generalEntities, name,
                   4166:                                         sizeof(ENTITY));
                   4167:           if (!declEntity)
                   4168:             return XML_ERROR_NO_MEMORY;
                   4169:           if (declEntity->name != name) {
                   4170:             poolDiscard(&dtd->pool);
                   4171:             declEntity = NULL;
                   4172:           }
                   4173:           else {
                   4174:             poolFinish(&dtd->pool);
                   4175:             declEntity->publicId = NULL;
                   4176:             declEntity->is_param = XML_FALSE;
                   4177:             /* if we have a parent parser or are reading an internal parameter
                   4178:                entity, then the entity declaration is not considered "internal"
                   4179:             */
                   4180:             declEntity->is_internal = !(parentParser || openInternalEntities);
                   4181:             if (entityDeclHandler)
                   4182:               handleDefault = XML_FALSE;
                   4183:           }
                   4184:         }
                   4185:         else {
                   4186:           poolDiscard(&dtd->pool);
                   4187:           declEntity = NULL;
                   4188:         }
                   4189:       }
                   4190:       break;
                   4191:     case XML_ROLE_PARAM_ENTITY_NAME:
                   4192: #ifdef XML_DTD
                   4193:       if (dtd->keepProcessing) {
                   4194:         const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
                   4195:         if (!name)
                   4196:           return XML_ERROR_NO_MEMORY;
                   4197:         declEntity = (ENTITY *)lookup(&dtd->paramEntities,
                   4198:                                            name, sizeof(ENTITY));
                   4199:         if (!declEntity)
                   4200:           return XML_ERROR_NO_MEMORY;
                   4201:         if (declEntity->name != name) {
                   4202:           poolDiscard(&dtd->pool);
                   4203:           declEntity = NULL;
                   4204:         }
                   4205:         else {
                   4206:           poolFinish(&dtd->pool);
                   4207:           declEntity->publicId = NULL;
                   4208:           declEntity->is_param = XML_TRUE;
                   4209:           /* if we have a parent parser or are reading an internal parameter
                   4210:              entity, then the entity declaration is not considered "internal"
                   4211:           */
                   4212:           declEntity->is_internal = !(parentParser || openInternalEntities);
                   4213:           if (entityDeclHandler)
                   4214:             handleDefault = XML_FALSE;
                   4215:         }
                   4216:       }
                   4217:       else {
                   4218:         poolDiscard(&dtd->pool);
                   4219:         declEntity = NULL;
                   4220:       }
                   4221: #else /* not XML_DTD */
                   4222:       declEntity = NULL;
                   4223: #endif /* XML_DTD */
                   4224:       break;
                   4225:     case XML_ROLE_NOTATION_NAME:
                   4226:       declNotationPublicId = NULL;
                   4227:       declNotationName = NULL;
                   4228:       if (notationDeclHandler) {
                   4229:         declNotationName = poolStoreString(&tempPool, enc, s, next);
                   4230:         if (!declNotationName)
                   4231:           return XML_ERROR_NO_MEMORY;
                   4232:         poolFinish(&tempPool);
                   4233:         handleDefault = XML_FALSE;
                   4234:       }
                   4235:       break;
                   4236:     case XML_ROLE_NOTATION_PUBLIC_ID:
                   4237:       if (!XmlIsPublicId(enc, s, next, eventPP))
                   4238:         return XML_ERROR_PUBLICID;
                   4239:       if (declNotationName) {  /* means notationDeclHandler != NULL */
                   4240:         XML_Char *tem = poolStoreString(&tempPool,
                   4241:                                         enc,
                   4242:                                         s + enc->minBytesPerChar,
                   4243:                                         next - enc->minBytesPerChar);
                   4244:         if (!tem)
                   4245:           return XML_ERROR_NO_MEMORY;
                   4246:         normalizePublicId(tem);
                   4247:         declNotationPublicId = tem;
                   4248:         poolFinish(&tempPool);
                   4249:         handleDefault = XML_FALSE;
                   4250:       }
                   4251:       break;
                   4252:     case XML_ROLE_NOTATION_SYSTEM_ID:
                   4253:       if (declNotationName && notationDeclHandler) {
                   4254:         const XML_Char *systemId
                   4255:           = poolStoreString(&tempPool, enc,
                   4256:                             s + enc->minBytesPerChar,
                   4257:                             next - enc->minBytesPerChar);
                   4258:         if (!systemId)
                   4259:           return XML_ERROR_NO_MEMORY;
                   4260:         *eventEndPP = s;
                   4261:         notationDeclHandler(handlerArg,
                   4262:                             declNotationName,
                   4263:                             curBase,
                   4264:                             systemId,
                   4265:                             declNotationPublicId);
                   4266:         handleDefault = XML_FALSE;
                   4267:       }
                   4268:       poolClear(&tempPool);
                   4269:       break;
                   4270:     case XML_ROLE_NOTATION_NO_SYSTEM_ID:
                   4271:       if (declNotationPublicId && notationDeclHandler) {
                   4272:         *eventEndPP = s;
                   4273:         notationDeclHandler(handlerArg,
                   4274:                             declNotationName,
                   4275:                             curBase,
                   4276:                             0,
                   4277:                             declNotationPublicId);
                   4278:         handleDefault = XML_FALSE;
                   4279:       }
                   4280:       poolClear(&tempPool);
                   4281:       break;
                   4282:     case XML_ROLE_ERROR:
                   4283:       switch (tok) {
                   4284:       case XML_TOK_PARAM_ENTITY_REF:
                   4285:         /* PE references in internal subset are
                   4286:            not allowed within declarations. */  
                   4287:         return XML_ERROR_PARAM_ENTITY_REF;
                   4288:       case XML_TOK_XML_DECL:
                   4289:         return XML_ERROR_MISPLACED_XML_PI;
                   4290:       default:
                   4291:         return XML_ERROR_SYNTAX;
                   4292:       }
                   4293: #ifdef XML_DTD
                   4294:     case XML_ROLE_IGNORE_SECT:
                   4295:       {
                   4296:         enum XML_Error result;
                   4297:         if (defaultHandler)
                   4298:           reportDefault(parser, enc, s, next);
                   4299:         handleDefault = XML_FALSE;
                   4300:         result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
                   4301:         if (result != XML_ERROR_NONE)
                   4302:           return result;
                   4303:         else if (!next) {
                   4304:           processor = ignoreSectionProcessor;
                   4305:           return result;
                   4306:         }
                   4307:       }
                   4308:       break;
                   4309: #endif /* XML_DTD */
                   4310:     case XML_ROLE_GROUP_OPEN:
                   4311:       if (prologState.level >= groupSize) {
                   4312:         if (groupSize) {
                   4313:           char *temp = (char *)REALLOC(groupConnector, groupSize *= 2);
                   4314:           if (temp == NULL)
                   4315:             return XML_ERROR_NO_MEMORY;
                   4316:           groupConnector = temp;
                   4317:           if (dtd->scaffIndex) {
                   4318:             int *temp = (int *)REALLOC(dtd->scaffIndex,
                   4319:                           groupSize * sizeof(int));
                   4320:             if (temp == NULL)
                   4321:               return XML_ERROR_NO_MEMORY;
                   4322:             dtd->scaffIndex = temp;
                   4323:           }
                   4324:         }
                   4325:         else {
                   4326:           groupConnector = (char *)MALLOC(groupSize = 32);
                   4327:           if (!groupConnector)
                   4328:             return XML_ERROR_NO_MEMORY;
                   4329:         }
                   4330:       }
                   4331:       groupConnector[prologState.level] = 0;
                   4332:       if (dtd->in_eldecl) {
                   4333:         int myindex = nextScaffoldPart(parser);
                   4334:         if (myindex < 0)
                   4335:           return XML_ERROR_NO_MEMORY;
                   4336:         dtd->scaffIndex[dtd->scaffLevel] = myindex;
                   4337:         dtd->scaffLevel++;
                   4338:         dtd->scaffold[myindex].type = XML_CTYPE_SEQ;
                   4339:         if (elementDeclHandler)
                   4340:           handleDefault = XML_FALSE;
                   4341:       }
                   4342:       break;
                   4343:     case XML_ROLE_GROUP_SEQUENCE:
                   4344:       if (groupConnector[prologState.level] == ASCII_PIPE)
                   4345:         return XML_ERROR_SYNTAX;
                   4346:       groupConnector[prologState.level] = ASCII_COMMA;
                   4347:       if (dtd->in_eldecl && elementDeclHandler)
                   4348:         handleDefault = XML_FALSE;
                   4349:       break;
                   4350:     case XML_ROLE_GROUP_CHOICE:
                   4351:       if (groupConnector[prologState.level] == ASCII_COMMA)
                   4352:         return XML_ERROR_SYNTAX;
                   4353:       if (dtd->in_eldecl
                   4354:           && !groupConnector[prologState.level]
                   4355:           && (dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
                   4356:               != XML_CTYPE_MIXED)
                   4357:           ) {
                   4358:         dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
                   4359:             = XML_CTYPE_CHOICE;
                   4360:         if (elementDeclHandler)
                   4361:           handleDefault = XML_FALSE;
                   4362:       }
                   4363:       groupConnector[prologState.level] = ASCII_PIPE;
                   4364:       break;
                   4365:     case XML_ROLE_PARAM_ENTITY_REF:
                   4366: #ifdef XML_DTD
                   4367:     case XML_ROLE_INNER_PARAM_ENTITY_REF:
                   4368:       dtd->hasParamEntityRefs = XML_TRUE;
                   4369:       if (!paramEntityParsing)
                   4370:         dtd->keepProcessing = dtd->standalone;
                   4371:       else {
                   4372:         const XML_Char *name;
                   4373:         ENTITY *entity;
                   4374:         name = poolStoreString(&dtd->pool, enc,
                   4375:                                 s + enc->minBytesPerChar,
                   4376:                                 next - enc->minBytesPerChar);
                   4377:         if (!name)
                   4378:           return XML_ERROR_NO_MEMORY;
                   4379:         entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);
                   4380:         poolDiscard(&dtd->pool);
                   4381:         /* first, determine if a check for an existing declaration is needed;
                   4382:            if yes, check that the entity exists, and that it is internal,
                   4383:            otherwise call the skipped entity handler
                   4384:         */
                   4385:         if (prologState.documentEntity &&
                   4386:             (dtd->standalone
                   4387:              ? !openInternalEntities
                   4388:              : !dtd->hasParamEntityRefs)) {
                   4389:           if (!entity)
                   4390:             return XML_ERROR_UNDEFINED_ENTITY;
                   4391:           else if (!entity->is_internal)
                   4392:             return XML_ERROR_ENTITY_DECLARED_IN_PE;
                   4393:         }
                   4394:         else if (!entity) {
                   4395:           dtd->keepProcessing = dtd->standalone;
                   4396:           /* cannot report skipped entities in declarations */
                   4397:           if ((role == XML_ROLE_PARAM_ENTITY_REF) && skippedEntityHandler) {
                   4398:             skippedEntityHandler(handlerArg, name, 1);
                   4399:             handleDefault = XML_FALSE;
                   4400:           }
                   4401:           break;
                   4402:         }
                   4403:         if (entity->open)
                   4404:           return XML_ERROR_RECURSIVE_ENTITY_REF;
                   4405:         if (entity->textPtr) {
                   4406:           enum XML_Error result;
                   4407:           XML_Bool betweenDecl = 
                   4408:             (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);
                   4409:           result = processInternalEntity(parser, entity, betweenDecl);
                   4410:           if (result != XML_ERROR_NONE)
                   4411:             return result;
                   4412:           handleDefault = XML_FALSE;
                   4413:           break;
                   4414:         }
                   4415:         if (externalEntityRefHandler) {
                   4416:           dtd->paramEntityRead = XML_FALSE;
                   4417:           entity->open = XML_TRUE;
                   4418:           if (!externalEntityRefHandler(externalEntityRefHandlerArg,
                   4419:                                         0,
                   4420:                                         entity->base,
                   4421:                                         entity->systemId,
                   4422:                                         entity->publicId)) {
                   4423:             entity->open = XML_FALSE;
                   4424:             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
                   4425:           }
                   4426:           entity->open = XML_FALSE;
                   4427:           handleDefault = XML_FALSE;
                   4428:           if (!dtd->paramEntityRead) {
                   4429:             dtd->keepProcessing = dtd->standalone;
                   4430:             break;
                   4431:           }
                   4432:         }
                   4433:         else {
                   4434:           dtd->keepProcessing = dtd->standalone;
                   4435:           break;
                   4436:         }
                   4437:       }
                   4438: #endif /* XML_DTD */
                   4439:       if (!dtd->standalone &&
                   4440:           notStandaloneHandler &&
                   4441:           !notStandaloneHandler(handlerArg))
                   4442:         return XML_ERROR_NOT_STANDALONE;
                   4443:       break;
                   4444: 
                   4445:     /* Element declaration stuff */
                   4446: 
                   4447:     case XML_ROLE_ELEMENT_NAME:
                   4448:       if (elementDeclHandler) {
                   4449:         declElementType = getElementType(parser, enc, s, next);
                   4450:         if (!declElementType)
                   4451:           return XML_ERROR_NO_MEMORY;
                   4452:         dtd->scaffLevel = 0;
                   4453:         dtd->scaffCount = 0;
                   4454:         dtd->in_eldecl = XML_TRUE;
                   4455:         handleDefault = XML_FALSE;
                   4456:       }
                   4457:       break;
                   4458: 
                   4459:     case XML_ROLE_CONTENT_ANY:
                   4460:     case XML_ROLE_CONTENT_EMPTY:
                   4461:       if (dtd->in_eldecl) {
                   4462:         if (elementDeclHandler) {
                   4463:           XML_Content * content = (XML_Content *) MALLOC(sizeof(XML_Content));
                   4464:           if (!content)
                   4465:             return XML_ERROR_NO_MEMORY;
                   4466:           content->quant = XML_CQUANT_NONE;
                   4467:           content->name = NULL;
                   4468:           content->numchildren = 0;
                   4469:           content->children = NULL;
                   4470:           content->type = ((role == XML_ROLE_CONTENT_ANY) ?
                   4471:                            XML_CTYPE_ANY :
                   4472:                            XML_CTYPE_EMPTY);
                   4473:           *eventEndPP = s;
                   4474:           elementDeclHandler(handlerArg, declElementType->name, content);
                   4475:           handleDefault = XML_FALSE;
                   4476:         }
                   4477:         dtd->in_eldecl = XML_FALSE;
                   4478:       }
                   4479:       break;
                   4480: 
                   4481:     case XML_ROLE_CONTENT_PCDATA:
                   4482:       if (dtd->in_eldecl) {
                   4483:         dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
                   4484:             = XML_CTYPE_MIXED;
                   4485:         if (elementDeclHandler)
                   4486:           handleDefault = XML_FALSE;
                   4487:       }
                   4488:       break;
                   4489: 
                   4490:     case XML_ROLE_CONTENT_ELEMENT:
                   4491:       quant = XML_CQUANT_NONE;
                   4492:       goto elementContent;
                   4493:     case XML_ROLE_CONTENT_ELEMENT_OPT:
                   4494:       quant = XML_CQUANT_OPT;
                   4495:       goto elementContent;
                   4496:     case XML_ROLE_CONTENT_ELEMENT_REP:
                   4497:       quant = XML_CQUANT_REP;
                   4498:       goto elementContent;
                   4499:     case XML_ROLE_CONTENT_ELEMENT_PLUS:
                   4500:       quant = XML_CQUANT_PLUS;
                   4501:     elementContent:
                   4502:       if (dtd->in_eldecl) {
                   4503:         ELEMENT_TYPE *el;
                   4504:         const XML_Char *name;
                   4505:         int nameLen;
                   4506:         const char *nxt = (quant == XML_CQUANT_NONE
                   4507:                            ? next
                   4508:                            : next - enc->minBytesPerChar);
                   4509:         int myindex = nextScaffoldPart(parser);
                   4510:         if (myindex < 0)
                   4511:           return XML_ERROR_NO_MEMORY;
                   4512:         dtd->scaffold[myindex].type = XML_CTYPE_NAME;
                   4513:         dtd->scaffold[myindex].quant = quant;
                   4514:         el = getElementType(parser, enc, s, nxt);
                   4515:         if (!el)
                   4516:           return XML_ERROR_NO_MEMORY;
                   4517:         name = el->name;
                   4518:         dtd->scaffold[myindex].name = name;
                   4519:         nameLen = 0;
                   4520:         for (; name[nameLen++]; );
                   4521:         dtd->contentStringLen +=  nameLen;
                   4522:         if (elementDeclHandler)
                   4523:           handleDefault = XML_FALSE;
                   4524:       }
                   4525:       break;
                   4526: 
                   4527:     case XML_ROLE_GROUP_CLOSE:
                   4528:       quant = XML_CQUANT_NONE;
                   4529:       goto closeGroup;
                   4530:     case XML_ROLE_GROUP_CLOSE_OPT:
                   4531:       quant = XML_CQUANT_OPT;
                   4532:       goto closeGroup;
                   4533:     case XML_ROLE_GROUP_CLOSE_REP:
                   4534:       quant = XML_CQUANT_REP;
                   4535:       goto closeGroup;
                   4536:     case XML_ROLE_GROUP_CLOSE_PLUS:
                   4537:       quant = XML_CQUANT_PLUS;
                   4538:     closeGroup:
                   4539:       if (dtd->in_eldecl) {
                   4540:         if (elementDeclHandler)
                   4541:           handleDefault = XML_FALSE;
                   4542:         dtd->scaffLevel--;
                   4543:         dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel]].quant = quant;
                   4544:         if (dtd->scaffLevel == 0) {
                   4545:           if (!handleDefault) {
                   4546:             XML_Content *model = build_model(parser);
                   4547:             if (!model)
                   4548:               return XML_ERROR_NO_MEMORY;
                   4549:             *eventEndPP = s;
                   4550:             elementDeclHandler(handlerArg, declElementType->name, model);
                   4551:           }
                   4552:           dtd->in_eldecl = XML_FALSE;
                   4553:           dtd->contentStringLen = 0;
                   4554:         }
                   4555:       }
                   4556:       break;
                   4557:       /* End element declaration stuff */
                   4558: 
                   4559:     case XML_ROLE_PI:
                   4560:       if (!reportProcessingInstruction(parser, enc, s, next))
                   4561:         return XML_ERROR_NO_MEMORY;
                   4562:       handleDefault = XML_FALSE;
                   4563:       break;
                   4564:     case XML_ROLE_COMMENT:
                   4565:       if (!reportComment(parser, enc, s, next))
                   4566:         return XML_ERROR_NO_MEMORY;
                   4567:       handleDefault = XML_FALSE;
                   4568:       break;
                   4569:     case XML_ROLE_NONE:
                   4570:       switch (tok) {
                   4571:       case XML_TOK_BOM:
                   4572:         handleDefault = XML_FALSE;
                   4573:         break;
                   4574:       }
                   4575:       break;
                   4576:     case XML_ROLE_DOCTYPE_NONE:
                   4577:       if (startDoctypeDeclHandler)
                   4578:         handleDefault = XML_FALSE;
                   4579:       break;
                   4580:     case XML_ROLE_ENTITY_NONE:
                   4581:       if (dtd->keepProcessing && entityDeclHandler)
                   4582:         handleDefault = XML_FALSE;
                   4583:       break;
                   4584:     case XML_ROLE_NOTATION_NONE:
                   4585:       if (notationDeclHandler)
                   4586:         handleDefault = XML_FALSE;
                   4587:       break;
                   4588:     case XML_ROLE_ATTLIST_NONE:
                   4589:       if (dtd->keepProcessing && attlistDeclHandler)
                   4590:         handleDefault = XML_FALSE;
                   4591:       break;
                   4592:     case XML_ROLE_ELEMENT_NONE:
                   4593:       if (elementDeclHandler)
                   4594:         handleDefault = XML_FALSE;
                   4595:       break;
                   4596:     } /* end of big switch */
                   4597: 
                   4598:     if (handleDefault && defaultHandler)
                   4599:       reportDefault(parser, enc, s, next);
                   4600: 
                   4601:     switch (ps_parsing) {
                   4602:     case XML_SUSPENDED: 
                   4603:       *nextPtr = next;
                   4604:       return XML_ERROR_NONE;
                   4605:     case XML_FINISHED:
                   4606:       return XML_ERROR_ABORTED;
                   4607:     default:
                   4608:       s = next;
                   4609:       tok = XmlPrologTok(enc, s, end, &next);
                   4610:     }
                   4611:   }
                   4612:   /* not reached */
                   4613: }
                   4614: 
                   4615: static enum XML_Error PTRCALL
                   4616: epilogProcessor(XML_Parser parser,
                   4617:                 const char *s,
                   4618:                 const char *end,
                   4619:                 const char **nextPtr)
                   4620: {
                   4621:   processor = epilogProcessor;
                   4622:   eventPtr = s;
                   4623:   for (;;) {
                   4624:     const char *next = NULL;
                   4625:     int tok = XmlPrologTok(encoding, s, end, &next);
                   4626:     eventEndPtr = next;
                   4627:     switch (tok) {
                   4628:     /* report partial linebreak - it might be the last token */
                   4629:     case -XML_TOK_PROLOG_S:
                   4630:       if (defaultHandler) {
                   4631:         reportDefault(parser, encoding, s, next);
                   4632:         if (ps_parsing == XML_FINISHED)
                   4633:           return XML_ERROR_ABORTED;
                   4634:       }
                   4635:       *nextPtr = next;
                   4636:       return XML_ERROR_NONE;
                   4637:     case XML_TOK_NONE:
                   4638:       *nextPtr = s;
                   4639:       return XML_ERROR_NONE;
                   4640:     case XML_TOK_PROLOG_S:
                   4641:       if (defaultHandler)
                   4642:         reportDefault(parser, encoding, s, next);
                   4643:       break;
                   4644:     case XML_TOK_PI:
                   4645:       if (!reportProcessingInstruction(parser, encoding, s, next))
                   4646:         return XML_ERROR_NO_MEMORY;
                   4647:       break;
                   4648:     case XML_TOK_COMMENT:
                   4649:       if (!reportComment(parser, encoding, s, next))
                   4650:         return XML_ERROR_NO_MEMORY;
                   4651:       break;
                   4652:     case XML_TOK_INVALID:
                   4653:       eventPtr = next;
                   4654:       return XML_ERROR_INVALID_TOKEN;
                   4655:     case XML_TOK_PARTIAL:
                   4656:       if (!ps_finalBuffer) {
                   4657:         *nextPtr = s;
                   4658:         return XML_ERROR_NONE;
                   4659:       }
                   4660:       return XML_ERROR_UNCLOSED_TOKEN;
                   4661:     case XML_TOK_PARTIAL_CHAR:
                   4662:       if (!ps_finalBuffer) {
                   4663:         *nextPtr = s;
                   4664:         return XML_ERROR_NONE;
                   4665:       }
                   4666:       return XML_ERROR_PARTIAL_CHAR;
                   4667:     default:
                   4668:       return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
                   4669:     }
                   4670:     eventPtr = s = next;
                   4671:     switch (ps_parsing) {
                   4672:     case XML_SUSPENDED: 
                   4673:       *nextPtr = next;
                   4674:       return XML_ERROR_NONE;
                   4675:     case XML_FINISHED:
                   4676:       return XML_ERROR_ABORTED;
                   4677:     default: ;
                   4678:     }
                   4679:   }
                   4680: }
                   4681: 
                   4682: static enum XML_Error
                   4683: processInternalEntity(XML_Parser parser, ENTITY *entity,
                   4684:                       XML_Bool betweenDecl)
                   4685: {
                   4686:   const char *textStart, *textEnd;
                   4687:   const char *next;
                   4688:   enum XML_Error result;
                   4689:   OPEN_INTERNAL_ENTITY *openEntity;
                   4690: 
                   4691:   if (freeInternalEntities) {
                   4692:     openEntity = freeInternalEntities;
                   4693:     freeInternalEntities = openEntity->next;
                   4694:   }
                   4695:   else {
                   4696:     openEntity = (OPEN_INTERNAL_ENTITY *)MALLOC(sizeof(OPEN_INTERNAL_ENTITY));
                   4697:     if (!openEntity)
                   4698:       return XML_ERROR_NO_MEMORY;
                   4699:   }
                   4700:   entity->open = XML_TRUE;
                   4701:   entity->processed = 0;
                   4702:   openEntity->next = openInternalEntities;
                   4703:   openInternalEntities = openEntity;
                   4704:   openEntity->entity = entity;
                   4705:   openEntity->startTagLevel = tagLevel;
                   4706:   openEntity->betweenDecl = betweenDecl;
                   4707:   openEntity->internalEventPtr = NULL;
                   4708:   openEntity->internalEventEndPtr = NULL;
                   4709:   textStart = (char *)entity->textPtr;
                   4710:   textEnd = (char *)(entity->textPtr + entity->textLen);
                   4711: 
                   4712: #ifdef XML_DTD
                   4713:   if (entity->is_param) {
                   4714:     int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
                   4715:     result = doProlog(parser, internalEncoding, textStart, textEnd, tok, 
                   4716:                       next, &next, XML_FALSE);
                   4717:   }
                   4718:   else 
                   4719: #endif /* XML_DTD */
                   4720:     result = doContent(parser, tagLevel, internalEncoding, textStart, 
                   4721:                        textEnd, &next, XML_FALSE);
                   4722: 
                   4723:   if (result == XML_ERROR_NONE) {
                   4724:     if (textEnd != next && ps_parsing == XML_SUSPENDED) {
                   4725:       entity->processed = (int)(next - textStart);
                   4726:       processor = internalEntityProcessor;
                   4727:     }
                   4728:     else {
                   4729:       entity->open = XML_FALSE;
                   4730:       openInternalEntities = openEntity->next;
                   4731:       /* put openEntity back in list of free instances */
                   4732:       openEntity->next = freeInternalEntities;
                   4733:       freeInternalEntities = openEntity;
                   4734:     }
                   4735:   }
                   4736:   return result;
                   4737: }
                   4738: 
                   4739: static enum XML_Error PTRCALL
                   4740: internalEntityProcessor(XML_Parser parser,
                   4741:                         const char *s,
                   4742:                         const char *end,
                   4743:                         const char **nextPtr)
                   4744: {
                   4745:   ENTITY *entity;
                   4746:   const char *textStart, *textEnd;
                   4747:   const char *next;
                   4748:   enum XML_Error result;
                   4749:   OPEN_INTERNAL_ENTITY *openEntity = openInternalEntities;
                   4750:   if (!openEntity)
                   4751:     return XML_ERROR_UNEXPECTED_STATE;
                   4752: 
                   4753:   entity = openEntity->entity;
                   4754:   textStart = ((char *)entity->textPtr) + entity->processed;
                   4755:   textEnd = (char *)(entity->textPtr + entity->textLen);
                   4756: 
                   4757: #ifdef XML_DTD
                   4758:   if (entity->is_param) {
                   4759:     int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
                   4760:     result = doProlog(parser, internalEncoding, textStart, textEnd, tok, 
                   4761:                       next, &next, XML_FALSE);
                   4762:   }
                   4763:   else
                   4764: #endif /* XML_DTD */
                   4765:     result = doContent(parser, openEntity->startTagLevel, internalEncoding, 
                   4766:                        textStart, textEnd, &next, XML_FALSE);  
                   4767: 
                   4768:   if (result != XML_ERROR_NONE)
                   4769:     return result;
                   4770:   else if (textEnd != next && ps_parsing == XML_SUSPENDED) {
                   4771:     entity->processed = (int)(next - (char *)entity->textPtr);
                   4772:     return result;
                   4773:   }
                   4774:   else {
                   4775:     entity->open = XML_FALSE;
                   4776:     openInternalEntities = openEntity->next;
                   4777:     /* put openEntity back in list of free instances */
                   4778:     openEntity->next = freeInternalEntities;
                   4779:     freeInternalEntities = openEntity;
                   4780:   }
                   4781: 
                   4782: #ifdef XML_DTD
                   4783:   if (entity->is_param) {
                   4784:     int tok;
                   4785:     processor = prologProcessor;
                   4786:     tok = XmlPrologTok(encoding, s, end, &next);
                   4787:     return doProlog(parser, encoding, s, end, tok, next, nextPtr, 
                   4788:                     (XML_Bool)!ps_finalBuffer);
                   4789:   }
                   4790:   else
                   4791: #endif /* XML_DTD */
                   4792:   {
                   4793:     processor = contentProcessor;
                   4794:     /* see externalEntityContentProcessor vs contentProcessor */
                   4795:     return doContent(parser, parentParser ? 1 : 0, encoding, s, end,
                   4796:                      nextPtr, (XML_Bool)!ps_finalBuffer); 
                   4797:   }  
                   4798: }
                   4799: 
                   4800: static enum XML_Error PTRCALL
                   4801: errorProcessor(XML_Parser parser,
                   4802:                const char *s,
                   4803:                const char *end,
                   4804:                const char **nextPtr)
                   4805: {
                   4806:   return errorCode;
                   4807: }
                   4808: 
                   4809: static enum XML_Error
                   4810: storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
                   4811:                     const char *ptr, const char *end,
                   4812:                     STRING_POOL *pool)
                   4813: {
                   4814:   enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr,
                   4815:                                                end, pool);
                   4816:   if (result)
                   4817:     return result;
                   4818:   if (!isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)
                   4819:     poolChop(pool);
                   4820:   if (!poolAppendChar(pool, XML_T('\0')))
                   4821:     return XML_ERROR_NO_MEMORY;
                   4822:   return XML_ERROR_NONE;
                   4823: }
                   4824: 
                   4825: static enum XML_Error
                   4826: appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
                   4827:                      const char *ptr, const char *end,
                   4828:                      STRING_POOL *pool)
                   4829: {
                   4830:   DTD * const dtd = _dtd;  /* save one level of indirection */
                   4831:   for (;;) {
                   4832:     const char *next;
                   4833:     int tok = XmlAttributeValueTok(enc, ptr, end, &next);
                   4834:     switch (tok) {
                   4835:     case XML_TOK_NONE:
                   4836:       return XML_ERROR_NONE;
                   4837:     case XML_TOK_INVALID:
                   4838:       if (enc == encoding)
                   4839:         eventPtr = next;
                   4840:       return XML_ERROR_INVALID_TOKEN;
                   4841:     case XML_TOK_PARTIAL:
                   4842:       if (enc == encoding)
                   4843:         eventPtr = ptr;
                   4844:       return XML_ERROR_INVALID_TOKEN;
                   4845:     case XML_TOK_CHAR_REF:
                   4846:       {
                   4847:         XML_Char buf[XML_ENCODE_MAX];
                   4848:         int i;
                   4849:         int n = XmlCharRefNumber(enc, ptr);
                   4850:         if (n < 0) {
                   4851:           if (enc == encoding)
                   4852:             eventPtr = ptr;
                   4853:           return XML_ERROR_BAD_CHAR_REF;
                   4854:         }
                   4855:         if (!isCdata
                   4856:             && n == 0x20 /* space */
                   4857:             && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
                   4858:           break;
                   4859:         n = XmlEncode(n, (ICHAR *)buf);
                   4860:         if (!n) {
                   4861:           if (enc == encoding)
                   4862:             eventPtr = ptr;
                   4863:           return XML_ERROR_BAD_CHAR_REF;
                   4864:         }
                   4865:         for (i = 0; i < n; i++) {
                   4866:           if (!poolAppendChar(pool, buf[i]))
                   4867:             return XML_ERROR_NO_MEMORY;
                   4868:         }
                   4869:       }
                   4870:       break;
                   4871:     case XML_TOK_DATA_CHARS:
                   4872:       if (!poolAppend(pool, enc, ptr, next))
                   4873:         return XML_ERROR_NO_MEMORY;
                   4874:       break;
                   4875:     case XML_TOK_TRAILING_CR:
                   4876:       next = ptr + enc->minBytesPerChar;
                   4877:       /* fall through */
                   4878:     case XML_TOK_ATTRIBUTE_VALUE_S:
                   4879:     case XML_TOK_DATA_NEWLINE:
                   4880:       if (!isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
                   4881:         break;
                   4882:       if (!poolAppendChar(pool, 0x20))
                   4883:         return XML_ERROR_NO_MEMORY;
                   4884:       break;
                   4885:     case XML_TOK_ENTITY_REF:
                   4886:       {
                   4887:         const XML_Char *name;
                   4888:         ENTITY *entity;
                   4889:         char checkEntityDecl;
                   4890:         XML_Char ch = (XML_Char) XmlPredefinedEntityName(enc,
                   4891:                                               ptr + enc->minBytesPerChar,
                   4892:                                               next - enc->minBytesPerChar);
                   4893:         if (ch) {
                   4894:           if (!poolAppendChar(pool, ch))
                   4895:                 return XML_ERROR_NO_MEMORY;
                   4896:           break;
                   4897:         }
                   4898:         name = poolStoreString(&temp2Pool, enc,
                   4899:                                ptr + enc->minBytesPerChar,
                   4900:                                next - enc->minBytesPerChar);
                   4901:         if (!name)
                   4902:           return XML_ERROR_NO_MEMORY;
                   4903:         entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);
                   4904:         poolDiscard(&temp2Pool);
                   4905:         /* First, determine if a check for an existing declaration is needed;
                   4906:            if yes, check that the entity exists, and that it is internal.
                   4907:         */
                   4908:         if (pool == &dtd->pool)  /* are we called from prolog? */
                   4909:           checkEntityDecl =
                   4910: #ifdef XML_DTD
                   4911:               prologState.documentEntity &&
                   4912: #endif /* XML_DTD */
                   4913:               (dtd->standalone
                   4914:                ? !openInternalEntities
                   4915:                : !dtd->hasParamEntityRefs);
                   4916:         else /* if (pool == &tempPool): we are called from content */
                   4917:           checkEntityDecl = !dtd->hasParamEntityRefs || dtd->standalone;
                   4918:         if (checkEntityDecl) {
                   4919:           if (!entity)
                   4920:             return XML_ERROR_UNDEFINED_ENTITY;
                   4921:           else if (!entity->is_internal)
                   4922:             return XML_ERROR_ENTITY_DECLARED_IN_PE;
                   4923:         }
                   4924:         else if (!entity) {
                   4925:           /* Cannot report skipped entity here - see comments on
                   4926:              skippedEntityHandler.
                   4927:           if (skippedEntityHandler)
                   4928:             skippedEntityHandler(handlerArg, name, 0);
                   4929:           */
                   4930:           /* Cannot call the default handler because this would be
                   4931:              out of sync with the call to the startElementHandler.
                   4932:           if ((pool == &tempPool) && defaultHandler)
                   4933:             reportDefault(parser, enc, ptr, next);
                   4934:           */
                   4935:           break;
                   4936:         }
                   4937:         if (entity->open) {
                   4938:           if (enc == encoding)
                   4939:             eventPtr = ptr;
                   4940:           return XML_ERROR_RECURSIVE_ENTITY_REF;
                   4941:         }
                   4942:         if (entity->notation) {
                   4943:           if (enc == encoding)
                   4944:             eventPtr = ptr;
                   4945:           return XML_ERROR_BINARY_ENTITY_REF;
                   4946:         }
                   4947:         if (!entity->textPtr) {
                   4948:           if (enc == encoding)
                   4949:             eventPtr = ptr;
                   4950:               return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
                   4951:         }
                   4952:         else {
                   4953:           enum XML_Error result;
                   4954:           const XML_Char *textEnd = entity->textPtr + entity->textLen;
                   4955:           entity->open = XML_TRUE;
                   4956:           result = appendAttributeValue(parser, internalEncoding, isCdata,
                   4957:                                         (char *)entity->textPtr,
                   4958:                                         (char *)textEnd, pool);
                   4959:           entity->open = XML_FALSE;
                   4960:           if (result)
                   4961:             return result;
                   4962:         }
                   4963:       }
                   4964:       break;
                   4965:     default:
                   4966:       if (enc == encoding)
                   4967:         eventPtr = ptr;
                   4968:       return XML_ERROR_UNEXPECTED_STATE;
                   4969:     }
                   4970:     ptr = next;
                   4971:   }
                   4972:   /* not reached */
                   4973: }
                   4974: 
                   4975: static enum XML_Error
                   4976: storeEntityValue(XML_Parser parser,
                   4977:                  const ENCODING *enc,
                   4978:                  const char *entityTextPtr,
                   4979:                  const char *entityTextEnd)
                   4980: {
                   4981:   DTD * const dtd = _dtd;  /* save one level of indirection */
                   4982:   STRING_POOL *pool = &(dtd->entityValuePool);
                   4983:   enum XML_Error result = XML_ERROR_NONE;
                   4984: #ifdef XML_DTD
                   4985:   int oldInEntityValue = prologState.inEntityValue;
                   4986:   prologState.inEntityValue = 1;
                   4987: #endif /* XML_DTD */
                   4988:   /* never return Null for the value argument in EntityDeclHandler,
                   4989:      since this would indicate an external entity; therefore we
                   4990:      have to make sure that entityValuePool.start is not null */
                   4991:   if (!pool->blocks) {
                   4992:     if (!poolGrow(pool))
                   4993:       return XML_ERROR_NO_MEMORY;
                   4994:   }
                   4995: 
                   4996:   for (;;) {
                   4997:     const char *next;
                   4998:     int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
                   4999:     switch (tok) {
                   5000:     case XML_TOK_PARAM_ENTITY_REF:
                   5001: #ifdef XML_DTD
                   5002:       if (isParamEntity || enc != encoding) {
                   5003:         const XML_Char *name;
                   5004:         ENTITY *entity;
                   5005:         name = poolStoreString(&tempPool, enc,
                   5006:                                entityTextPtr + enc->minBytesPerChar,
                   5007:                                next - enc->minBytesPerChar);
                   5008:         if (!name) {
                   5009:           result = XML_ERROR_NO_MEMORY;
                   5010:           goto endEntityValue;
                   5011:         }
                   5012:         entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);
                   5013:         poolDiscard(&tempPool);
                   5014:         if (!entity) {
                   5015:           /* not a well-formedness error - see XML 1.0: WFC Entity Declared */
                   5016:           /* cannot report skipped entity here - see comments on
                   5017:              skippedEntityHandler
                   5018:           if (skippedEntityHandler)
                   5019:             skippedEntityHandler(handlerArg, name, 0);
                   5020:           */
                   5021:           dtd->keepProcessing = dtd->standalone;
                   5022:           goto endEntityValue;
                   5023:         }
                   5024:         if (entity->open) {
                   5025:           if (enc == encoding)
                   5026:             eventPtr = entityTextPtr;
                   5027:           result = XML_ERROR_RECURSIVE_ENTITY_REF;
                   5028:           goto endEntityValue;
                   5029:         }
                   5030:         if (entity->systemId) {
                   5031:           if (externalEntityRefHandler) {
                   5032:             dtd->paramEntityRead = XML_FALSE;
                   5033:             entity->open = XML_TRUE;
                   5034:             if (!externalEntityRefHandler(externalEntityRefHandlerArg,
                   5035:                                           0,
                   5036:                                           entity->base,
                   5037:                                           entity->systemId,
                   5038:                                           entity->publicId)) {
                   5039:               entity->open = XML_FALSE;
                   5040:               result = XML_ERROR_EXTERNAL_ENTITY_HANDLING;
                   5041:               goto endEntityValue;
                   5042:             }
                   5043:             entity->open = XML_FALSE;
                   5044:             if (!dtd->paramEntityRead)
                   5045:               dtd->keepProcessing = dtd->standalone;
                   5046:           }
                   5047:           else
                   5048:             dtd->keepProcessing = dtd->standalone;
                   5049:         }
                   5050:         else {
                   5051:           entity->open = XML_TRUE;
                   5052:           result = storeEntityValue(parser,
                   5053:                                     internalEncoding,
                   5054:                                     (char *)entity->textPtr,
                   5055:                                     (char *)(entity->textPtr
                   5056:                                              + entity->textLen));
                   5057:           entity->open = XML_FALSE;
                   5058:           if (result)
                   5059:             goto endEntityValue;
                   5060:         }
                   5061:         break;
                   5062:       }
                   5063: #endif /* XML_DTD */
                   5064:       /* In the internal subset, PE references are not legal
                   5065:          within markup declarations, e.g entity values in this case. */
                   5066:       eventPtr = entityTextPtr;
                   5067:       result = XML_ERROR_PARAM_ENTITY_REF;
                   5068:       goto endEntityValue;
                   5069:     case XML_TOK_NONE:
                   5070:       result = XML_ERROR_NONE;
                   5071:       goto endEntityValue;
                   5072:     case XML_TOK_ENTITY_REF:
                   5073:     case XML_TOK_DATA_CHARS:
                   5074:       if (!poolAppend(pool, enc, entityTextPtr, next)) {
                   5075:         result = XML_ERROR_NO_MEMORY;
                   5076:         goto endEntityValue;
                   5077:       }
                   5078:       break;
                   5079:     case XML_TOK_TRAILING_CR:
                   5080:       next = entityTextPtr + enc->minBytesPerChar;
                   5081:       /* fall through */
                   5082:     case XML_TOK_DATA_NEWLINE:
                   5083:       if (pool->end == pool->ptr && !poolGrow(pool)) {
                   5084:               result = XML_ERROR_NO_MEMORY;
                   5085:         goto endEntityValue;
                   5086:       }
                   5087:       *(pool->ptr)++ = 0xA;
                   5088:       break;
                   5089:     case XML_TOK_CHAR_REF:
                   5090:       {
                   5091:         XML_Char buf[XML_ENCODE_MAX];
                   5092:         int i;
                   5093:         int n = XmlCharRefNumber(enc, entityTextPtr);
                   5094:         if (n < 0) {
                   5095:           if (enc == encoding)
                   5096:             eventPtr = entityTextPtr;
                   5097:           result = XML_ERROR_BAD_CHAR_REF;
                   5098:           goto endEntityValue;
                   5099:         }
                   5100:         n = XmlEncode(n, (ICHAR *)buf);
                   5101:         if (!n) {
                   5102:           if (enc == encoding)
                   5103:             eventPtr = entityTextPtr;
                   5104:           result = XML_ERROR_BAD_CHAR_REF;
                   5105:           goto endEntityValue;
                   5106:         }
                   5107:         for (i = 0; i < n; i++) {
                   5108:           if (pool->end == pool->ptr && !poolGrow(pool)) {
                   5109:             result = XML_ERROR_NO_MEMORY;
                   5110:             goto endEntityValue;
                   5111:           }
                   5112:           *(pool->ptr)++ = buf[i];
                   5113:         }
                   5114:       }
                   5115:       break;
                   5116:     case XML_TOK_PARTIAL:
                   5117:       if (enc == encoding)
                   5118:         eventPtr = entityTextPtr;
                   5119:       result = XML_ERROR_INVALID_TOKEN;
                   5120:       goto endEntityValue;
                   5121:     case XML_TOK_INVALID:
                   5122:       if (enc == encoding)
                   5123:         eventPtr = next;
                   5124:       result = XML_ERROR_INVALID_TOKEN;
                   5125:       goto endEntityValue;
                   5126:     default:
                   5127:       if (enc == encoding)
                   5128:         eventPtr = entityTextPtr;
                   5129:       result = XML_ERROR_UNEXPECTED_STATE;
                   5130:       goto endEntityValue;
                   5131:     }
                   5132:     entityTextPtr = next;
                   5133:   }
                   5134: endEntityValue:
                   5135: #ifdef XML_DTD
                   5136:   prologState.inEntityValue = oldInEntityValue;
                   5137: #endif /* XML_DTD */
                   5138:   return result;
                   5139: }
                   5140: 
                   5141: static void FASTCALL
                   5142: normalizeLines(XML_Char *s)
                   5143: {
                   5144:   XML_Char *p;
                   5145:   for (;; s++) {
                   5146:     if (*s == XML_T('\0'))
                   5147:       return;
                   5148:     if (*s == 0xD)
                   5149:       break;
                   5150:   }
                   5151:   p = s;
                   5152:   do {
                   5153:     if (*s == 0xD) {
                   5154:       *p++ = 0xA;
                   5155:       if (*++s == 0xA)
                   5156:         s++;
                   5157:     }
                   5158:     else
                   5159:       *p++ = *s++;
                   5160:   } while (*s);
                   5161:   *p = XML_T('\0');
                   5162: }
                   5163: 
                   5164: static int
                   5165: reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
                   5166:                             const char *start, const char *end)
                   5167: {
                   5168:   const XML_Char *target;
                   5169:   XML_Char *data;
                   5170:   const char *tem;
                   5171:   if (!processingInstructionHandler) {
                   5172:     if (defaultHandler)
                   5173:       reportDefault(parser, enc, start, end);
                   5174:     return 1;
                   5175:   }
                   5176:   start += enc->minBytesPerChar * 2;
                   5177:   tem = start + XmlNameLength(enc, start);
                   5178:   target = poolStoreString(&tempPool, enc, start, tem);
                   5179:   if (!target)
                   5180:     return 0;
                   5181:   poolFinish(&tempPool);
                   5182:   data = poolStoreString(&tempPool, enc,
                   5183:                         XmlSkipS(enc, tem),
                   5184:                         end - enc->minBytesPerChar*2);
                   5185:   if (!data)
                   5186:     return 0;
                   5187:   normalizeLines(data);
                   5188:   processingInstructionHandler(handlerArg, target, data);
                   5189:   poolClear(&tempPool);
                   5190:   return 1;
                   5191: }
                   5192: 
                   5193: static int
                   5194: reportComment(XML_Parser parser, const ENCODING *enc,
                   5195:               const char *start, const char *end)
                   5196: {
                   5197:   XML_Char *data;
                   5198:   if (!commentHandler) {
                   5199:     if (defaultHandler)
                   5200:       reportDefault(parser, enc, start, end);
                   5201:     return 1;
                   5202:   }
                   5203:   data = poolStoreString(&tempPool,
                   5204:                          enc,
                   5205:                          start + enc->minBytesPerChar * 4,
                   5206:                          end - enc->minBytesPerChar * 3);
                   5207:   if (!data)
                   5208:     return 0;
                   5209:   normalizeLines(data);
                   5210:   commentHandler(handlerArg, data);
                   5211:   poolClear(&tempPool);
                   5212:   return 1;
                   5213: }
                   5214: 
                   5215: static void
                   5216: reportDefault(XML_Parser parser, const ENCODING *enc,
                   5217:               const char *s, const char *end)
                   5218: {
                   5219:   if (MUST_CONVERT(enc, s)) {
                   5220:     const char **eventPP;
                   5221:     const char **eventEndPP;
                   5222:     if (enc == encoding) {
                   5223:       eventPP = &eventPtr;
                   5224:       eventEndPP = &eventEndPtr;
                   5225:     }
                   5226:     else {
                   5227:       eventPP = &(openInternalEntities->internalEventPtr);
                   5228:       eventEndPP = &(openInternalEntities->internalEventEndPtr);
                   5229:     }
                   5230:     do {
                   5231:       ICHAR *dataPtr = (ICHAR *)dataBuf;
                   5232:       XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
                   5233:       *eventEndPP = s;
                   5234:       defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));
                   5235:       *eventPP = s;
                   5236:     } while (s != end);
                   5237:   }
                   5238:   else
                   5239:     defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));
                   5240: }
                   5241: 
                   5242: 
                   5243: static int
                   5244: defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,
                   5245:                 XML_Bool isId, const XML_Char *value, XML_Parser parser)
                   5246: {
                   5247:   DEFAULT_ATTRIBUTE *att;
                   5248:   if (value || isId) {
                   5249:     /* The handling of default attributes gets messed up if we have
                   5250:        a default which duplicates a non-default. */
                   5251:     int i;
                   5252:     for (i = 0; i < type->nDefaultAtts; i++)
                   5253:       if (attId == type->defaultAtts[i].id)
                   5254:         return 1;
                   5255:     if (isId && !type->idAtt && !attId->xmlns)
                   5256:       type->idAtt = attId;
                   5257:   }
                   5258:   if (type->nDefaultAtts == type->allocDefaultAtts) {
                   5259:     if (type->allocDefaultAtts == 0) {
                   5260:       type->allocDefaultAtts = 8;
                   5261:       type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(type->allocDefaultAtts
                   5262:                             * sizeof(DEFAULT_ATTRIBUTE));
                   5263:       if (!type->defaultAtts)
                   5264:         return 0;
                   5265:     }
                   5266:     else {
                   5267:       DEFAULT_ATTRIBUTE *temp;
                   5268:       int count = type->allocDefaultAtts * 2;
                   5269:       temp = (DEFAULT_ATTRIBUTE *)
                   5270:         REALLOC(type->defaultAtts, (count * sizeof(DEFAULT_ATTRIBUTE)));
                   5271:       if (temp == NULL)
                   5272:         return 0;
                   5273:       type->allocDefaultAtts = count;
                   5274:       type->defaultAtts = temp;
                   5275:     }
                   5276:   }
                   5277:   att = type->defaultAtts + type->nDefaultAtts;
                   5278:   att->id = attId;
                   5279:   att->value = value;
                   5280:   att->isCdata = isCdata;
                   5281:   if (!isCdata)
                   5282:     attId->maybeTokenized = XML_TRUE;
                   5283:   type->nDefaultAtts += 1;
                   5284:   return 1;
                   5285: }
                   5286: 
                   5287: static int
                   5288: setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType)
                   5289: {
                   5290:   DTD * const dtd = _dtd;  /* save one level of indirection */
                   5291:   const XML_Char *name;
                   5292:   for (name = elementType->name; *name; name++) {
                   5293:     if (*name == XML_T(ASCII_COLON)) {
                   5294:       PREFIX *prefix;
                   5295:       const XML_Char *s;
                   5296:       for (s = elementType->name; s != name; s++) {
                   5297:         if (!poolAppendChar(&dtd->pool, *s))
                   5298:           return 0;
                   5299:       }
                   5300:       if (!poolAppendChar(&dtd->pool, XML_T('\0')))
                   5301:         return 0;
                   5302:       prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),
                   5303:                                 sizeof(PREFIX));
                   5304:       if (!prefix)
                   5305:         return 0;
                   5306:       if (prefix->name == poolStart(&dtd->pool))
                   5307:         poolFinish(&dtd->pool);
                   5308:       else
                   5309:         poolDiscard(&dtd->pool);
                   5310:       elementType->prefix = prefix;
                   5311: 
                   5312:     }
                   5313:   }
                   5314:   return 1;
                   5315: }
                   5316: 
                   5317: static ATTRIBUTE_ID *
                   5318: getAttributeId(XML_Parser parser, const ENCODING *enc,
                   5319:                const char *start, const char *end)
                   5320: {
                   5321:   DTD * const dtd = _dtd;  /* save one level of indirection */
                   5322:   ATTRIBUTE_ID *id;
                   5323:   const XML_Char *name;
                   5324:   if (!poolAppendChar(&dtd->pool, XML_T('\0')))
                   5325:     return NULL;
                   5326:   name = poolStoreString(&dtd->pool, enc, start, end);
                   5327:   if (!name)
                   5328:     return NULL;
                   5329:   /* skip quotation mark - its storage will be re-used (like in name[-1]) */
                   5330:   ++name;
                   5331:   id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, name, sizeof(ATTRIBUTE_ID));
                   5332:   if (!id)
                   5333:     return NULL;
                   5334:   if (id->name != name)
                   5335:     poolDiscard(&dtd->pool);
                   5336:   else {
                   5337:     poolFinish(&dtd->pool);
                   5338:     if (!ns)
                   5339:       ;
                   5340:     else if (name[0] == XML_T(ASCII_x)
                   5341:         && name[1] == XML_T(ASCII_m)
                   5342:         && name[2] == XML_T(ASCII_l)
                   5343:         && name[3] == XML_T(ASCII_n)
                   5344:         && name[4] == XML_T(ASCII_s)
                   5345:         && (name[5] == XML_T('\0') || name[5] == XML_T(ASCII_COLON))) {
                   5346:       if (name[5] == XML_T('\0'))
                   5347:         id->prefix = &dtd->defaultPrefix;
                   5348:       else
                   5349:         id->prefix = (PREFIX *)lookup(&dtd->prefixes, name + 6, sizeof(PREFIX));
                   5350:       id->xmlns = XML_TRUE;
                   5351:     }
                   5352:     else {
                   5353:       int i;
                   5354:       for (i = 0; name[i]; i++) {
                   5355:         /* attributes without prefix are *not* in the default namespace */
                   5356:         if (name[i] == XML_T(ASCII_COLON)) {
                   5357:           int j;
                   5358:           for (j = 0; j < i; j++) {
                   5359:             if (!poolAppendChar(&dtd->pool, name[j]))
                   5360:               return NULL;
                   5361:           }
                   5362:           if (!poolAppendChar(&dtd->pool, XML_T('\0')))
                   5363:             return NULL;
                   5364:           id->prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),
                   5365:                                         sizeof(PREFIX));
                   5366:           if (id->prefix->name == poolStart(&dtd->pool))
                   5367:             poolFinish(&dtd->pool);
                   5368:           else
                   5369:             poolDiscard(&dtd->pool);
                   5370:           break;
                   5371:         }
                   5372:       }
                   5373:     }
                   5374:   }
                   5375:   return id;
                   5376: }
                   5377: 
                   5378: #define CONTEXT_SEP XML_T(ASCII_FF)
                   5379: 
                   5380: static const XML_Char *
                   5381: getContext(XML_Parser parser)
                   5382: {
                   5383:   DTD * const dtd = _dtd;  /* save one level of indirection */
                   5384:   HASH_TABLE_ITER iter;
                   5385:   XML_Bool needSep = XML_FALSE;
                   5386: 
                   5387:   if (dtd->defaultPrefix.binding) {
                   5388:     int i;
                   5389:     int len;
                   5390:     if (!poolAppendChar(&tempPool, XML_T(ASCII_EQUALS)))
                   5391:       return NULL;
                   5392:     len = dtd->defaultPrefix.binding->uriLen;
                   5393:     if (namespaceSeparator)
                   5394:       len--;
                   5395:     for (i = 0; i < len; i++)
                   5396:       if (!poolAppendChar(&tempPool, dtd->defaultPrefix.binding->uri[i]))
                   5397:         return NULL;
                   5398:     needSep = XML_TRUE;
                   5399:   }
                   5400: 
                   5401:   hashTableIterInit(&iter, &(dtd->prefixes));
                   5402:   for (;;) {
                   5403:     int i;
                   5404:     int len;
                   5405:     const XML_Char *s;
                   5406:     PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);
                   5407:     if (!prefix)
                   5408:       break;
                   5409:     if (!prefix->binding)
                   5410:       continue;
                   5411:     if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))
                   5412:       return NULL;
                   5413:     for (s = prefix->name; *s; s++)
                   5414:       if (!poolAppendChar(&tempPool, *s))
                   5415:         return NULL;
                   5416:     if (!poolAppendChar(&tempPool, XML_T(ASCII_EQUALS)))
                   5417:       return NULL;
                   5418:     len = prefix->binding->uriLen;
                   5419:     if (namespaceSeparator)
                   5420:       len--;
                   5421:     for (i = 0; i < len; i++)
                   5422:       if (!poolAppendChar(&tempPool, prefix->binding->uri[i]))
                   5423:         return NULL;
                   5424:     needSep = XML_TRUE;
                   5425:   }
                   5426: 
                   5427: 
                   5428:   hashTableIterInit(&iter, &(dtd->generalEntities));
                   5429:   for (;;) {
                   5430:     const XML_Char *s;
                   5431:     ENTITY *e = (ENTITY *)hashTableIterNext(&iter);
                   5432:     if (!e)
                   5433:       break;
                   5434:     if (!e->open)
                   5435:       continue;
                   5436:     if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))
                   5437:       return NULL;
                   5438:     for (s = e->name; *s; s++)
                   5439:       if (!poolAppendChar(&tempPool, *s))
                   5440:         return 0;
                   5441:     needSep = XML_TRUE;
                   5442:   }
                   5443: 
                   5444:   if (!poolAppendChar(&tempPool, XML_T('\0')))
                   5445:     return NULL;
                   5446:   return tempPool.start;
                   5447: }
                   5448: 
                   5449: static XML_Bool
                   5450: setContext(XML_Parser parser, const XML_Char *context)
                   5451: {
                   5452:   DTD * const dtd = _dtd;  /* save one level of indirection */
                   5453:   const XML_Char *s = context;
                   5454: 
                   5455:   while (*context != XML_T('\0')) {
                   5456:     if (*s == CONTEXT_SEP || *s == XML_T('\0')) {
                   5457:       ENTITY *e;
                   5458:       if (!poolAppendChar(&tempPool, XML_T('\0')))
                   5459:         return XML_FALSE;
                   5460:       e = (ENTITY *)lookup(&dtd->generalEntities, poolStart(&tempPool), 0);
                   5461:       if (e)
                   5462:         e->open = XML_TRUE;
                   5463:       if (*s != XML_T('\0'))
                   5464:         s++;
                   5465:       context = s;
                   5466:       poolDiscard(&tempPool);
                   5467:     }
                   5468:     else if (*s == XML_T(ASCII_EQUALS)) {
                   5469:       PREFIX *prefix;
                   5470:       if (poolLength(&tempPool) == 0)
                   5471:         prefix = &dtd->defaultPrefix;
                   5472:       else {
                   5473:         if (!poolAppendChar(&tempPool, XML_T('\0')))
                   5474:           return XML_FALSE;
                   5475:         prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&tempPool),
                   5476:                                   sizeof(PREFIX));
                   5477:         if (!prefix)
                   5478:           return XML_FALSE;
                   5479:         if (prefix->name == poolStart(&tempPool)) {
                   5480:           prefix->name = poolCopyString(&dtd->pool, prefix->name);
                   5481:           if (!prefix->name)
                   5482:             return XML_FALSE;
                   5483:         }
                   5484:         poolDiscard(&tempPool);
                   5485:       }
                   5486:       for (context = s + 1;
                   5487:            *context != CONTEXT_SEP && *context != XML_T('\0');
                   5488:            context++)
                   5489:         if (!poolAppendChar(&tempPool, *context))
                   5490:           return XML_FALSE;
                   5491:       if (!poolAppendChar(&tempPool, XML_T('\0')))
                   5492:         return XML_FALSE;
                   5493:       if (addBinding(parser, prefix, NULL, poolStart(&tempPool),
                   5494:                      &inheritedBindings) != XML_ERROR_NONE)
                   5495:         return XML_FALSE;
                   5496:       poolDiscard(&tempPool);
                   5497:       if (*context != XML_T('\0'))
                   5498:         ++context;
                   5499:       s = context;
                   5500:     }
                   5501:     else {
                   5502:       if (!poolAppendChar(&tempPool, *s))
                   5503:         return XML_FALSE;
                   5504:       s++;
                   5505:     }
                   5506:   }
                   5507:   return XML_TRUE;
                   5508: }
                   5509: 
                   5510: static void FASTCALL
                   5511: normalizePublicId(XML_Char *publicId)
                   5512: {
                   5513:   XML_Char *p = publicId;
                   5514:   XML_Char *s;
                   5515:   for (s = publicId; *s; s++) {
                   5516:     switch (*s) {
                   5517:     case 0x20:
                   5518:     case 0xD:
                   5519:     case 0xA:
                   5520:       if (p != publicId && p[-1] != 0x20)
                   5521:         *p++ = 0x20;
                   5522:       break;
                   5523:     default:
                   5524:       *p++ = *s;
                   5525:     }
                   5526:   }
                   5527:   if (p != publicId && p[-1] == 0x20)
                   5528:     --p;
                   5529:   *p = XML_T('\0');
                   5530: }
                   5531: 
                   5532: static DTD *
                   5533: dtdCreate(const XML_Memory_Handling_Suite *ms)
                   5534: {
                   5535:   DTD *p = (DTD *)ms->malloc_fcn(sizeof(DTD));
                   5536:   if (p == NULL)
                   5537:     return p;
                   5538:   poolInit(&(p->pool), ms);
                   5539:   poolInit(&(p->entityValuePool), ms);
                   5540:   hashTableInit(&(p->generalEntities), ms);
                   5541:   hashTableInit(&(p->elementTypes), ms);
                   5542:   hashTableInit(&(p->attributeIds), ms);
                   5543:   hashTableInit(&(p->prefixes), ms);
                   5544: #ifdef XML_DTD
                   5545:   p->paramEntityRead = XML_FALSE;
                   5546:   hashTableInit(&(p->paramEntities), ms);
                   5547: #endif /* XML_DTD */
                   5548:   p->defaultPrefix.name = NULL;
                   5549:   p->defaultPrefix.binding = NULL;
                   5550: 
                   5551:   p->in_eldecl = XML_FALSE;
                   5552:   p->scaffIndex = NULL;
                   5553:   p->scaffold = NULL;
                   5554:   p->scaffLevel = 0;
                   5555:   p->scaffSize = 0;
                   5556:   p->scaffCount = 0;
                   5557:   p->contentStringLen = 0;
                   5558: 
                   5559:   p->keepProcessing = XML_TRUE;
                   5560:   p->hasParamEntityRefs = XML_FALSE;
                   5561:   p->standalone = XML_FALSE;
                   5562:   return p;
                   5563: }
                   5564: 
                   5565: static void
                   5566: dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms)
                   5567: {
                   5568:   HASH_TABLE_ITER iter;
                   5569:   hashTableIterInit(&iter, &(p->elementTypes));
                   5570:   for (;;) {
                   5571:     ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
                   5572:     if (!e)
                   5573:       break;
                   5574:     if (e->allocDefaultAtts != 0)
                   5575:       ms->free_fcn(e->defaultAtts);
                   5576:   }
                   5577:   hashTableClear(&(p->generalEntities));
                   5578: #ifdef XML_DTD
                   5579:   p->paramEntityRead = XML_FALSE;
                   5580:   hashTableClear(&(p->paramEntities));
                   5581: #endif /* XML_DTD */
                   5582:   hashTableClear(&(p->elementTypes));
                   5583:   hashTableClear(&(p->attributeIds));
                   5584:   hashTableClear(&(p->prefixes));
                   5585:   poolClear(&(p->pool));
                   5586:   poolClear(&(p->entityValuePool));
                   5587:   p->defaultPrefix.name = NULL;
                   5588:   p->defaultPrefix.binding = NULL;
                   5589: 
                   5590:   p->in_eldecl = XML_FALSE;
                   5591: 
                   5592:   ms->free_fcn(p->scaffIndex);
                   5593:   p->scaffIndex = NULL;
                   5594:   ms->free_fcn(p->scaffold);
                   5595:   p->scaffold = NULL;
                   5596: 
                   5597:   p->scaffLevel = 0;
                   5598:   p->scaffSize = 0;
                   5599:   p->scaffCount = 0;
                   5600:   p->contentStringLen = 0;
                   5601: 
                   5602:   p->keepProcessing = XML_TRUE;
                   5603:   p->hasParamEntityRefs = XML_FALSE;
                   5604:   p->standalone = XML_FALSE;
                   5605: }
                   5606: 
                   5607: static void
                   5608: dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms)
                   5609: {
                   5610:   HASH_TABLE_ITER iter;
                   5611:   hashTableIterInit(&iter, &(p->elementTypes));
                   5612:   for (;;) {
                   5613:     ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
                   5614:     if (!e)
                   5615:       break;
                   5616:     if (e->allocDefaultAtts != 0)
                   5617:       ms->free_fcn(e->defaultAtts);
                   5618:   }
                   5619:   hashTableDestroy(&(p->generalEntities));
                   5620: #ifdef XML_DTD
                   5621:   hashTableDestroy(&(p->paramEntities));
                   5622: #endif /* XML_DTD */
                   5623:   hashTableDestroy(&(p->elementTypes));
                   5624:   hashTableDestroy(&(p->attributeIds));
                   5625:   hashTableDestroy(&(p->prefixes));
                   5626:   poolDestroy(&(p->pool));
                   5627:   poolDestroy(&(p->entityValuePool));
                   5628:   if (isDocEntity) {
                   5629:     ms->free_fcn(p->scaffIndex);
                   5630:     ms->free_fcn(p->scaffold);
                   5631:   }
                   5632:   ms->free_fcn(p);
                   5633: }
                   5634: 
                   5635: /* Do a deep copy of the DTD. Return 0 for out of memory, non-zero otherwise.
                   5636:    The new DTD has already been initialized.
                   5637: */
                   5638: static int
                   5639: dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
                   5640: {
                   5641:   HASH_TABLE_ITER iter;
                   5642: 
                   5643:   /* Copy the prefix table. */
                   5644: 
                   5645:   hashTableIterInit(&iter, &(oldDtd->prefixes));
                   5646:   for (;;) {
                   5647:     const XML_Char *name;
                   5648:     const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);
                   5649:     if (!oldP)
                   5650:       break;
                   5651:     name = poolCopyString(&(newDtd->pool), oldP->name);
                   5652:     if (!name)
                   5653:       return 0;
                   5654:     if (!lookup(&(newDtd->prefixes), name, sizeof(PREFIX)))
                   5655:       return 0;
                   5656:   }
                   5657: 
                   5658:   hashTableIterInit(&iter, &(oldDtd->attributeIds));
                   5659: 
                   5660:   /* Copy the attribute id table. */
                   5661: 
                   5662:   for (;;) {
                   5663:     ATTRIBUTE_ID *newA;
                   5664:     const XML_Char *name;
                   5665:     const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);
                   5666: 
                   5667:     if (!oldA)
                   5668:       break;
                   5669:     /* Remember to allocate the scratch byte before the name. */
                   5670:     if (!poolAppendChar(&(newDtd->pool), XML_T('\0')))
                   5671:       return 0;
                   5672:     name = poolCopyString(&(newDtd->pool), oldA->name);
                   5673:     if (!name)
                   5674:       return 0;
                   5675:     ++name;
                   5676:     newA = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), name,
                   5677:                                   sizeof(ATTRIBUTE_ID));
                   5678:     if (!newA)
                   5679:       return 0;
                   5680:     newA->maybeTokenized = oldA->maybeTokenized;
                   5681:     if (oldA->prefix) {
                   5682:       newA->xmlns = oldA->xmlns;
                   5683:       if (oldA->prefix == &oldDtd->defaultPrefix)
                   5684:         newA->prefix = &newDtd->defaultPrefix;
                   5685:       else
                   5686:         newA->prefix = (PREFIX *)lookup(&(newDtd->prefixes),
                   5687:                                         oldA->prefix->name, 0);
                   5688:     }
                   5689:   }
                   5690: 
                   5691:   /* Copy the element type table. */
                   5692: 
                   5693:   hashTableIterInit(&iter, &(oldDtd->elementTypes));
                   5694: 
                   5695:   for (;;) {
                   5696:     int i;
                   5697:     ELEMENT_TYPE *newE;
                   5698:     const XML_Char *name;
                   5699:     const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);
                   5700:     if (!oldE)
                   5701:       break;
                   5702:     name = poolCopyString(&(newDtd->pool), oldE->name);
                   5703:     if (!name)
                   5704:       return 0;
                   5705:     newE = (ELEMENT_TYPE *)lookup(&(newDtd->elementTypes), name,
                   5706:                                   sizeof(ELEMENT_TYPE));
                   5707:     if (!newE)
                   5708:       return 0;
                   5709:     if (oldE->nDefaultAtts) {
                   5710:       newE->defaultAtts = (DEFAULT_ATTRIBUTE *)
                   5711:           ms->malloc_fcn(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
                   5712:       if (!newE->defaultAtts) {
                   5713:         ms->free_fcn(newE);
                   5714:         return 0;
                   5715:       }
                   5716:     }
                   5717:     if (oldE->idAtt)
                   5718:       newE->idAtt = (ATTRIBUTE_ID *)
                   5719:           lookup(&(newDtd->attributeIds), oldE->idAtt->name, 0);
                   5720:     newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
                   5721:     if (oldE->prefix)
                   5722:       newE->prefix = (PREFIX *)lookup(&(newDtd->prefixes),
                   5723:                                       oldE->prefix->name, 0);
                   5724:     for (i = 0; i < newE->nDefaultAtts; i++) {
                   5725:       newE->defaultAtts[i].id = (ATTRIBUTE_ID *)
                   5726:           lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
                   5727:       newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
                   5728:       if (oldE->defaultAtts[i].value) {
                   5729:         newE->defaultAtts[i].value
                   5730:             = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);
                   5731:         if (!newE->defaultAtts[i].value)
                   5732:           return 0;
                   5733:       }
                   5734:       else
                   5735:         newE->defaultAtts[i].value = NULL;
                   5736:     }
                   5737:   }
                   5738: 
                   5739:   /* Copy the entity tables. */
                   5740:   if (!copyEntityTable(&(newDtd->generalEntities),
                   5741:                        &(newDtd->pool),
                   5742:                        &(oldDtd->generalEntities)))
                   5743:       return 0;
                   5744: 
                   5745: #ifdef XML_DTD
                   5746:   if (!copyEntityTable(&(newDtd->paramEntities),
                   5747:                        &(newDtd->pool),
                   5748:                        &(oldDtd->paramEntities)))
                   5749:       return 0;
                   5750:   newDtd->paramEntityRead = oldDtd->paramEntityRead;
                   5751: #endif /* XML_DTD */
                   5752: 
                   5753:   newDtd->keepProcessing = oldDtd->keepProcessing;
                   5754:   newDtd->hasParamEntityRefs = oldDtd->hasParamEntityRefs;
                   5755:   newDtd->standalone = oldDtd->standalone;
                   5756: 
                   5757:   /* Don't want deep copying for scaffolding */
                   5758:   newDtd->in_eldecl = oldDtd->in_eldecl;
                   5759:   newDtd->scaffold = oldDtd->scaffold;
                   5760:   newDtd->contentStringLen = oldDtd->contentStringLen;
                   5761:   newDtd->scaffSize = oldDtd->scaffSize;
                   5762:   newDtd->scaffLevel = oldDtd->scaffLevel;
                   5763:   newDtd->scaffIndex = oldDtd->scaffIndex;
                   5764: 
                   5765:   return 1;
                   5766: }  /* End dtdCopy */
                   5767: 
                   5768: static int
                   5769: copyEntityTable(HASH_TABLE *newTable,
                   5770:                 STRING_POOL *newPool,
                   5771:                 const HASH_TABLE *oldTable)
                   5772: {
                   5773:   HASH_TABLE_ITER iter;
                   5774:   const XML_Char *cachedOldBase = NULL;
                   5775:   const XML_Char *cachedNewBase = NULL;
                   5776: 
                   5777:   hashTableIterInit(&iter, oldTable);
                   5778: 
                   5779:   for (;;) {
                   5780:     ENTITY *newE;
                   5781:     const XML_Char *name;
                   5782:     const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);
                   5783:     if (!oldE)
                   5784:       break;
                   5785:     name = poolCopyString(newPool, oldE->name);
                   5786:     if (!name)
                   5787:       return 0;
                   5788:     newE = (ENTITY *)lookup(newTable, name, sizeof(ENTITY));
                   5789:     if (!newE)
                   5790:       return 0;
                   5791:     if (oldE->systemId) {
                   5792:       const XML_Char *tem = poolCopyString(newPool, oldE->systemId);
                   5793:       if (!tem)
                   5794:         return 0;
                   5795:       newE->systemId = tem;
                   5796:       if (oldE->base) {
                   5797:         if (oldE->base == cachedOldBase)
                   5798:           newE->base = cachedNewBase;
                   5799:         else {
                   5800:           cachedOldBase = oldE->base;
                   5801:           tem = poolCopyString(newPool, cachedOldBase);
                   5802:           if (!tem)
                   5803:             return 0;
                   5804:           cachedNewBase = newE->base = tem;
                   5805:         }
                   5806:       }
                   5807:       if (oldE->publicId) {
                   5808:         tem = poolCopyString(newPool, oldE->publicId);
                   5809:         if (!tem)
                   5810:           return 0;
                   5811:         newE->publicId = tem;
                   5812:       }
                   5813:     }
                   5814:     else {
                   5815:       const XML_Char *tem = poolCopyStringN(newPool, oldE->textPtr,
                   5816:                                             oldE->textLen);
                   5817:       if (!tem)
                   5818:         return 0;
                   5819:       newE->textPtr = tem;
                   5820:       newE->textLen = oldE->textLen;
                   5821:     }
                   5822:     if (oldE->notation) {
                   5823:       const XML_Char *tem = poolCopyString(newPool, oldE->notation);
                   5824:       if (!tem)
                   5825:         return 0;
                   5826:       newE->notation = tem;
                   5827:     }
                   5828:     newE->is_param = oldE->is_param;
                   5829:     newE->is_internal = oldE->is_internal;
                   5830:   }
                   5831:   return 1;
                   5832: }
                   5833: 
                   5834: #define INIT_POWER 6
                   5835: 
                   5836: static XML_Bool FASTCALL
                   5837: keyeq(KEY s1, KEY s2)
                   5838: {
                   5839:   for (; *s1 == *s2; s1++, s2++)
                   5840:     if (*s1 == 0)
                   5841:       return XML_TRUE;
                   5842:   return XML_FALSE;
                   5843: }
                   5844: 
                   5845: static unsigned long FASTCALL
                   5846: hash(KEY s)
                   5847: {
                   5848:   unsigned long h = 0;
                   5849:   while (*s)
                   5850:     h = CHAR_HASH(h, *s++);
                   5851:   return h;
                   5852: }
                   5853: 
                   5854: static NAMED *
                   5855: lookup(HASH_TABLE *table, KEY name, size_t createSize)
                   5856: {
                   5857:   size_t i;
                   5858:   if (table->size == 0) {
                   5859:     size_t tsize;
                   5860:     if (!createSize)
                   5861:       return NULL;
                   5862:     table->power = INIT_POWER;
                   5863:     /* table->size is a power of 2 */
                   5864:     table->size = (size_t)1 << INIT_POWER;
                   5865:     tsize = table->size * sizeof(NAMED *);
                   5866:     table->v = (NAMED **)table->mem->malloc_fcn(tsize);
                   5867:     if (!table->v) {
                   5868:       table->size = 0;
                   5869:       return NULL;
                   5870:     }
                   5871:     memset(table->v, 0, tsize);
                   5872:     i = hash(name) & ((unsigned long)table->size - 1);
                   5873:   }
                   5874:   else {
                   5875:     unsigned long h = hash(name);
                   5876:     unsigned long mask = (unsigned long)table->size - 1;
                   5877:     unsigned char step = 0;
                   5878:     i = h & mask;
                   5879:     while (table->v[i]) {
                   5880:       if (keyeq(name, table->v[i]->name))
                   5881:         return table->v[i];
                   5882:       if (!step)
                   5883:         step = PROBE_STEP(h, mask, table->power);
                   5884:       i < step ? (i += table->size - step) : (i -= step);
                   5885:     }
                   5886:     if (!createSize)
                   5887:       return NULL;
                   5888: 
                   5889:     /* check for overflow (table is half full) */
                   5890:     if (table->used >> (table->power - 1)) {
                   5891:       unsigned char newPower = table->power + 1;
                   5892:       size_t newSize = (size_t)1 << newPower;
                   5893:       unsigned long newMask = (unsigned long)newSize - 1;
                   5894:       size_t tsize = newSize * sizeof(NAMED *);
                   5895:       NAMED **newV = (NAMED **)table->mem->malloc_fcn(tsize);
                   5896:       if (!newV)
                   5897:         return NULL;
                   5898:       memset(newV, 0, tsize);
                   5899:       for (i = 0; i < table->size; i++)
                   5900:         if (table->v[i]) {
                   5901:           unsigned long newHash = hash(table->v[i]->name);
                   5902:           size_t j = newHash & newMask;
                   5903:           step = 0;
                   5904:           while (newV[j]) {
                   5905:             if (!step)
                   5906:               step = PROBE_STEP(newHash, newMask, newPower);
                   5907:             j < step ? (j += newSize - step) : (j -= step);
                   5908:           }
                   5909:           newV[j] = table->v[i];
                   5910:         }
                   5911:       table->mem->free_fcn(table->v);
                   5912:       table->v = newV;
                   5913:       table->power = newPower;
                   5914:       table->size = newSize;
                   5915:       i = h & newMask;
                   5916:       step = 0;
                   5917:       while (table->v[i]) {
                   5918:         if (!step)
                   5919:           step = PROBE_STEP(h, newMask, newPower);
                   5920:         i < step ? (i += newSize - step) : (i -= step);
                   5921:       }
                   5922:     }
                   5923:   }
                   5924:   table->v[i] = (NAMED *)table->mem->malloc_fcn(createSize);
                   5925:   if (!table->v[i])
                   5926:     return NULL;
                   5927:   memset(table->v[i], 0, createSize);
                   5928:   table->v[i]->name = name;
                   5929:   (table->used)++;
                   5930:   return table->v[i];
                   5931: }
                   5932: 
                   5933: static void FASTCALL
                   5934: hashTableClear(HASH_TABLE *table)
                   5935: {
                   5936:   size_t i;
                   5937:   for (i = 0; i < table->size; i++) {
                   5938:     table->mem->free_fcn(table->v[i]);
                   5939:     table->v[i] = NULL;
                   5940:   }
                   5941:   table->used = 0;
                   5942: }
                   5943: 
                   5944: static void FASTCALL
                   5945: hashTableDestroy(HASH_TABLE *table)
                   5946: {
                   5947:   size_t i;
                   5948:   for (i = 0; i < table->size; i++)
                   5949:     table->mem->free_fcn(table->v[i]);
                   5950:   table->mem->free_fcn(table->v);
                   5951: }
                   5952: 
                   5953: static void FASTCALL
                   5954: hashTableInit(HASH_TABLE *p, const XML_Memory_Handling_Suite *ms)
                   5955: {
                   5956:   p->power = 0;
                   5957:   p->size = 0;
                   5958:   p->used = 0;
                   5959:   p->v = NULL;
                   5960:   p->mem = ms;
                   5961: }
                   5962: 
                   5963: static void FASTCALL
                   5964: hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table)
                   5965: {
                   5966:   iter->p = table->v;
                   5967:   iter->end = iter->p + table->size;
                   5968: }
                   5969: 
                   5970: static NAMED * FASTCALL
                   5971: hashTableIterNext(HASH_TABLE_ITER *iter)
                   5972: {
                   5973:   while (iter->p != iter->end) {
                   5974:     NAMED *tem = *(iter->p)++;
                   5975:     if (tem)
                   5976:       return tem;
                   5977:   }
                   5978:   return NULL;
                   5979: }
                   5980: 
                   5981: static void FASTCALL
                   5982: poolInit(STRING_POOL *pool, const XML_Memory_Handling_Suite *ms)
                   5983: {
                   5984:   pool->blocks = NULL;
                   5985:   pool->freeBlocks = NULL;
                   5986:   pool->start = NULL;
                   5987:   pool->ptr = NULL;
                   5988:   pool->end = NULL;
                   5989:   pool->mem = ms;
                   5990: }
                   5991: 
                   5992: static void FASTCALL
                   5993: poolClear(STRING_POOL *pool)
                   5994: {
                   5995:   if (!pool->freeBlocks)
                   5996:     pool->freeBlocks = pool->blocks;
                   5997:   else {
                   5998:     BLOCK *p = pool->blocks;
                   5999:     while (p) {
                   6000:       BLOCK *tem = p->next;
                   6001:       p->next = pool->freeBlocks;
                   6002:       pool->freeBlocks = p;
                   6003:       p = tem;
                   6004:     }
                   6005:   }
                   6006:   pool->blocks = NULL;
                   6007:   pool->start = NULL;
                   6008:   pool->ptr = NULL;
                   6009:   pool->end = NULL;
                   6010: }
                   6011: 
                   6012: static void FASTCALL
                   6013: poolDestroy(STRING_POOL *pool)
                   6014: {
                   6015:   BLOCK *p = pool->blocks;
                   6016:   while (p) {
                   6017:     BLOCK *tem = p->next;
                   6018:     pool->mem->free_fcn(p);
                   6019:     p = tem;
                   6020:   }
                   6021:   p = pool->freeBlocks;
                   6022:   while (p) {
                   6023:     BLOCK *tem = p->next;
                   6024:     pool->mem->free_fcn(p);
                   6025:     p = tem;
                   6026:   }
                   6027: }
                   6028: 
                   6029: static XML_Char *
                   6030: poolAppend(STRING_POOL *pool, const ENCODING *enc,
                   6031:            const char *ptr, const char *end)
                   6032: {
                   6033:   if (!pool->ptr && !poolGrow(pool))
                   6034:     return NULL;
                   6035:   for (;;) {
                   6036:     XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
                   6037:     if (ptr == end)
                   6038:       break;
                   6039:     if (!poolGrow(pool))
                   6040:       return NULL;
                   6041:   }
                   6042:   return pool->start;
                   6043: }
                   6044: 
                   6045: static const XML_Char * FASTCALL
                   6046: poolCopyString(STRING_POOL *pool, const XML_Char *s)
                   6047: {
                   6048:   do {
                   6049:     if (!poolAppendChar(pool, *s))
                   6050:       return NULL;
                   6051:   } while (*s++);
                   6052:   s = pool->start;
                   6053:   poolFinish(pool);
                   6054:   return s;
                   6055: }
                   6056: 
                   6057: static const XML_Char *
                   6058: poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n)
                   6059: {
                   6060:   if (!pool->ptr && !poolGrow(pool))
                   6061:     return NULL;
                   6062:   for (; n > 0; --n, s++) {
                   6063:     if (!poolAppendChar(pool, *s))
                   6064:       return NULL;
                   6065:   }
                   6066:   s = pool->start;
                   6067:   poolFinish(pool);
                   6068:   return s;
                   6069: }
                   6070: 
                   6071: static const XML_Char * FASTCALL
                   6072: poolAppendString(STRING_POOL *pool, const XML_Char *s)
                   6073: {
                   6074:   while (*s) {
                   6075:     if (!poolAppendChar(pool, *s))
                   6076:       return NULL;
                   6077:     s++;
                   6078:   }
                   6079:   return pool->start;
                   6080: }
                   6081: 
                   6082: static XML_Char *
                   6083: poolStoreString(STRING_POOL *pool, const ENCODING *enc,
                   6084:                 const char *ptr, const char *end)
                   6085: {
                   6086:   if (!poolAppend(pool, enc, ptr, end))
                   6087:     return NULL;
                   6088:   if (pool->ptr == pool->end && !poolGrow(pool))
                   6089:     return NULL;
                   6090:   *(pool->ptr)++ = 0;
                   6091:   return pool->start;
                   6092: }
                   6093: 
                   6094: static XML_Bool FASTCALL
                   6095: poolGrow(STRING_POOL *pool)
                   6096: {
                   6097:   if (pool->freeBlocks) {
                   6098:     if (pool->start == 0) {
                   6099:       pool->blocks = pool->freeBlocks;
                   6100:       pool->freeBlocks = pool->freeBlocks->next;
                   6101:       pool->blocks->next = NULL;
                   6102:       pool->start = pool->blocks->s;
                   6103:       pool->end = pool->start + pool->blocks->size;
                   6104:       pool->ptr = pool->start;
                   6105:       return XML_TRUE;
                   6106:     }
                   6107:     if (pool->end - pool->start < pool->freeBlocks->size) {
                   6108:       BLOCK *tem = pool->freeBlocks->next;
                   6109:       pool->freeBlocks->next = pool->blocks;
                   6110:       pool->blocks = pool->freeBlocks;
                   6111:       pool->freeBlocks = tem;
                   6112:       memcpy(pool->blocks->s, pool->start,
                   6113:              (pool->end - pool->start) * sizeof(XML_Char));
                   6114:       pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
                   6115:       pool->start = pool->blocks->s;
                   6116:       pool->end = pool->start + pool->blocks->size;
                   6117:       return XML_TRUE;
                   6118:     }
                   6119:   }
                   6120:   if (pool->blocks && pool->start == pool->blocks->s) {
                   6121:     int blockSize = (int)(pool->end - pool->start)*2;
                   6122:     pool->blocks = (BLOCK *)
                   6123:       pool->mem->realloc_fcn(pool->blocks,
                   6124:                              (offsetof(BLOCK, s)
                   6125:                               + blockSize * sizeof(XML_Char)));
                   6126:     if (pool->blocks == NULL)
                   6127:       return XML_FALSE;
                   6128:     pool->blocks->size = blockSize;
                   6129:     pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
                   6130:     pool->start = pool->blocks->s;
                   6131:     pool->end = pool->start + blockSize;
                   6132:   }
                   6133:   else {
                   6134:     BLOCK *tem;
                   6135:     int blockSize = (int)(pool->end - pool->start);
                   6136:     if (blockSize < INIT_BLOCK_SIZE)
                   6137:       blockSize = INIT_BLOCK_SIZE;
                   6138:     else
                   6139:       blockSize *= 2;
                   6140:     tem = (BLOCK *)pool->mem->malloc_fcn(offsetof(BLOCK, s)
                   6141:                                         + blockSize * sizeof(XML_Char));
                   6142:     if (!tem)
                   6143:       return XML_FALSE;
                   6144:     tem->size = blockSize;
                   6145:     tem->next = pool->blocks;
                   6146:     pool->blocks = tem;
                   6147:     if (pool->ptr != pool->start)
                   6148:       memcpy(tem->s, pool->start,
                   6149:              (pool->ptr - pool->start) * sizeof(XML_Char));
                   6150:     pool->ptr = tem->s + (pool->ptr - pool->start);
                   6151:     pool->start = tem->s;
                   6152:     pool->end = tem->s + blockSize;
                   6153:   }
                   6154:   return XML_TRUE;
                   6155: }
                   6156: 
                   6157: static int FASTCALL
                   6158: nextScaffoldPart(XML_Parser parser)
                   6159: {
                   6160:   DTD * const dtd = _dtd;  /* save one level of indirection */
                   6161:   CONTENT_SCAFFOLD * me;
                   6162:   int next;
                   6163: 
                   6164:   if (!dtd->scaffIndex) {
                   6165:     dtd->scaffIndex = (int *)MALLOC(groupSize * sizeof(int));
                   6166:     if (!dtd->scaffIndex)
                   6167:       return -1;
                   6168:     dtd->scaffIndex[0] = 0;
                   6169:   }
                   6170: 
                   6171:   if (dtd->scaffCount >= dtd->scaffSize) {
                   6172:     CONTENT_SCAFFOLD *temp;
                   6173:     if (dtd->scaffold) {
                   6174:       temp = (CONTENT_SCAFFOLD *)
                   6175:         REALLOC(dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
                   6176:       if (temp == NULL)
                   6177:         return -1;
                   6178:       dtd->scaffSize *= 2;
                   6179:     }
                   6180:     else {
                   6181:       temp = (CONTENT_SCAFFOLD *)MALLOC(INIT_SCAFFOLD_ELEMENTS
                   6182:                                         * sizeof(CONTENT_SCAFFOLD));
                   6183:       if (temp == NULL)
                   6184:         return -1;
                   6185:       dtd->scaffSize = INIT_SCAFFOLD_ELEMENTS;
                   6186:     }
                   6187:     dtd->scaffold = temp;
                   6188:   }
                   6189:   next = dtd->scaffCount++;
                   6190:   me = &dtd->scaffold[next];
                   6191:   if (dtd->scaffLevel) {
                   6192:     CONTENT_SCAFFOLD *parent = &dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel-1]];
                   6193:     if (parent->lastchild) {
                   6194:       dtd->scaffold[parent->lastchild].nextsib = next;
                   6195:     }
                   6196:     if (!parent->childcnt)
                   6197:       parent->firstchild = next;
                   6198:     parent->lastchild = next;
                   6199:     parent->childcnt++;
                   6200:   }
                   6201:   me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;
                   6202:   return next;
                   6203: }
                   6204: 
                   6205: static void
                   6206: build_node(XML_Parser parser,
                   6207:            int src_node,
                   6208:            XML_Content *dest,
                   6209:            XML_Content **contpos,
                   6210:            XML_Char **strpos)
                   6211: {
                   6212:   DTD * const dtd = _dtd;  /* save one level of indirection */
                   6213:   dest->type = dtd->scaffold[src_node].type;
                   6214:   dest->quant = dtd->scaffold[src_node].quant;
                   6215:   if (dest->type == XML_CTYPE_NAME) {
                   6216:     const XML_Char *src;
                   6217:     dest->name = *strpos;
                   6218:     src = dtd->scaffold[src_node].name;
                   6219:     for (;;) {
                   6220:       *(*strpos)++ = *src;
                   6221:       if (!*src)
                   6222:         break;
                   6223:       src++;
                   6224:     }
                   6225:     dest->numchildren = 0;
                   6226:     dest->children = NULL;
                   6227:   }
                   6228:   else {
                   6229:     unsigned int i;
                   6230:     int cn;
                   6231:     dest->numchildren = dtd->scaffold[src_node].childcnt;
                   6232:     dest->children = *contpos;
                   6233:     *contpos += dest->numchildren;
                   6234:     for (i = 0, cn = dtd->scaffold[src_node].firstchild;
                   6235:          i < dest->numchildren;
                   6236:          i++, cn = dtd->scaffold[cn].nextsib) {
                   6237:       build_node(parser, cn, &(dest->children[i]), contpos, strpos);
                   6238:     }
                   6239:     dest->name = NULL;
                   6240:   }
                   6241: }
                   6242: 
                   6243: static XML_Content *
                   6244: build_model (XML_Parser parser)
                   6245: {
                   6246:   DTD * const dtd = _dtd;  /* save one level of indirection */
                   6247:   XML_Content *ret;
                   6248:   XML_Content *cpos;
                   6249:   XML_Char * str;
                   6250:   int allocsize = (dtd->scaffCount * sizeof(XML_Content)
                   6251:                    + (dtd->contentStringLen * sizeof(XML_Char)));
                   6252: 
                   6253:   ret = (XML_Content *)MALLOC(allocsize);
                   6254:   if (!ret)
                   6255:     return NULL;
                   6256: 
                   6257:   str =  (XML_Char *) (&ret[dtd->scaffCount]);
                   6258:   cpos = &ret[1];
                   6259: 
                   6260:   build_node(parser, 0, ret, &cpos, &str);
                   6261:   return ret;
                   6262: }
                   6263: 
                   6264: static ELEMENT_TYPE *
                   6265: getElementType(XML_Parser parser,
                   6266:                const ENCODING *enc,
                   6267:                const char *ptr,
                   6268:                const char *end)
                   6269: {
                   6270:   DTD * const dtd = _dtd;  /* save one level of indirection */
                   6271:   const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end);
                   6272:   ELEMENT_TYPE *ret;
                   6273: 
                   6274:   if (!name)
                   6275:     return NULL;
                   6276:   ret = (ELEMENT_TYPE *) lookup(&dtd->elementTypes, name, sizeof(ELEMENT_TYPE));
                   6277:   if (!ret)
                   6278:     return NULL;
                   6279:   if (ret->name != name)
                   6280:     poolDiscard(&dtd->pool);
                   6281:   else {
                   6282:     poolFinish(&dtd->pool);
                   6283:     if (!setElementTypePrefix(parser, ret))
                   6284:       return NULL;
                   6285:   }
                   6286:   return ret;
                   6287: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>