Annotation of embedaddon/expat/lib/xmlparse.c, revision 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>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xmlparse.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / expat / lib