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 } 6288
