Annotation of libwww/modules/expat/xmlparse/xmlparse.c, revision 1.1
1.1 ! frystyk 1: /*
! 2: The contents of this file are subject to the Mozilla Public License
! 3: Version 1.0 (the "License"); you may not use this file except in
! 4: compliance with the License. You may obtain a copy of the License at
! 5: http://www.mozilla.org/MPL/
! 6:
! 7: Software distributed under the License is distributed on an "AS IS"
! 8: basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
! 9: License for the specific language governing rights and limitations
! 10: under the License.
! 11:
! 12: The Original Code is expat.
! 13:
! 14: The Initial Developer of the Original Code is James Clark.
! 15: Portions created by James Clark are Copyright (C) 1998
! 16: James Clark. All Rights Reserved.
! 17:
! 18: Contributor(s):
! 19: */
! 20:
! 21: #include <stdlib.h>
! 22: #include <string.h>
! 23: #include <stddef.h>
! 24:
! 25: #include "xmldef.h"
! 26:
! 27: #ifdef XML_UNICODE
! 28: #define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
! 29: #define XmlConvert XmlUtf16Convert
! 30: #define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
! 31: #define XmlEncode XmlUtf16Encode
! 32: #define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((unsigned long)s) & 1))
! 33: typedef unsigned short ICHAR;
! 34: #else
! 35: #define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
! 36: #define XmlConvert XmlUtf8Convert
! 37: #define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
! 38: #define XmlEncode XmlUtf8Encode
! 39: #define MUST_CONVERT(enc, s) (!(enc)->isUtf8)
! 40: typedef char ICHAR;
! 41: #endif
! 42:
! 43: #ifdef XML_UNICODE_WCHAR_T
! 44: #define XML_T(x) L ## x
! 45: #else
! 46: #define XML_T(x) x
! 47: #endif
! 48:
! 49: /* Round up n to be a multiple of sz, where sz is a power of 2. */
! 50: #define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1))
! 51:
! 52: #include "xmlparse.h"
! 53: #include "xmltok.h"
! 54: #include "xmlrole.h"
! 55: #include "hashtable.h"
! 56:
! 57: #define INIT_TAG_BUF_SIZE 32 /* must be a multiple of sizeof(XML_Char) */
! 58: #define INIT_DATA_BUF_SIZE 1024
! 59: #define INIT_ATTS_SIZE 16
! 60: #define INIT_BLOCK_SIZE 1024
! 61: #define INIT_BUFFER_SIZE 1024
! 62:
! 63: typedef struct tag {
! 64: struct tag *parent;
! 65: const char *rawName;
! 66: int rawNameLength;
! 67: const XML_Char *name;
! 68: char *buf;
! 69: char *bufEnd;
! 70: } TAG;
! 71:
! 72: typedef struct {
! 73: const XML_Char *name;
! 74: const XML_Char *textPtr;
! 75: int textLen;
! 76: const XML_Char *systemId;
! 77: const XML_Char *base;
! 78: const XML_Char *publicId;
! 79: const XML_Char *notation;
! 80: char open;
! 81: } ENTITY;
! 82:
! 83: typedef struct block {
! 84: struct block *next;
! 85: int size;
! 86: XML_Char s[1];
! 87: } BLOCK;
! 88:
! 89: typedef struct {
! 90: BLOCK *blocks;
! 91: BLOCK *freeBlocks;
! 92: const XML_Char *end;
! 93: XML_Char *ptr;
! 94: XML_Char *start;
! 95: } STRING_POOL;
! 96:
! 97: /* The XML_Char before the name is used to determine whether
! 98: an attribute has been specified. */
! 99: typedef struct {
! 100: XML_Char *name;
! 101: char maybeTokenized;
! 102: } ATTRIBUTE_ID;
! 103:
! 104: typedef struct {
! 105: const ATTRIBUTE_ID *id;
! 106: char isCdata;
! 107: const XML_Char *value;
! 108: } DEFAULT_ATTRIBUTE;
! 109:
! 110: typedef struct {
! 111: const XML_Char *name;
! 112: int nDefaultAtts;
! 113: int allocDefaultAtts;
! 114: DEFAULT_ATTRIBUTE *defaultAtts;
! 115: } ELEMENT_TYPE;
! 116:
! 117: typedef struct {
! 118: HASH_TABLE generalEntities;
! 119: HASH_TABLE elementTypes;
! 120: HASH_TABLE attributeIds;
! 121: STRING_POOL pool;
! 122: int complete;
! 123: int standalone;
! 124: const XML_Char *base;
! 125: } DTD;
! 126:
! 127: typedef enum XML_Error Processor(XML_Parser parser,
! 128: const char *start,
! 129: const char *end,
! 130: const char **endPtr);
! 131:
! 132: static Processor prologProcessor;
! 133: static Processor prologInitProcessor;
! 134: static Processor contentProcessor;
! 135: static Processor cdataSectionProcessor;
! 136: static Processor epilogProcessor;
! 137: static Processor errorProcessor;
! 138: static Processor externalEntityInitProcessor;
! 139: static Processor externalEntityInitProcessor2;
! 140: static Processor externalEntityInitProcessor3;
! 141: static Processor externalEntityContentProcessor;
! 142:
! 143: static enum XML_Error
! 144: handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);
! 145: static enum XML_Error
! 146: processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *, const char *);
! 147: static enum XML_Error
! 148: initializeEncoding(XML_Parser parser);
! 149: static enum XML_Error
! 150: doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
! 151: const char *start, const char *end, const char **endPtr);
! 152: static enum XML_Error
! 153: doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr, const char *end, const char **nextPtr);
! 154: static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *, const XML_Char *tagName, const char *s);
! 155: static int
! 156: defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, int isCdata, const XML_Char *dfltValue);
! 157: static enum XML_Error
! 158: storeAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *,
! 159: STRING_POOL *);
! 160: static enum XML_Error
! 161: appendAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *,
! 162: STRING_POOL *);
! 163: static ATTRIBUTE_ID *
! 164: getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
! 165: static enum XML_Error
! 166: storeEntityValue(XML_Parser parser, const char *start, const char *end);
! 167: static int
! 168: reportProcessingInstruction(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
! 169: static void
! 170: reportDefault(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
! 171:
! 172: static const XML_Char *getOpenEntityNames(XML_Parser parser);
! 173: static int setOpenEntityNames(XML_Parser parser, const XML_Char *openEntityNames);
! 174: static void normalizePublicId(XML_Char *s);
! 175: static int dtdInit(DTD *);
! 176: static void dtdDestroy(DTD *);
! 177: static int dtdCopy(DTD *newDtd, const DTD *oldDtd);
! 178: static void poolInit(STRING_POOL *);
! 179: static void poolClear(STRING_POOL *);
! 180: static void poolDestroy(STRING_POOL *);
! 181: static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
! 182: const char *ptr, const char *end);
! 183: static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
! 184: const char *ptr, const char *end);
! 185: static int poolGrow(STRING_POOL *pool);
! 186: static const XML_Char *poolCopyString(STRING_POOL *pool, const XML_Char *s);
! 187: static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n);
! 188:
! 189: #define poolStart(pool) ((pool)->start)
! 190: #define poolEnd(pool) ((pool)->ptr)
! 191: #define poolLength(pool) ((pool)->ptr - (pool)->start)
! 192: #define poolChop(pool) ((void)--(pool->ptr))
! 193: #define poolLastChar(pool) (((pool)->ptr)[-1])
! 194: #define poolDiscard(pool) ((pool)->ptr = (pool)->start)
! 195: #define poolFinish(pool) ((pool)->start = (pool)->ptr)
! 196: #define poolAppendChar(pool, c) \
! 197: (((pool)->ptr == (pool)->end && !poolGrow(pool)) \
! 198: ? 0 \
! 199: : ((*((pool)->ptr)++ = c), 1))
! 200:
! 201: typedef struct {
! 202: /* The first member must be userData so that the XML_GetUserData macro works. */
! 203: void *userData;
! 204: void *handlerArg;
! 205: char *buffer;
! 206: /* first character to be parsed */
! 207: const char *bufferPtr;
! 208: /* past last character to be parsed */
! 209: char *bufferEnd;
! 210: /* allocated end of buffer */
! 211: const char *bufferLim;
! 212: long parseEndByteIndex;
! 213: const char *parseEndPtr;
! 214: XML_Char *dataBuf;
! 215: XML_Char *dataBufEnd;
! 216: XML_StartElementHandler startElementHandler;
! 217: XML_EndElementHandler endElementHandler;
! 218: XML_CharacterDataHandler characterDataHandler;
! 219: XML_ProcessingInstructionHandler processingInstructionHandler;
! 220: XML_DefaultHandler defaultHandler;
! 221: XML_UnparsedEntityDeclHandler unparsedEntityDeclHandler;
! 222: XML_NotationDeclHandler notationDeclHandler;
! 223: XML_ExternalEntityRefHandler externalEntityRefHandler;
! 224: XML_UnknownEncodingHandler unknownEncodingHandler;
! 225: const ENCODING *encoding;
! 226: INIT_ENCODING initEncoding;
! 227: const XML_Char *protocolEncodingName;
! 228: void *unknownEncodingMem;
! 229: void *unknownEncodingData;
! 230: void *unknownEncodingHandlerData;
! 231: void (*unknownEncodingRelease)(void *);
! 232: PROLOG_STATE prologState;
! 233: Processor *processor;
! 234: enum XML_Error errorCode;
! 235: const char *eventPtr;
! 236: const char *eventEndPtr;
! 237: const char *positionPtr;
! 238: int tagLevel;
! 239: ENTITY *declEntity;
! 240: const XML_Char *declNotationName;
! 241: const XML_Char *declNotationPublicId;
! 242: ELEMENT_TYPE *declElementType;
! 243: ATTRIBUTE_ID *declAttributeId;
! 244: char declAttributeIsCdata;
! 245: DTD dtd;
! 246: TAG *tagStack;
! 247: TAG *freeTagList;
! 248: int attsSize;
! 249: ATTRIBUTE *atts;
! 250: POSITION position;
! 251: STRING_POOL tempPool;
! 252: STRING_POOL temp2Pool;
! 253: char *groupConnector;
! 254: unsigned groupSize;
! 255: int hadExternalDoctype;
! 256: } Parser;
! 257:
! 258: #define userData (((Parser *)parser)->userData)
! 259: #define handlerArg (((Parser *)parser)->handlerArg)
! 260: #define startElementHandler (((Parser *)parser)->startElementHandler)
! 261: #define endElementHandler (((Parser *)parser)->endElementHandler)
! 262: #define characterDataHandler (((Parser *)parser)->characterDataHandler)
! 263: #define processingInstructionHandler (((Parser *)parser)->processingInstructionHandler)
! 264: #define defaultHandler (((Parser *)parser)->defaultHandler)
! 265: #define unparsedEntityDeclHandler (((Parser *)parser)->unparsedEntityDeclHandler)
! 266: #define notationDeclHandler (((Parser *)parser)->notationDeclHandler)
! 267: #define externalEntityRefHandler (((Parser *)parser)->externalEntityRefHandler)
! 268: #define unknownEncodingHandler (((Parser *)parser)->unknownEncodingHandler)
! 269: #define encoding (((Parser *)parser)->encoding)
! 270: #define initEncoding (((Parser *)parser)->initEncoding)
! 271: #define unknownEncodingMem (((Parser *)parser)->unknownEncodingMem)
! 272: #define unknownEncodingData (((Parser *)parser)->unknownEncodingData)
! 273: #define unknownEncodingHandlerData \
! 274: (((Parser *)parser)->unknownEncodingHandlerData)
! 275: #define unknownEncodingRelease (((Parser *)parser)->unknownEncodingRelease)
! 276: #define protocolEncodingName (((Parser *)parser)->protocolEncodingName)
! 277: #define prologState (((Parser *)parser)->prologState)
! 278: #define processor (((Parser *)parser)->processor)
! 279: #define errorCode (((Parser *)parser)->errorCode)
! 280: #define eventPtr (((Parser *)parser)->eventPtr)
! 281: #define eventEndPtr (((Parser *)parser)->eventEndPtr)
! 282: #define positionPtr (((Parser *)parser)->positionPtr)
! 283: #define position (((Parser *)parser)->position)
! 284: #define tagLevel (((Parser *)parser)->tagLevel)
! 285: #define buffer (((Parser *)parser)->buffer)
! 286: #define bufferPtr (((Parser *)parser)->bufferPtr)
! 287: #define bufferEnd (((Parser *)parser)->bufferEnd)
! 288: #define parseEndByteIndex (((Parser *)parser)->parseEndByteIndex)
! 289: #define parseEndPtr (((Parser *)parser)->parseEndPtr)
! 290: #define bufferLim (((Parser *)parser)->bufferLim)
! 291: #define dataBuf (((Parser *)parser)->dataBuf)
! 292: #define dataBufEnd (((Parser *)parser)->dataBufEnd)
! 293: #define dtd (((Parser *)parser)->dtd)
! 294: #define declEntity (((Parser *)parser)->declEntity)
! 295: #define declNotationName (((Parser *)parser)->declNotationName)
! 296: #define declNotationPublicId (((Parser *)parser)->declNotationPublicId)
! 297: #define declElementType (((Parser *)parser)->declElementType)
! 298: #define declAttributeId (((Parser *)parser)->declAttributeId)
! 299: #define declAttributeIsCdata (((Parser *)parser)->declAttributeIsCdata)
! 300: #define freeTagList (((Parser *)parser)->freeTagList)
! 301: #define tagStack (((Parser *)parser)->tagStack)
! 302: #define atts (((Parser *)parser)->atts)
! 303: #define attsSize (((Parser *)parser)->attsSize)
! 304: #define tempPool (((Parser *)parser)->tempPool)
! 305: #define temp2Pool (((Parser *)parser)->temp2Pool)
! 306: #define groupConnector (((Parser *)parser)->groupConnector)
! 307: #define groupSize (((Parser *)parser)->groupSize)
! 308: #define hadExternalDoctype (((Parser *)parser)->hadExternalDoctype)
! 309:
! 310: XML_Parser XML_ParserCreate(const XML_Char *encodingName)
! 311: {
! 312: XML_Parser parser = malloc(sizeof(Parser));
! 313: if (!parser)
! 314: return parser;
! 315: processor = prologInitProcessor;
! 316: XmlPrologStateInit(&prologState);
! 317: userData = 0;
! 318: handlerArg = 0;
! 319: startElementHandler = 0;
! 320: endElementHandler = 0;
! 321: characterDataHandler = 0;
! 322: processingInstructionHandler = 0;
! 323: defaultHandler = 0;
! 324: unparsedEntityDeclHandler = 0;
! 325: notationDeclHandler = 0;
! 326: externalEntityRefHandler = 0;
! 327: unknownEncodingHandler = 0;
! 328: buffer = 0;
! 329: bufferPtr = 0;
! 330: bufferEnd = 0;
! 331: parseEndByteIndex = 0;
! 332: parseEndPtr = 0;
! 333: bufferLim = 0;
! 334: declElementType = 0;
! 335: declAttributeId = 0;
! 336: declEntity = 0;
! 337: declNotationName = 0;
! 338: declNotationPublicId = 0;
! 339: memset(&position, 0, sizeof(POSITION));
! 340: errorCode = XML_ERROR_NONE;
! 341: eventPtr = 0;
! 342: eventEndPtr = 0;
! 343: positionPtr = 0;
! 344: tagLevel = 0;
! 345: tagStack = 0;
! 346: freeTagList = 0;
! 347: attsSize = INIT_ATTS_SIZE;
! 348: atts = malloc(attsSize * sizeof(ATTRIBUTE));
! 349: dataBuf = malloc(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
! 350: groupSize = 0;
! 351: groupConnector = 0;
! 352: hadExternalDoctype = 0;
! 353: unknownEncodingMem = 0;
! 354: unknownEncodingRelease = 0;
! 355: unknownEncodingData = 0;
! 356: unknownEncodingHandlerData = 0;
! 357: poolInit(&tempPool);
! 358: poolInit(&temp2Pool);
! 359: protocolEncodingName = encodingName ? poolCopyString(&tempPool, encodingName) : 0;
! 360: if (!dtdInit(&dtd) || !atts || !dataBuf
! 361: || (encodingName && !protocolEncodingName)) {
! 362: XML_ParserFree(parser);
! 363: return 0;
! 364: }
! 365: dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;
! 366: XmlInitEncoding(&initEncoding, &encoding, 0);
! 367: return parser;
! 368: }
! 369:
! 370: XML_Parser XML_ExternalEntityParserCreate(XML_Parser oldParser,
! 371: const XML_Char *openEntityNames,
! 372: const XML_Char *encodingName)
! 373: {
! 374: XML_Parser parser = oldParser;
! 375: DTD *oldDtd = &dtd;
! 376: XML_StartElementHandler oldStartElementHandler = startElementHandler;
! 377: XML_EndElementHandler oldEndElementHandler = endElementHandler;
! 378: XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;
! 379: XML_ProcessingInstructionHandler oldProcessingInstructionHandler = processingInstructionHandler;
! 380: XML_DefaultHandler oldDefaultHandler = defaultHandler;
! 381: XML_ExternalEntityRefHandler oldExternalEntityRefHandler = externalEntityRefHandler;
! 382: XML_UnknownEncodingHandler oldUnknownEncodingHandler = unknownEncodingHandler;
! 383: void *oldUserData = userData;
! 384: void *oldHandlerArg = handlerArg;
! 385:
! 386: parser = XML_ParserCreate(encodingName);
! 387: if (!parser)
! 388: return 0;
! 389: startElementHandler = oldStartElementHandler;
! 390: endElementHandler = oldEndElementHandler;
! 391: characterDataHandler = oldCharacterDataHandler;
! 392: processingInstructionHandler = oldProcessingInstructionHandler;
! 393: defaultHandler = oldDefaultHandler;
! 394: externalEntityRefHandler = oldExternalEntityRefHandler;
! 395: unknownEncodingHandler = oldUnknownEncodingHandler;
! 396: userData = oldUserData;
! 397: if (oldUserData == oldHandlerArg)
! 398: handlerArg = userData;
! 399: else
! 400: handlerArg = parser;
! 401: if (!dtdCopy(&dtd, oldDtd) || !setOpenEntityNames(parser, openEntityNames)) {
! 402: XML_ParserFree(parser);
! 403: return 0;
! 404: }
! 405: processor = externalEntityInitProcessor;
! 406: return parser;
! 407: }
! 408:
! 409: void XML_ParserFree(XML_Parser parser)
! 410: {
! 411: for (;;) {
! 412: TAG *p;
! 413: if (tagStack == 0) {
! 414: if (freeTagList == 0)
! 415: break;
! 416: tagStack = freeTagList;
! 417: freeTagList = 0;
! 418: }
! 419: p = tagStack;
! 420: tagStack = tagStack->parent;
! 421: free(p->buf);
! 422: free(p);
! 423: }
! 424: poolDestroy(&tempPool);
! 425: poolDestroy(&temp2Pool);
! 426: dtdDestroy(&dtd);
! 427: free((void *)atts);
! 428: free(groupConnector);
! 429: free(buffer);
! 430: free(dataBuf);
! 431: free(unknownEncodingMem);
! 432: if (unknownEncodingRelease)
! 433: unknownEncodingRelease(unknownEncodingData);
! 434: free(parser);
! 435: }
! 436:
! 437: void XML_UseParserAsHandlerArg(XML_Parser parser)
! 438: {
! 439: handlerArg = parser;
! 440: }
! 441:
! 442: void XML_SetUserData(XML_Parser parser, void *p)
! 443: {
! 444: if (handlerArg == userData)
! 445: handlerArg = userData = p;
! 446: else
! 447: userData = p;
! 448: }
! 449:
! 450: int XML_SetBase(XML_Parser parser, const XML_Char *p)
! 451: {
! 452: if (p) {
! 453: p = poolCopyString(&dtd.pool, p);
! 454: if (!p)
! 455: return 0;
! 456: dtd.base = p;
! 457: }
! 458: else
! 459: dtd.base = 0;
! 460: return 1;
! 461: }
! 462:
! 463: const XML_Char *XML_GetBase(XML_Parser parser)
! 464: {
! 465: return dtd.base;
! 466: }
! 467:
! 468: void XML_SetElementHandler(XML_Parser parser,
! 469: XML_StartElementHandler start,
! 470: XML_EndElementHandler end)
! 471: {
! 472: startElementHandler = start;
! 473: endElementHandler = end;
! 474: }
! 475:
! 476: void XML_SetCharacterDataHandler(XML_Parser parser,
! 477: XML_CharacterDataHandler handler)
! 478: {
! 479: characterDataHandler = handler;
! 480: }
! 481:
! 482: void XML_SetProcessingInstructionHandler(XML_Parser parser,
! 483: XML_ProcessingInstructionHandler handler)
! 484: {
! 485: processingInstructionHandler = handler;
! 486: }
! 487:
! 488: void XML_SetDefaultHandler(XML_Parser parser,
! 489: XML_DefaultHandler handler)
! 490: {
! 491: defaultHandler = handler;
! 492: }
! 493:
! 494: void XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
! 495: XML_UnparsedEntityDeclHandler handler)
! 496: {
! 497: unparsedEntityDeclHandler = handler;
! 498: }
! 499:
! 500: void XML_SetNotationDeclHandler(XML_Parser parser,
! 501: XML_NotationDeclHandler handler)
! 502: {
! 503: notationDeclHandler = handler;
! 504: }
! 505:
! 506: void XML_SetExternalEntityRefHandler(XML_Parser parser,
! 507: XML_ExternalEntityRefHandler handler)
! 508: {
! 509: externalEntityRefHandler = handler;
! 510: }
! 511:
! 512: void XML_SetUnknownEncodingHandler(XML_Parser parser,
! 513: XML_UnknownEncodingHandler handler,
! 514: void *data)
! 515: {
! 516: unknownEncodingHandler = handler;
! 517: unknownEncodingHandlerData = data;
! 518: }
! 519:
! 520: int XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
! 521: {
! 522: if (len == 0) {
! 523: if (!isFinal)
! 524: return 1;
! 525: errorCode = processor(parser, bufferPtr, parseEndPtr = bufferEnd, 0);
! 526: if (errorCode == XML_ERROR_NONE)
! 527: return 1;
! 528: eventEndPtr = eventPtr;
! 529: return 0;
! 530: }
! 531: else if (bufferPtr == bufferEnd) {
! 532: const char *end;
! 533: int nLeftOver;
! 534: parseEndByteIndex += len;
! 535: positionPtr = s;
! 536: if (isFinal) {
! 537: errorCode = processor(parser, s, parseEndPtr = s + len, 0);
! 538: if (errorCode == XML_ERROR_NONE)
! 539: return 1;
! 540: eventEndPtr = eventPtr;
! 541: return 0;
! 542: }
! 543: errorCode = processor(parser, s, parseEndPtr = s + len, &end);
! 544: if (errorCode != XML_ERROR_NONE) {
! 545: eventEndPtr = eventPtr;
! 546: return 0;
! 547: }
! 548: XmlUpdatePosition(encoding, positionPtr, end, &position);
! 549: nLeftOver = s + len - end;
! 550: if (nLeftOver) {
! 551: if (buffer == 0 || nLeftOver > bufferLim - buffer) {
! 552: /* FIXME avoid integer overflow */
! 553: buffer = buffer == 0 ? malloc(len * 2) : realloc(buffer, len * 2);
! 554: if (!buffer) {
! 555: errorCode = XML_ERROR_NO_MEMORY;
! 556: eventPtr = eventEndPtr = 0;
! 557: return 0;
! 558: }
! 559: bufferLim = buffer + len * 2;
! 560: }
! 561: memcpy(buffer, end, nLeftOver);
! 562: bufferPtr = buffer;
! 563: bufferEnd = buffer + nLeftOver;
! 564: }
! 565: return 1;
! 566: }
! 567: else {
! 568: memcpy(XML_GetBuffer(parser, len), s, len);
! 569: return XML_ParseBuffer(parser, len, isFinal);
! 570: }
! 571: }
! 572:
! 573: int XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
! 574: {
! 575: const char *start = bufferPtr;
! 576: positionPtr = start;
! 577: bufferEnd += len;
! 578: parseEndByteIndex += len;
! 579: errorCode = processor(parser, start, parseEndPtr = bufferEnd,
! 580: isFinal ? (const char **)0 : &bufferPtr);
! 581: if (errorCode == XML_ERROR_NONE) {
! 582: if (!isFinal)
! 583: XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
! 584: return 1;
! 585: }
! 586: else {
! 587: eventEndPtr = eventPtr;
! 588: return 0;
! 589: }
! 590: }
! 591:
! 592: void *XML_GetBuffer(XML_Parser parser, int len)
! 593: {
! 594: if (len > bufferLim - bufferEnd) {
! 595: /* FIXME avoid integer overflow */
! 596: int neededSize = len + (bufferEnd - bufferPtr);
! 597: if (neededSize <= bufferLim - buffer) {
! 598: memmove(buffer, bufferPtr, bufferEnd - bufferPtr);
! 599: bufferEnd = buffer + (bufferEnd - bufferPtr);
! 600: bufferPtr = buffer;
! 601: }
! 602: else {
! 603: char *newBuf;
! 604: int bufferSize = bufferLim - bufferPtr;
! 605: if (bufferSize == 0)
! 606: bufferSize = INIT_BUFFER_SIZE;
! 607: do {
! 608: bufferSize *= 2;
! 609: } while (bufferSize < neededSize);
! 610: newBuf = malloc(bufferSize);
! 611: if (newBuf == 0) {
! 612: errorCode = XML_ERROR_NO_MEMORY;
! 613: return 0;
! 614: }
! 615: bufferLim = newBuf + bufferSize;
! 616: if (bufferPtr) {
! 617: memcpy(newBuf, bufferPtr, bufferEnd - bufferPtr);
! 618: free(buffer);
! 619: }
! 620: bufferEnd = newBuf + (bufferEnd - bufferPtr);
! 621: bufferPtr = buffer = newBuf;
! 622: }
! 623: }
! 624: return bufferEnd;
! 625: }
! 626:
! 627: enum XML_Error XML_GetErrorCode(XML_Parser parser)
! 628: {
! 629: return errorCode;
! 630: }
! 631:
! 632: long XML_GetCurrentByteIndex(XML_Parser parser)
! 633: {
! 634: if (eventPtr)
! 635: return parseEndByteIndex - (parseEndPtr - eventPtr);
! 636: return -1;
! 637: }
! 638:
! 639: int XML_GetCurrentLineNumber(XML_Parser parser)
! 640: {
! 641: if (eventPtr) {
! 642: XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
! 643: positionPtr = eventPtr;
! 644: }
! 645: return position.lineNumber + 1;
! 646: }
! 647:
! 648: int XML_GetCurrentColumnNumber(XML_Parser parser)
! 649: {
! 650: if (eventPtr) {
! 651: XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
! 652: positionPtr = eventPtr;
! 653: }
! 654: return position.columnNumber;
! 655: }
! 656:
! 657: void XML_DefaultCurrent(XML_Parser parser)
! 658: {
! 659: if (defaultHandler)
! 660: reportDefault(parser, encoding, eventPtr, eventEndPtr);
! 661: }
! 662:
! 663: const XML_LChar *XML_ErrorString(int code)
! 664: {
! 665: static const XML_LChar *message[] = {
! 666: 0,
! 667: XML_T("out of memory"),
! 668: XML_T("syntax error"),
! 669: XML_T("no element found"),
! 670: XML_T("not well-formed"),
! 671: XML_T("unclosed token"),
! 672: XML_T("unclosed token"),
! 673: XML_T("mismatched tag"),
! 674: XML_T("duplicate attribute"),
! 675: XML_T("junk after document element"),
! 676: XML_T("illegal parameter entity reference"),
! 677: XML_T("undefined entity"),
! 678: XML_T("recursive entity reference"),
! 679: XML_T("asynchronous entity"),
! 680: XML_T("reference to invalid character number"),
! 681: XML_T("reference to binary entity"),
! 682: XML_T("reference to external entity in attribute"),
! 683: XML_T("xml processing instruction not at start of external entity"),
! 684: XML_T("unknown encoding"),
! 685: XML_T("encoding specified in XML declaration is incorrect"),
! 686: XML_T("unclosed CDATA section"),
! 687: XML_T("error in processing external entity reference")
! 688: };
! 689: if (code > 0 && code < sizeof(message)/sizeof(message[0]))
! 690: return message[code];
! 691: return 0;
! 692: }
! 693:
! 694: static
! 695: enum XML_Error contentProcessor(XML_Parser parser,
! 696: const char *start,
! 697: const char *end,
! 698: const char **endPtr)
! 699: {
! 700: return doContent(parser, 0, encoding, start, end, endPtr);
! 701: }
! 702:
! 703: static
! 704: enum XML_Error externalEntityInitProcessor(XML_Parser parser,
! 705: const char *start,
! 706: const char *end,
! 707: const char **endPtr)
! 708: {
! 709: enum XML_Error result = initializeEncoding(parser);
! 710: if (result != XML_ERROR_NONE)
! 711: return result;
! 712: processor = externalEntityInitProcessor2;
! 713: return externalEntityInitProcessor2(parser, start, end, endPtr);
! 714: }
! 715:
! 716: static
! 717: enum XML_Error externalEntityInitProcessor2(XML_Parser parser,
! 718: const char *start,
! 719: const char *end,
! 720: const char **endPtr)
! 721: {
! 722: const char *next;
! 723: int tok = XmlContentTok(encoding, start, end, &next);
! 724: switch (tok) {
! 725: case XML_TOK_BOM:
! 726: start = next;
! 727: break;
! 728: case XML_TOK_PARTIAL:
! 729: if (endPtr) {
! 730: *endPtr = start;
! 731: return XML_ERROR_NONE;
! 732: }
! 733: eventPtr = start;
! 734: return XML_ERROR_UNCLOSED_TOKEN;
! 735: case XML_TOK_PARTIAL_CHAR:
! 736: if (endPtr) {
! 737: *endPtr = start;
! 738: return XML_ERROR_NONE;
! 739: }
! 740: eventPtr = start;
! 741: return XML_ERROR_PARTIAL_CHAR;
! 742: }
! 743: processor = externalEntityInitProcessor3;
! 744: return externalEntityInitProcessor3(parser, start, end, endPtr);
! 745: }
! 746:
! 747: static
! 748: enum XML_Error externalEntityInitProcessor3(XML_Parser parser,
! 749: const char *start,
! 750: const char *end,
! 751: const char **endPtr)
! 752: {
! 753: const char *next;
! 754: int tok = XmlContentTok(encoding, start, end, &next);
! 755: switch (tok) {
! 756: case XML_TOK_XML_DECL:
! 757: {
! 758: enum XML_Error result = processXmlDecl(parser, 1, start, next);
! 759: if (result != XML_ERROR_NONE)
! 760: return result;
! 761: start = next;
! 762: }
! 763: break;
! 764: case XML_TOK_PARTIAL:
! 765: if (endPtr) {
! 766: *endPtr = start;
! 767: return XML_ERROR_NONE;
! 768: }
! 769: eventPtr = start;
! 770: return XML_ERROR_UNCLOSED_TOKEN;
! 771: case XML_TOK_PARTIAL_CHAR:
! 772: if (endPtr) {
! 773: *endPtr = start;
! 774: return XML_ERROR_NONE;
! 775: }
! 776: eventPtr = start;
! 777: return XML_ERROR_PARTIAL_CHAR;
! 778: }
! 779: processor = externalEntityContentProcessor;
! 780: tagLevel = 1;
! 781: return doContent(parser, 1, encoding, start, end, endPtr);
! 782: }
! 783:
! 784: static
! 785: enum XML_Error externalEntityContentProcessor(XML_Parser parser,
! 786: const char *start,
! 787: const char *end,
! 788: const char **endPtr)
! 789: {
! 790: return doContent(parser, 1, encoding, start, end, endPtr);
! 791: }
! 792:
! 793: static enum XML_Error
! 794: doContent(XML_Parser parser,
! 795: int startTagLevel,
! 796: const ENCODING *enc,
! 797: const char *s,
! 798: const char *end,
! 799: const char **nextPtr)
! 800: {
! 801: const ENCODING *internalEnc = XmlGetInternalEncoding();
! 802: const char *dummy;
! 803: const char **eventPP;
! 804: const char **eventEndPP;
! 805: if (enc == encoding) {
! 806: eventPP = &eventPtr;
! 807: *eventPP = s;
! 808: eventEndPP = &eventEndPtr;
! 809: }
! 810: else
! 811: eventPP = eventEndPP = &dummy;
! 812: for (;;) {
! 813: const char *next;
! 814: int tok = XmlContentTok(enc, s, end, &next);
! 815: *eventEndPP = next;
! 816: switch (tok) {
! 817: case XML_TOK_TRAILING_CR:
! 818: if (nextPtr) {
! 819: *nextPtr = s;
! 820: return XML_ERROR_NONE;
! 821: }
! 822: *eventEndPP = end;
! 823: if (characterDataHandler) {
! 824: XML_Char c = XML_T('\n');
! 825: characterDataHandler(handlerArg, &c, 1);
! 826: }
! 827: else if (defaultHandler)
! 828: reportDefault(parser, enc, s, end);
! 829: if (startTagLevel == 0)
! 830: return XML_ERROR_NO_ELEMENTS;
! 831: if (tagLevel != startTagLevel)
! 832: return XML_ERROR_ASYNC_ENTITY;
! 833: return XML_ERROR_NONE;
! 834: case XML_TOK_NONE:
! 835: if (nextPtr) {
! 836: *nextPtr = s;
! 837: return XML_ERROR_NONE;
! 838: }
! 839: if (startTagLevel > 0) {
! 840: if (tagLevel != startTagLevel)
! 841: return XML_ERROR_ASYNC_ENTITY;
! 842: return XML_ERROR_NONE;
! 843: }
! 844: return XML_ERROR_NO_ELEMENTS;
! 845: case XML_TOK_INVALID:
! 846: *eventPP = next;
! 847: return XML_ERROR_INVALID_TOKEN;
! 848: case XML_TOK_PARTIAL:
! 849: if (nextPtr) {
! 850: *nextPtr = s;
! 851: return XML_ERROR_NONE;
! 852: }
! 853: return XML_ERROR_UNCLOSED_TOKEN;
! 854: case XML_TOK_PARTIAL_CHAR:
! 855: if (nextPtr) {
! 856: *nextPtr = s;
! 857: return XML_ERROR_NONE;
! 858: }
! 859: return XML_ERROR_PARTIAL_CHAR;
! 860: case XML_TOK_ENTITY_REF:
! 861: {
! 862: const XML_Char *name;
! 863: ENTITY *entity;
! 864: XML_Char ch = XmlPredefinedEntityName(enc,
! 865: s + enc->minBytesPerChar,
! 866: next - enc->minBytesPerChar);
! 867: if (ch) {
! 868: if (characterDataHandler)
! 869: characterDataHandler(handlerArg, &ch, 1);
! 870: else if (defaultHandler)
! 871: reportDefault(parser, enc, s, next);
! 872: break;
! 873: }
! 874: name = poolStoreString(&dtd.pool, enc,
! 875: s + enc->minBytesPerChar,
! 876: next - enc->minBytesPerChar);
! 877: if (!name)
! 878: return XML_ERROR_NO_MEMORY;
! 879: entity = (ENTITY *)lookup(&dtd.generalEntities, name, 0);
! 880: poolDiscard(&dtd.pool);
! 881: if (!entity) {
! 882: if (dtd.complete || dtd.standalone)
! 883: return XML_ERROR_UNDEFINED_ENTITY;
! 884: if (defaultHandler)
! 885: reportDefault(parser, enc, s, next);
! 886: break;
! 887: }
! 888: if (entity->open)
! 889: return XML_ERROR_RECURSIVE_ENTITY_REF;
! 890: if (entity->notation)
! 891: return XML_ERROR_BINARY_ENTITY_REF;
! 892: if (entity) {
! 893: if (entity->textPtr) {
! 894: enum XML_Error result;
! 895: if (defaultHandler) {
! 896: reportDefault(parser, enc, s, next);
! 897: break;
! 898: }
! 899: /* Protect against the possibility that somebody sets
! 900: the defaultHandler from inside another handler. */
! 901: *eventEndPP = *eventPP;
! 902: entity->open = 1;
! 903: result = doContent(parser,
! 904: tagLevel,
! 905: internalEnc,
! 906: (char *)entity->textPtr,
! 907: (char *)(entity->textPtr + entity->textLen),
! 908: 0);
! 909: entity->open = 0;
! 910: if (result)
! 911: return result;
! 912: }
! 913: else if (externalEntityRefHandler) {
! 914: const XML_Char *openEntityNames;
! 915: entity->open = 1;
! 916: openEntityNames = getOpenEntityNames(parser);
! 917: entity->open = 0;
! 918: if (!openEntityNames)
! 919: return XML_ERROR_NO_MEMORY;
! 920: if (!externalEntityRefHandler(parser, openEntityNames, dtd.base, entity->systemId, entity->publicId))
! 921: return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
! 922: poolDiscard(&tempPool);
! 923: }
! 924: else if (defaultHandler)
! 925: reportDefault(parser, enc, s, next);
! 926: }
! 927: break;
! 928: }
! 929: case XML_TOK_START_TAG_WITH_ATTS:
! 930: if (!startElementHandler) {
! 931: enum XML_Error result = storeAtts(parser, enc, 0, s);
! 932: if (result)
! 933: return result;
! 934: }
! 935: /* fall through */
! 936: case XML_TOK_START_TAG_NO_ATTS:
! 937: {
! 938: TAG *tag;
! 939: if (freeTagList) {
! 940: tag = freeTagList;
! 941: freeTagList = freeTagList->parent;
! 942: }
! 943: else {
! 944: tag = malloc(sizeof(TAG));
! 945: if (!tag)
! 946: return XML_ERROR_NO_MEMORY;
! 947: tag->buf = malloc(INIT_TAG_BUF_SIZE);
! 948: if (!tag->buf)
! 949: return XML_ERROR_NO_MEMORY;
! 950: tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
! 951: }
! 952: tag->parent = tagStack;
! 953: tagStack = tag;
! 954: tag->rawName = s + enc->minBytesPerChar;
! 955: tag->rawNameLength = XmlNameLength(enc, tag->rawName);
! 956: if (nextPtr) {
! 957: if (tag->rawNameLength > tag->bufEnd - tag->buf) {
! 958: int bufSize = tag->rawNameLength * 4;
! 959: bufSize = ROUND_UP(bufSize, sizeof(XML_Char));
! 960: tag->buf = realloc(tag->buf, bufSize);
! 961: if (!tag->buf)
! 962: return XML_ERROR_NO_MEMORY;
! 963: tag->bufEnd = tag->buf + bufSize;
! 964: }
! 965: memcpy(tag->buf, tag->rawName, tag->rawNameLength);
! 966: tag->rawName = tag->buf;
! 967: }
! 968: ++tagLevel;
! 969: if (startElementHandler) {
! 970: enum XML_Error result;
! 971: XML_Char *toPtr;
! 972: for (;;) {
! 973: const char *rawNameEnd = tag->rawName + tag->rawNameLength;
! 974: const char *fromPtr = tag->rawName;
! 975: int bufSize;
! 976: if (nextPtr)
! 977: toPtr = (XML_Char *)(tag->buf + ROUND_UP(tag->rawNameLength, sizeof(XML_Char)));
! 978: else
! 979: toPtr = (XML_Char *)tag->buf;
! 980: tag->name = toPtr;
! 981: XmlConvert(enc,
! 982: &fromPtr, rawNameEnd,
! 983: (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);
! 984: if (fromPtr == rawNameEnd)
! 985: break;
! 986: bufSize = (tag->bufEnd - tag->buf) << 1;
! 987: tag->buf = realloc(tag->buf, bufSize);
! 988: if (!tag->buf)
! 989: return XML_ERROR_NO_MEMORY;
! 990: tag->bufEnd = tag->buf + bufSize;
! 991: if (nextPtr)
! 992: tag->rawName = tag->buf;
! 993: }
! 994: *toPtr = XML_T('\0');
! 995: result = storeAtts(parser, enc, tag->name, s);
! 996: if (result)
! 997: return result;
! 998: startElementHandler(handlerArg, tag->name, (const XML_Char **)atts);
! 999: poolClear(&tempPool);
! 1000: }
! 1001: else {
! 1002: tag->name = 0;
! 1003: if (defaultHandler)
! 1004: reportDefault(parser, enc, s, next);
! 1005: }
! 1006: break;
! 1007: }
! 1008: case XML_TOK_EMPTY_ELEMENT_WITH_ATTS:
! 1009: if (!startElementHandler) {
! 1010: enum XML_Error result = storeAtts(parser, enc, 0, s);
! 1011: if (result)
! 1012: return result;
! 1013: }
! 1014: /* fall through */
! 1015: case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
! 1016: if (startElementHandler || endElementHandler) {
! 1017: const char *rawName = s + enc->minBytesPerChar;
! 1018: const XML_Char *name = poolStoreString(&tempPool, enc, rawName,
! 1019: rawName
! 1020: + XmlNameLength(enc, rawName));
! 1021: if (!name)
! 1022: return XML_ERROR_NO_MEMORY;
! 1023: poolFinish(&tempPool);
! 1024: if (startElementHandler) {
! 1025: enum XML_Error result = storeAtts(parser, enc, name, s);
! 1026: if (result)
! 1027: return result;
! 1028: startElementHandler(handlerArg, name, (const XML_Char **)atts);
! 1029: }
! 1030: if (endElementHandler) {
! 1031: if (startElementHandler)
! 1032: *eventPP = *eventEndPP;
! 1033: endElementHandler(handlerArg, name);
! 1034: }
! 1035: poolClear(&tempPool);
! 1036: }
! 1037: else if (defaultHandler)
! 1038: reportDefault(parser, enc, s, next);
! 1039: if (tagLevel == 0)
! 1040: return epilogProcessor(parser, next, end, nextPtr);
! 1041: break;
! 1042: case XML_TOK_END_TAG:
! 1043: if (tagLevel == startTagLevel)
! 1044: return XML_ERROR_ASYNC_ENTITY;
! 1045: else {
! 1046: int len;
! 1047: const char *rawName;
! 1048: TAG *tag = tagStack;
! 1049: tagStack = tag->parent;
! 1050: tag->parent = freeTagList;
! 1051: freeTagList = tag;
! 1052: rawName = s + enc->minBytesPerChar*2;
! 1053: len = XmlNameLength(enc, rawName);
! 1054: if (len != tag->rawNameLength
! 1055: || memcmp(tag->rawName, rawName, len) != 0) {
! 1056: *eventPP = rawName;
! 1057: return XML_ERROR_TAG_MISMATCH;
! 1058: }
! 1059: --tagLevel;
! 1060: if (endElementHandler) {
! 1061: if (tag->name)
! 1062: endElementHandler(handlerArg, tag->name);
! 1063: else {
! 1064: const XML_Char *name = poolStoreString(&tempPool, enc, rawName,
! 1065: rawName + len);
! 1066: if (!name)
! 1067: return XML_ERROR_NO_MEMORY;
! 1068: endElementHandler(handlerArg, name);
! 1069: poolClear(&tempPool);
! 1070: }
! 1071: }
! 1072: else if (defaultHandler)
! 1073: reportDefault(parser, enc, s, next);
! 1074: if (tagLevel == 0)
! 1075: return epilogProcessor(parser, next, end, nextPtr);
! 1076: }
! 1077: break;
! 1078: case XML_TOK_CHAR_REF:
! 1079: {
! 1080: int n = XmlCharRefNumber(enc, s);
! 1081: if (n < 0)
! 1082: return XML_ERROR_BAD_CHAR_REF;
! 1083: if (characterDataHandler) {
! 1084: XML_Char buf[XML_ENCODE_MAX];
! 1085: characterDataHandler(handlerArg, buf, XmlEncode(n, (ICHAR *)buf));
! 1086: }
! 1087: else if (defaultHandler)
! 1088: reportDefault(parser, enc, s, next);
! 1089: }
! 1090: break;
! 1091: case XML_TOK_XML_DECL:
! 1092: return XML_ERROR_MISPLACED_XML_PI;
! 1093: case XML_TOK_DATA_NEWLINE:
! 1094: if (characterDataHandler) {
! 1095: XML_Char c = XML_T('\n');
! 1096: characterDataHandler(handlerArg, &c, 1);
! 1097: }
! 1098: else if (defaultHandler)
! 1099: reportDefault(parser, enc, s, next);
! 1100: break;
! 1101: case XML_TOK_CDATA_SECT_OPEN:
! 1102: {
! 1103: enum XML_Error result;
! 1104: if (characterDataHandler)
! 1105: characterDataHandler(handlerArg, dataBuf, 0);
! 1106: else if (defaultHandler)
! 1107: reportDefault(parser, enc, s, next);
! 1108: result = doCdataSection(parser, enc, &next, end, nextPtr);
! 1109: if (!next) {
! 1110: processor = cdataSectionProcessor;
! 1111: return result;
! 1112: }
! 1113: }
! 1114: break;
! 1115: case XML_TOK_TRAILING_RSQB:
! 1116: if (nextPtr) {
! 1117: *nextPtr = s;
! 1118: return XML_ERROR_NONE;
! 1119: }
! 1120: if (characterDataHandler) {
! 1121: if (MUST_CONVERT(enc, s)) {
! 1122: ICHAR *dataPtr = (ICHAR *)dataBuf;
! 1123: XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
! 1124: characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
! 1125: }
! 1126: else
! 1127: characterDataHandler(handlerArg,
! 1128: (XML_Char *)s,
! 1129: (XML_Char *)end - (XML_Char *)s);
! 1130: }
! 1131: else if (defaultHandler)
! 1132: reportDefault(parser, enc, s, end);
! 1133: if (startTagLevel == 0) {
! 1134: *eventPP = end;
! 1135: return XML_ERROR_NO_ELEMENTS;
! 1136: }
! 1137: if (tagLevel != startTagLevel) {
! 1138: *eventPP = end;
! 1139: return XML_ERROR_ASYNC_ENTITY;
! 1140: }
! 1141: return XML_ERROR_NONE;
! 1142: case XML_TOK_DATA_CHARS:
! 1143: if (characterDataHandler) {
! 1144: if (MUST_CONVERT(enc, s)) {
! 1145: for (;;) {
! 1146: ICHAR *dataPtr = (ICHAR *)dataBuf;
! 1147: XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
! 1148: *eventEndPP = s;
! 1149: characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
! 1150: if (s == next)
! 1151: break;
! 1152: *eventPP = s;
! 1153: }
! 1154: }
! 1155: else
! 1156: characterDataHandler(handlerArg,
! 1157: (XML_Char *)s,
! 1158: (XML_Char *)next - (XML_Char *)s);
! 1159: }
! 1160: else if (defaultHandler)
! 1161: reportDefault(parser, enc, s, next);
! 1162: break;
! 1163: case XML_TOK_PI:
! 1164: if (!reportProcessingInstruction(parser, enc, s, next))
! 1165: return XML_ERROR_NO_MEMORY;
! 1166: break;
! 1167: default:
! 1168: if (defaultHandler)
! 1169: reportDefault(parser, enc, s, next);
! 1170: break;
! 1171: }
! 1172: *eventPP = s = next;
! 1173: }
! 1174: /* not reached */
! 1175: }
! 1176:
! 1177: /* If tagName is non-null, build a real list of attributes,
! 1178: otherwise just check the attributes for well-formedness. */
! 1179:
! 1180: static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *enc,
! 1181: const XML_Char *tagName, const char *s)
! 1182: {
! 1183: ELEMENT_TYPE *elementType = 0;
! 1184: int nDefaultAtts = 0;
! 1185: const XML_Char **appAtts;
! 1186: int i;
! 1187: int n;
! 1188:
! 1189: if (tagName) {
! 1190: elementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, tagName, 0);
! 1191: if (elementType)
! 1192: nDefaultAtts = elementType->nDefaultAtts;
! 1193: }
! 1194:
! 1195: n = XmlGetAttributes(enc, s, attsSize, atts);
! 1196: if (n + nDefaultAtts > attsSize) {
! 1197: int oldAttsSize = attsSize;
! 1198: attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
! 1199: atts = realloc((void *)atts, attsSize * sizeof(ATTRIBUTE));
! 1200: if (!atts)
! 1201: return XML_ERROR_NO_MEMORY;
! 1202: if (n > oldAttsSize)
! 1203: XmlGetAttributes(enc, s, n, atts);
! 1204: }
! 1205: appAtts = (const XML_Char **)atts;
! 1206: for (i = 0; i < n; i++) {
! 1207: ATTRIBUTE_ID *attId = getAttributeId(parser, enc, atts[i].name,
! 1208: atts[i].name
! 1209: + XmlNameLength(enc, atts[i].name));
! 1210: if (!attId)
! 1211: return XML_ERROR_NO_MEMORY;
! 1212: if ((attId->name)[-1]) {
! 1213: if (enc == encoding)
! 1214: eventPtr = atts[i].name;
! 1215: return XML_ERROR_DUPLICATE_ATTRIBUTE;
! 1216: }
! 1217: (attId->name)[-1] = 1;
! 1218: appAtts[i << 1] = attId->name;
! 1219: if (!atts[i].normalized) {
! 1220: enum XML_Error result;
! 1221: int isCdata = 1;
! 1222:
! 1223: if (attId->maybeTokenized) {
! 1224: int j;
! 1225: for (j = 0; j < nDefaultAtts; j++) {
! 1226: if (attId == elementType->defaultAtts[j].id) {
! 1227: isCdata = elementType->defaultAtts[j].isCdata;
! 1228: break;
! 1229: }
! 1230: }
! 1231: }
! 1232:
! 1233: result = storeAttributeValue(parser, enc, isCdata,
! 1234: atts[i].valuePtr, atts[i].valueEnd,
! 1235: &tempPool);
! 1236: if (result)
! 1237: return result;
! 1238: if (tagName) {
! 1239: appAtts[(i << 1) + 1] = poolStart(&tempPool);
! 1240: poolFinish(&tempPool);
! 1241: }
! 1242: else
! 1243: poolDiscard(&tempPool);
! 1244: }
! 1245: else if (tagName) {
! 1246: appAtts[(i << 1) + 1] = poolStoreString(&tempPool, enc, atts[i].valuePtr, atts[i].valueEnd);
! 1247: if (appAtts[(i << 1) + 1] == 0)
! 1248: return XML_ERROR_NO_MEMORY;
! 1249: poolFinish(&tempPool);
! 1250: }
! 1251: }
! 1252: if (tagName) {
! 1253: int j;
! 1254: for (j = 0; j < nDefaultAtts; j++) {
! 1255: const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + j;
! 1256: if (!(da->id->name)[-1] && da->value) {
! 1257: (da->id->name)[-1] = 1;
! 1258: appAtts[i << 1] = da->id->name;
! 1259: appAtts[(i << 1) + 1] = da->value;
! 1260: i++;
! 1261: }
! 1262: }
! 1263: appAtts[i << 1] = 0;
! 1264: }
! 1265: while (i-- > 0)
! 1266: ((XML_Char *)appAtts[i << 1])[-1] = 0;
! 1267: return XML_ERROR_NONE;
! 1268: }
! 1269:
! 1270: /* The idea here is to avoid using stack for each CDATA section when
! 1271: the whole file is parsed with one call. */
! 1272:
! 1273: static
! 1274: enum XML_Error cdataSectionProcessor(XML_Parser parser,
! 1275: const char *start,
! 1276: const char *end,
! 1277: const char **endPtr)
! 1278: {
! 1279: enum XML_Error result = doCdataSection(parser, encoding, &start, end, endPtr);
! 1280: if (start) {
! 1281: processor = contentProcessor;
! 1282: return contentProcessor(parser, start, end, endPtr);
! 1283: }
! 1284: return result;
! 1285: }
! 1286:
! 1287: /* startPtr gets set to non-null is the section is closed, and to null if
! 1288: the section is not yet closed. */
! 1289:
! 1290: static
! 1291: enum XML_Error doCdataSection(XML_Parser parser,
! 1292: const ENCODING *enc,
! 1293: const char **startPtr,
! 1294: const char *end,
! 1295: const char **nextPtr)
! 1296: {
! 1297: const char *s = *startPtr;
! 1298: const char *dummy;
! 1299: const char **eventPP;
! 1300: const char **eventEndPP;
! 1301: if (enc == encoding) {
! 1302: eventPP = &eventPtr;
! 1303: *eventPP = s;
! 1304: eventEndPP = &eventEndPtr;
! 1305: }
! 1306: else
! 1307: eventPP = eventEndPP = &dummy;
! 1308: *startPtr = 0;
! 1309: for (;;) {
! 1310: const char *next;
! 1311: int tok = XmlCdataSectionTok(enc, s, end, &next);
! 1312: *eventEndPP = next;
! 1313: switch (tok) {
! 1314: case XML_TOK_CDATA_SECT_CLOSE:
! 1315: if (characterDataHandler)
! 1316: characterDataHandler(handlerArg, dataBuf, 0);
! 1317: else if (defaultHandler)
! 1318: reportDefault(parser, enc, s, next);
! 1319: *startPtr = next;
! 1320: return XML_ERROR_NONE;
! 1321: case XML_TOK_DATA_NEWLINE:
! 1322: if (characterDataHandler) {
! 1323: XML_Char c = XML_T('\n');
! 1324: characterDataHandler(handlerArg, &c, 1);
! 1325: }
! 1326: else if (defaultHandler)
! 1327: reportDefault(parser, enc, s, next);
! 1328: break;
! 1329: case XML_TOK_DATA_CHARS:
! 1330: if (characterDataHandler) {
! 1331: if (MUST_CONVERT(enc, s)) {
! 1332: for (;;) {
! 1333: ICHAR *dataPtr = (ICHAR *)dataBuf;
! 1334: XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
! 1335: *eventEndPP = next;
! 1336: characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
! 1337: if (s == next)
! 1338: break;
! 1339: *eventPP = s;
! 1340: }
! 1341: }
! 1342: else
! 1343: characterDataHandler(handlerArg,
! 1344: (XML_Char *)s,
! 1345: (XML_Char *)next - (XML_Char *)s);
! 1346: }
! 1347: else if (defaultHandler)
! 1348: reportDefault(parser, enc, s, next);
! 1349: break;
! 1350: case XML_TOK_INVALID:
! 1351: *eventPP = next;
! 1352: return XML_ERROR_INVALID_TOKEN;
! 1353: case XML_TOK_PARTIAL_CHAR:
! 1354: if (nextPtr) {
! 1355: *nextPtr = s;
! 1356: return XML_ERROR_NONE;
! 1357: }
! 1358: return XML_ERROR_PARTIAL_CHAR;
! 1359: case XML_TOK_PARTIAL:
! 1360: case XML_TOK_NONE:
! 1361: if (nextPtr) {
! 1362: *nextPtr = s;
! 1363: return XML_ERROR_NONE;
! 1364: }
! 1365: return XML_ERROR_UNCLOSED_CDATA_SECTION;
! 1366: default:
! 1367: abort();
! 1368: }
! 1369: *eventPP = s = next;
! 1370: }
! 1371: /* not reached */
! 1372: }
! 1373:
! 1374: static enum XML_Error
! 1375: initializeEncoding(XML_Parser parser)
! 1376: {
! 1377: const char *s;
! 1378: #ifdef XML_UNICODE
! 1379: char encodingBuf[128];
! 1380: if (!protocolEncodingName)
! 1381: s = 0;
! 1382: else {
! 1383: int i;
! 1384: for (i = 0; protocolEncodingName[i]; i++) {
! 1385: if (i == sizeof(encodingBuf) - 1
! 1386: || protocolEncodingName[i] >= 0x80
! 1387: || protocolEncodingName[i] < 0) {
! 1388: encodingBuf[0] = '\0';
! 1389: break;
! 1390: }
! 1391: encodingBuf[i] = (char)protocolEncodingName[i];
! 1392: }
! 1393: encodingBuf[i] = '\0';
! 1394: s = encodingBuf;
! 1395: }
! 1396: #else
! 1397: s = protocolEncodingName;
! 1398: #endif
! 1399: if (XmlInitEncoding(&initEncoding, &encoding, s))
! 1400: return XML_ERROR_NONE;
! 1401: return handleUnknownEncoding(parser, protocolEncodingName);
! 1402: }
! 1403:
! 1404: static enum XML_Error
! 1405: processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
! 1406: const char *s, const char *next)
! 1407: {
! 1408: const char *encodingName = 0;
! 1409: const ENCODING *newEncoding = 0;
! 1410: const char *version;
! 1411: int standalone = -1;
! 1412: if (!XmlParseXmlDecl(isGeneralTextEntity,
! 1413: encoding,
! 1414: s,
! 1415: next,
! 1416: &eventPtr,
! 1417: &version,
! 1418: &encodingName,
! 1419: &newEncoding,
! 1420: &standalone))
! 1421: return XML_ERROR_SYNTAX;
! 1422: if (!isGeneralTextEntity && standalone == 1)
! 1423: dtd.standalone = 1;
! 1424: if (defaultHandler)
! 1425: reportDefault(parser, encoding, s, next);
! 1426: if (!protocolEncodingName) {
! 1427: if (newEncoding) {
! 1428: if (newEncoding->minBytesPerChar != encoding->minBytesPerChar) {
! 1429: eventPtr = encodingName;
! 1430: return XML_ERROR_INCORRECT_ENCODING;
! 1431: }
! 1432: encoding = newEncoding;
! 1433: }
! 1434: else if (encodingName) {
! 1435: enum XML_Error result;
! 1436: const XML_Char *s = poolStoreString(&tempPool,
! 1437: encoding,
! 1438: encodingName,
! 1439: encodingName
! 1440: + XmlNameLength(encoding, encodingName));
! 1441: if (!s)
! 1442: return XML_ERROR_NO_MEMORY;
! 1443: result = handleUnknownEncoding(parser, s);
! 1444: poolDiscard(&tempPool);
! 1445: if (result == XML_ERROR_UNKNOWN_ENCODING)
! 1446: eventPtr = encodingName;
! 1447: return result;
! 1448: }
! 1449: }
! 1450: return XML_ERROR_NONE;
! 1451: }
! 1452:
! 1453: static enum XML_Error
! 1454: handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName)
! 1455: {
! 1456: if (unknownEncodingHandler) {
! 1457: XML_Encoding info;
! 1458: int i;
! 1459: for (i = 0; i < 256; i++)
! 1460: info.map[i] = -1;
! 1461: info.convert = 0;
! 1462: info.data = 0;
! 1463: info.release = 0;
! 1464: if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName, &info)) {
! 1465: ENCODING *enc;
! 1466: unknownEncodingMem = malloc(XmlSizeOfUnknownEncoding());
! 1467: if (!unknownEncodingMem) {
! 1468: if (info.release)
! 1469: info.release(info.data);
! 1470: return XML_ERROR_NO_MEMORY;
! 1471: }
! 1472: enc = XmlInitUnknownEncoding(unknownEncodingMem,
! 1473: info.map,
! 1474: info.convert,
! 1475: info.data);
! 1476: if (enc) {
! 1477: unknownEncodingData = info.data;
! 1478: unknownEncodingRelease = info.release;
! 1479: encoding = enc;
! 1480: return XML_ERROR_NONE;
! 1481: }
! 1482: }
! 1483: if (info.release)
! 1484: info.release(info.data);
! 1485: }
! 1486: return XML_ERROR_UNKNOWN_ENCODING;
! 1487: }
! 1488:
! 1489: static enum XML_Error
! 1490: prologInitProcessor(XML_Parser parser,
! 1491: const char *s,
! 1492: const char *end,
! 1493: const char **nextPtr)
! 1494: {
! 1495: enum XML_Error result = initializeEncoding(parser);
! 1496: if (result != XML_ERROR_NONE)
! 1497: return result;
! 1498: processor = prologProcessor;
! 1499: return prologProcessor(parser, s, end, nextPtr);
! 1500: }
! 1501:
! 1502: static enum XML_Error
! 1503: prologProcessor(XML_Parser parser,
! 1504: const char *s,
! 1505: const char *end,
! 1506: const char **nextPtr)
! 1507: {
! 1508: for (;;) {
! 1509: const char *next;
! 1510: int tok = XmlPrologTok(encoding, s, end, &next);
! 1511: if (tok <= 0) {
! 1512: if (nextPtr != 0 && tok != XML_TOK_INVALID) {
! 1513: *nextPtr = s;
! 1514: return XML_ERROR_NONE;
! 1515: }
! 1516: switch (tok) {
! 1517: case XML_TOK_INVALID:
! 1518: eventPtr = next;
! 1519: return XML_ERROR_INVALID_TOKEN;
! 1520: case XML_TOK_NONE:
! 1521: return XML_ERROR_NO_ELEMENTS;
! 1522: case XML_TOK_PARTIAL:
! 1523: return XML_ERROR_UNCLOSED_TOKEN;
! 1524: case XML_TOK_PARTIAL_CHAR:
! 1525: return XML_ERROR_PARTIAL_CHAR;
! 1526: case XML_TOK_TRAILING_CR:
! 1527: eventPtr = s + encoding->minBytesPerChar;
! 1528: return XML_ERROR_NO_ELEMENTS;
! 1529: default:
! 1530: abort();
! 1531: }
! 1532: }
! 1533: switch (XmlTokenRole(&prologState, tok, s, next, encoding)) {
! 1534: case XML_ROLE_XML_DECL:
! 1535: {
! 1536: enum XML_Error result = processXmlDecl(parser, 0, s, next);
! 1537: if (result != XML_ERROR_NONE)
! 1538: return result;
! 1539: }
! 1540: break;
! 1541: case XML_ROLE_DOCTYPE_SYSTEM_ID:
! 1542: hadExternalDoctype = 1;
! 1543: break;
! 1544: case XML_ROLE_DOCTYPE_PUBLIC_ID:
! 1545: case XML_ROLE_ENTITY_PUBLIC_ID:
! 1546: if (!XmlIsPublicId(encoding, s, next, &eventPtr))
! 1547: return XML_ERROR_SYNTAX;
! 1548: if (declEntity) {
! 1549: XML_Char *tem = poolStoreString(&dtd.pool,
! 1550: encoding,
! 1551: s + encoding->minBytesPerChar,
! 1552: next - encoding->minBytesPerChar);
! 1553: if (!tem)
! 1554: return XML_ERROR_NO_MEMORY;
! 1555: normalizePublicId(tem);
! 1556: declEntity->publicId = tem;
! 1557: poolFinish(&dtd.pool);
! 1558: }
! 1559: break;
! 1560: case XML_ROLE_INSTANCE_START:
! 1561: processor = contentProcessor;
! 1562: if (hadExternalDoctype)
! 1563: dtd.complete = 0;
! 1564: return contentProcessor(parser, s, end, nextPtr);
! 1565: case XML_ROLE_ATTLIST_ELEMENT_NAME:
! 1566: {
! 1567: const XML_Char *name = poolStoreString(&dtd.pool, encoding, s, next);
! 1568: if (!name)
! 1569: return XML_ERROR_NO_MEMORY;
! 1570: declElementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, name, sizeof(ELEMENT_TYPE));
! 1571: if (!declElementType)
! 1572: return XML_ERROR_NO_MEMORY;
! 1573: if (declElementType->name != name)
! 1574: poolDiscard(&dtd.pool);
! 1575: else
! 1576: poolFinish(&dtd.pool);
! 1577: break;
! 1578: }
! 1579: case XML_ROLE_ATTRIBUTE_NAME:
! 1580: declAttributeId = getAttributeId(parser, encoding, s, next);
! 1581: if (!declAttributeId)
! 1582: return XML_ERROR_NO_MEMORY;
! 1583: declAttributeIsCdata = 0;
! 1584: break;
! 1585: case XML_ROLE_ATTRIBUTE_TYPE_CDATA:
! 1586: declAttributeIsCdata = 1;
! 1587: break;
! 1588: case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:
! 1589: case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:
! 1590: if (dtd.complete
! 1591: && !defineAttribute(declElementType, declAttributeId, declAttributeIsCdata, 0))
! 1592: return XML_ERROR_NO_MEMORY;
! 1593: break;
! 1594: case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
! 1595: case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
! 1596: {
! 1597: const XML_Char *attVal;
! 1598: enum XML_Error result
! 1599: = storeAttributeValue(parser, encoding, declAttributeIsCdata,
! 1600: s + encoding->minBytesPerChar,
! 1601: next - encoding->minBytesPerChar,
! 1602: &dtd.pool);
! 1603: if (result)
! 1604: return result;
! 1605: attVal = poolStart(&dtd.pool);
! 1606: poolFinish(&dtd.pool);
! 1607: if (dtd.complete
! 1608: && !defineAttribute(declElementType, declAttributeId, declAttributeIsCdata, attVal))
! 1609: return XML_ERROR_NO_MEMORY;
! 1610: break;
! 1611: }
! 1612: case XML_ROLE_ENTITY_VALUE:
! 1613: {
! 1614: enum XML_Error result = storeEntityValue(parser, s, next);
! 1615: if (result != XML_ERROR_NONE)
! 1616: return result;
! 1617: }
! 1618: break;
! 1619: case XML_ROLE_ENTITY_SYSTEM_ID:
! 1620: if (declEntity) {
! 1621: declEntity->systemId = poolStoreString(&dtd.pool, encoding,
! 1622: s + encoding->minBytesPerChar,
! 1623: next - encoding->minBytesPerChar);
! 1624: if (!declEntity->systemId)
! 1625: return XML_ERROR_NO_MEMORY;
! 1626: declEntity->base = dtd.base;
! 1627: poolFinish(&dtd.pool);
! 1628: }
! 1629: break;
! 1630: case XML_ROLE_ENTITY_NOTATION_NAME:
! 1631: if (declEntity) {
! 1632: declEntity->notation = poolStoreString(&dtd.pool, encoding, s, next);
! 1633: if (!declEntity->notation)
! 1634: return XML_ERROR_NO_MEMORY;
! 1635: poolFinish(&dtd.pool);
! 1636: if (unparsedEntityDeclHandler) {
! 1637: eventPtr = eventEndPtr = s;
! 1638: unparsedEntityDeclHandler(handlerArg,
! 1639: declEntity->name,
! 1640: declEntity->base,
! 1641: declEntity->systemId,
! 1642: declEntity->publicId,
! 1643: declEntity->notation);
! 1644: }
! 1645:
! 1646: }
! 1647: break;
! 1648: case XML_ROLE_GENERAL_ENTITY_NAME:
! 1649: {
! 1650: const XML_Char *name;
! 1651: if (XmlPredefinedEntityName(encoding, s, next)) {
! 1652: declEntity = 0;
! 1653: break;
! 1654: }
! 1655: name = poolStoreString(&dtd.pool, encoding, s, next);
! 1656: if (!name)
! 1657: return XML_ERROR_NO_MEMORY;
! 1658: if (dtd.complete) {
! 1659: declEntity = (ENTITY *)lookup(&dtd.generalEntities, name, sizeof(ENTITY));
! 1660: if (!declEntity)
! 1661: return XML_ERROR_NO_MEMORY;
! 1662: if (declEntity->name != name) {
! 1663: poolDiscard(&dtd.pool);
! 1664: declEntity = 0;
! 1665: }
! 1666: else
! 1667: poolFinish(&dtd.pool);
! 1668: }
! 1669: else {
! 1670: poolDiscard(&dtd.pool);
! 1671: declEntity = 0;
! 1672: }
! 1673: }
! 1674: break;
! 1675: case XML_ROLE_PARAM_ENTITY_NAME:
! 1676: declEntity = 0;
! 1677: break;
! 1678: case XML_ROLE_NOTATION_NAME:
! 1679: declNotationPublicId = 0;
! 1680: declNotationName = 0;
! 1681: if (notationDeclHandler) {
! 1682: declNotationName = poolStoreString(&tempPool, encoding, s, next);
! 1683: if (!declNotationName)
! 1684: return XML_ERROR_NO_MEMORY;
! 1685: poolFinish(&tempPool);
! 1686: }
! 1687: break;
! 1688: case XML_ROLE_NOTATION_PUBLIC_ID:
! 1689: if (!XmlIsPublicId(encoding, s, next, &eventPtr))
! 1690: return XML_ERROR_SYNTAX;
! 1691: if (declNotationName) {
! 1692: XML_Char *tem = poolStoreString(&tempPool,
! 1693: encoding,
! 1694: s + encoding->minBytesPerChar,
! 1695: next - encoding->minBytesPerChar);
! 1696: if (!tem)
! 1697: return XML_ERROR_NO_MEMORY;
! 1698: normalizePublicId(tem);
! 1699: declNotationPublicId = tem;
! 1700: poolFinish(&tempPool);
! 1701: }
! 1702: break;
! 1703: case XML_ROLE_NOTATION_SYSTEM_ID:
! 1704: if (declNotationName && notationDeclHandler) {
! 1705: const XML_Char *systemId
! 1706: = poolStoreString(&tempPool, encoding,
! 1707: s + encoding->minBytesPerChar,
! 1708: next - encoding->minBytesPerChar);
! 1709: if (!systemId)
! 1710: return XML_ERROR_NO_MEMORY;
! 1711: eventPtr = eventEndPtr = s;
! 1712: notationDeclHandler(handlerArg,
! 1713: declNotationName,
! 1714: dtd.base,
! 1715: systemId,
! 1716: declNotationPublicId);
! 1717: }
! 1718: poolClear(&tempPool);
! 1719: break;
! 1720: case XML_ROLE_NOTATION_NO_SYSTEM_ID:
! 1721: if (declNotationPublicId && notationDeclHandler) {
! 1722: eventPtr = eventEndPtr = s;
! 1723: notationDeclHandler(handlerArg,
! 1724: declNotationName,
! 1725: dtd.base,
! 1726: 0,
! 1727: declNotationPublicId);
! 1728: }
! 1729: poolClear(&tempPool);
! 1730: break;
! 1731: case XML_ROLE_ERROR:
! 1732: eventPtr = s;
! 1733: switch (tok) {
! 1734: case XML_TOK_PARAM_ENTITY_REF:
! 1735: return XML_ERROR_PARAM_ENTITY_REF;
! 1736: case XML_TOK_XML_DECL:
! 1737: return XML_ERROR_MISPLACED_XML_PI;
! 1738: default:
! 1739: return XML_ERROR_SYNTAX;
! 1740: }
! 1741: case XML_ROLE_GROUP_OPEN:
! 1742: if (prologState.level >= groupSize) {
! 1743: if (groupSize)
! 1744: groupConnector = realloc(groupConnector, groupSize *= 2);
! 1745: else
! 1746: groupConnector = malloc(groupSize = 32);
! 1747: if (!groupConnector)
! 1748: return XML_ERROR_NO_MEMORY;
! 1749: }
! 1750: groupConnector[prologState.level] = 0;
! 1751: break;
! 1752: case XML_ROLE_GROUP_SEQUENCE:
! 1753: if (groupConnector[prologState.level] == '|') {
! 1754: eventPtr = s;
! 1755: return XML_ERROR_SYNTAX;
! 1756: }
! 1757: groupConnector[prologState.level] = ',';
! 1758: break;
! 1759: case XML_ROLE_GROUP_CHOICE:
! 1760: if (groupConnector[prologState.level] == ',') {
! 1761: eventPtr = s;
! 1762: return XML_ERROR_SYNTAX;
! 1763: }
! 1764: groupConnector[prologState.level] = '|';
! 1765: break;
! 1766: case XML_ROLE_PARAM_ENTITY_REF:
! 1767: dtd.complete = 0;
! 1768: break;
! 1769: case XML_ROLE_NONE:
! 1770: switch (tok) {
! 1771: case XML_TOK_PI:
! 1772: eventPtr = s;
! 1773: eventEndPtr = next;
! 1774: if (!reportProcessingInstruction(parser, encoding, s, next))
! 1775: return XML_ERROR_NO_MEMORY;
! 1776: break;
! 1777: }
! 1778: break;
! 1779: }
! 1780: if (defaultHandler) {
! 1781: switch (tok) {
! 1782: case XML_TOK_PI:
! 1783: case XML_TOK_BOM:
! 1784: case XML_TOK_XML_DECL:
! 1785: break;
! 1786: default:
! 1787: eventPtr = s;
! 1788: eventEndPtr = next;
! 1789: reportDefault(parser, encoding, s, next);
! 1790: }
! 1791: }
! 1792: s = next;
! 1793: }
! 1794: /* not reached */
! 1795: }
! 1796:
! 1797: static
! 1798: enum XML_Error epilogProcessor(XML_Parser parser,
! 1799: const char *s,
! 1800: const char *end,
! 1801: const char **nextPtr)
! 1802: {
! 1803: processor = epilogProcessor;
! 1804: eventPtr = s;
! 1805: for (;;) {
! 1806: const char *next;
! 1807: int tok = XmlPrologTok(encoding, s, end, &next);
! 1808: eventEndPtr = next;
! 1809: switch (tok) {
! 1810: case XML_TOK_TRAILING_CR:
! 1811: if (defaultHandler) {
! 1812: eventEndPtr = end;
! 1813: reportDefault(parser, encoding, s, end);
! 1814: }
! 1815: /* fall through */
! 1816: case XML_TOK_NONE:
! 1817: if (nextPtr)
! 1818: *nextPtr = end;
! 1819: return XML_ERROR_NONE;
! 1820: case XML_TOK_PROLOG_S:
! 1821: case XML_TOK_COMMENT:
! 1822: if (defaultHandler)
! 1823: reportDefault(parser, encoding, s, next);
! 1824: break;
! 1825: case XML_TOK_PI:
! 1826: if (!reportProcessingInstruction(parser, encoding, s, next))
! 1827: return XML_ERROR_NO_MEMORY;
! 1828: break;
! 1829: case XML_TOK_INVALID:
! 1830: eventPtr = next;
! 1831: return XML_ERROR_INVALID_TOKEN;
! 1832: case XML_TOK_PARTIAL:
! 1833: if (nextPtr) {
! 1834: *nextPtr = s;
! 1835: return XML_ERROR_NONE;
! 1836: }
! 1837: return XML_ERROR_UNCLOSED_TOKEN;
! 1838: case XML_TOK_PARTIAL_CHAR:
! 1839: if (nextPtr) {
! 1840: *nextPtr = s;
! 1841: return XML_ERROR_NONE;
! 1842: }
! 1843: return XML_ERROR_PARTIAL_CHAR;
! 1844: default:
! 1845: return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
! 1846: }
! 1847: eventPtr = s = next;
! 1848: }
! 1849: }
! 1850:
! 1851: static
! 1852: enum XML_Error errorProcessor(XML_Parser parser,
! 1853: const char *s,
! 1854: const char *end,
! 1855: const char **nextPtr)
! 1856: {
! 1857: return errorCode;
! 1858: }
! 1859:
! 1860: static enum XML_Error
! 1861: storeAttributeValue(XML_Parser parser, const ENCODING *enc, int isCdata,
! 1862: const char *ptr, const char *end,
! 1863: STRING_POOL *pool)
! 1864: {
! 1865: enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr, end, pool);
! 1866: if (result)
! 1867: return result;
! 1868: if (!isCdata && poolLength(pool) && poolLastChar(pool) == XML_T(' '))
! 1869: poolChop(pool);
! 1870: if (!poolAppendChar(pool, XML_T('\0')))
! 1871: return XML_ERROR_NO_MEMORY;
! 1872: return XML_ERROR_NONE;
! 1873: }
! 1874:
! 1875: static enum XML_Error
! 1876: appendAttributeValue(XML_Parser parser, const ENCODING *enc, int isCdata,
! 1877: const char *ptr, const char *end,
! 1878: STRING_POOL *pool)
! 1879: {
! 1880: const ENCODING *internalEnc = XmlGetInternalEncoding();
! 1881: for (;;) {
! 1882: const char *next;
! 1883: int tok = XmlAttributeValueTok(enc, ptr, end, &next);
! 1884: switch (tok) {
! 1885: case XML_TOK_NONE:
! 1886: return XML_ERROR_NONE;
! 1887: case XML_TOK_INVALID:
! 1888: if (enc == encoding)
! 1889: eventPtr = next;
! 1890: return XML_ERROR_INVALID_TOKEN;
! 1891: case XML_TOK_PARTIAL:
! 1892: if (enc == encoding)
! 1893: eventPtr = ptr;
! 1894: return XML_ERROR_INVALID_TOKEN;
! 1895: case XML_TOK_CHAR_REF:
! 1896: {
! 1897: XML_Char buf[XML_ENCODE_MAX];
! 1898: int i;
! 1899: int n = XmlCharRefNumber(enc, ptr);
! 1900: if (n < 0) {
! 1901: if (enc == encoding)
! 1902: eventPtr = ptr;
! 1903: return XML_ERROR_BAD_CHAR_REF;
! 1904: }
! 1905: if (!isCdata
! 1906: && n == 0x20 /* space */
! 1907: && (poolLength(pool) == 0 || poolLastChar(pool) == XML_T(' ')))
! 1908: break;
! 1909: n = XmlEncode(n, (ICHAR *)buf);
! 1910: if (!n) {
! 1911: if (enc == encoding)
! 1912: eventPtr = ptr;
! 1913: return XML_ERROR_BAD_CHAR_REF;
! 1914: }
! 1915: for (i = 0; i < n; i++) {
! 1916: if (!poolAppendChar(pool, buf[i]))
! 1917: return XML_ERROR_NO_MEMORY;
! 1918: }
! 1919: }
! 1920: break;
! 1921: case XML_TOK_DATA_CHARS:
! 1922: if (!poolAppend(pool, enc, ptr, next))
! 1923: return XML_ERROR_NO_MEMORY;
! 1924: break;
! 1925: break;
! 1926: case XML_TOK_TRAILING_CR:
! 1927: next = ptr + enc->minBytesPerChar;
! 1928: /* fall through */
! 1929: case XML_TOK_ATTRIBUTE_VALUE_S:
! 1930: case XML_TOK_DATA_NEWLINE:
! 1931: if (!isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == XML_T(' ')))
! 1932: break;
! 1933: if (!poolAppendChar(pool, XML_T(' ')))
! 1934: return XML_ERROR_NO_MEMORY;
! 1935: break;
! 1936: case XML_TOK_ENTITY_REF:
! 1937: {
! 1938: const XML_Char *name;
! 1939: ENTITY *entity;
! 1940: XML_Char ch = XmlPredefinedEntityName(enc,
! 1941: ptr + enc->minBytesPerChar,
! 1942: next - enc->minBytesPerChar);
! 1943: if (ch) {
! 1944: if (!poolAppendChar(pool, ch))
! 1945: return XML_ERROR_NO_MEMORY;
! 1946: break;
! 1947: }
! 1948: name = poolStoreString(&temp2Pool, enc,
! 1949: ptr + enc->minBytesPerChar,
! 1950: next - enc->minBytesPerChar);
! 1951: if (!name)
! 1952: return XML_ERROR_NO_MEMORY;
! 1953: entity = (ENTITY *)lookup(&dtd.generalEntities, name, 0);
! 1954: poolDiscard(&temp2Pool);
! 1955: if (!entity) {
! 1956: if (dtd.complete) {
! 1957: if (enc == encoding)
! 1958: eventPtr = ptr;
! 1959: return XML_ERROR_UNDEFINED_ENTITY;
! 1960: }
! 1961: }
! 1962: else if (entity->open) {
! 1963: if (enc == encoding)
! 1964: eventPtr = ptr;
! 1965: return XML_ERROR_RECURSIVE_ENTITY_REF;
! 1966: }
! 1967: else if (entity->notation) {
! 1968: if (enc == encoding)
! 1969: eventPtr = ptr;
! 1970: return XML_ERROR_BINARY_ENTITY_REF;
! 1971: }
! 1972: else if (!entity->textPtr) {
! 1973: if (enc == encoding)
! 1974: eventPtr = ptr;
! 1975: return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
! 1976: }
! 1977: else {
! 1978: enum XML_Error result;
! 1979: const XML_Char *textEnd = entity->textPtr + entity->textLen;
! 1980: entity->open = 1;
! 1981: result = appendAttributeValue(parser, internalEnc, isCdata, (char *)entity->textPtr, (char *)textEnd, pool);
! 1982: entity->open = 0;
! 1983: if (result)
! 1984: return result;
! 1985: }
! 1986: }
! 1987: break;
! 1988: default:
! 1989: abort();
! 1990: }
! 1991: ptr = next;
! 1992: }
! 1993: /* not reached */
! 1994: }
! 1995:
! 1996: static
! 1997: enum XML_Error storeEntityValue(XML_Parser parser,
! 1998: const char *entityTextPtr,
! 1999: const char *entityTextEnd)
! 2000: {
! 2001: const ENCODING *internalEnc = XmlGetInternalEncoding();
! 2002: STRING_POOL *pool = &(dtd.pool);
! 2003: entityTextPtr += encoding->minBytesPerChar;
! 2004: entityTextEnd -= encoding->minBytesPerChar;
! 2005: for (;;) {
! 2006: const char *next;
! 2007: int tok = XmlEntityValueTok(encoding, entityTextPtr, entityTextEnd, &next);
! 2008: switch (tok) {
! 2009: case XML_TOK_PARAM_ENTITY_REF:
! 2010: eventPtr = entityTextPtr;
! 2011: return XML_ERROR_SYNTAX;
! 2012: case XML_TOK_NONE:
! 2013: if (declEntity) {
! 2014: declEntity->textPtr = pool->start;
! 2015: declEntity->textLen = pool->ptr - pool->start;
! 2016: poolFinish(pool);
! 2017: }
! 2018: else
! 2019: poolDiscard(pool);
! 2020: return XML_ERROR_NONE;
! 2021: case XML_TOK_ENTITY_REF:
! 2022: case XML_TOK_DATA_CHARS:
! 2023: if (!poolAppend(pool, encoding, entityTextPtr, next))
! 2024: return XML_ERROR_NO_MEMORY;
! 2025: break;
! 2026: case XML_TOK_TRAILING_CR:
! 2027: next = entityTextPtr + encoding->minBytesPerChar;
! 2028: /* fall through */
! 2029: case XML_TOK_DATA_NEWLINE:
! 2030: if (pool->end == pool->ptr && !poolGrow(pool))
! 2031: return XML_ERROR_NO_MEMORY;
! 2032: *(pool->ptr)++ = XML_T('\n');
! 2033: break;
! 2034: case XML_TOK_CHAR_REF:
! 2035: {
! 2036: XML_Char buf[XML_ENCODE_MAX];
! 2037: int i;
! 2038: int n = XmlCharRefNumber(encoding, entityTextPtr);
! 2039: if (n < 0) {
! 2040: eventPtr = entityTextPtr;
! 2041: return XML_ERROR_BAD_CHAR_REF;
! 2042: }
! 2043: n = XmlEncode(n, (ICHAR *)buf);
! 2044: if (!n) {
! 2045: eventPtr = entityTextPtr;
! 2046: return XML_ERROR_BAD_CHAR_REF;
! 2047: }
! 2048: for (i = 0; i < n; i++) {
! 2049: if (pool->end == pool->ptr && !poolGrow(pool))
! 2050: return XML_ERROR_NO_MEMORY;
! 2051: *(pool->ptr)++ = buf[i];
! 2052: }
! 2053: }
! 2054: break;
! 2055: case XML_TOK_PARTIAL:
! 2056: eventPtr = entityTextPtr;
! 2057: return XML_ERROR_INVALID_TOKEN;
! 2058: case XML_TOK_INVALID:
! 2059: eventPtr = next;
! 2060: return XML_ERROR_INVALID_TOKEN;
! 2061: default:
! 2062: abort();
! 2063: }
! 2064: entityTextPtr = next;
! 2065: }
! 2066: /* not reached */
! 2067: }
! 2068:
! 2069: static void
! 2070: normalizeLines(XML_Char *s)
! 2071: {
! 2072: XML_Char *p;
! 2073: for (;; s++) {
! 2074: if (*s == XML_T('\0'))
! 2075: return;
! 2076: if (*s == XML_T('\r'))
! 2077: break;
! 2078: }
! 2079: p = s;
! 2080: do {
! 2081: if (*s == XML_T('\r')) {
! 2082: *p++ = XML_T('\n');
! 2083: if (*++s == XML_T('\n'))
! 2084: s++;
! 2085: }
! 2086: else
! 2087: *p++ = *s++;
! 2088: } while (*s);
! 2089: *p = XML_T('\0');
! 2090: }
! 2091:
! 2092: static int
! 2093: reportProcessingInstruction(XML_Parser parser, const ENCODING *enc, const char *start, const char *end)
! 2094: {
! 2095: const XML_Char *target;
! 2096: XML_Char *data;
! 2097: const char *tem;
! 2098: if (!processingInstructionHandler) {
! 2099: if (defaultHandler)
! 2100: reportDefault(parser, enc, start, end);
! 2101: return 1;
! 2102: }
! 2103: start += enc->minBytesPerChar * 2;
! 2104: tem = start + XmlNameLength(enc, start);
! 2105: target = poolStoreString(&tempPool, enc, start, tem);
! 2106: if (!target)
! 2107: return 0;
! 2108: poolFinish(&tempPool);
! 2109: data = poolStoreString(&tempPool, enc,
! 2110: XmlSkipS(enc, tem),
! 2111: end - enc->minBytesPerChar*2);
! 2112: if (!data)
! 2113: return 0;
! 2114: normalizeLines(data);
! 2115: processingInstructionHandler(handlerArg, target, data);
! 2116: poolClear(&tempPool);
! 2117: return 1;
! 2118: }
! 2119:
! 2120: static void
! 2121: reportDefault(XML_Parser parser, const ENCODING *enc, const char *s, const char *end)
! 2122: {
! 2123: if (MUST_CONVERT(enc, s)) {
! 2124: for (;;) {
! 2125: ICHAR *dataPtr = (ICHAR *)dataBuf;
! 2126: XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
! 2127: if (s == end) {
! 2128: defaultHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
! 2129: break;
! 2130: }
! 2131: if (enc == encoding) {
! 2132: eventEndPtr = s;
! 2133: defaultHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
! 2134: eventPtr = s;
! 2135: }
! 2136: else
! 2137: defaultHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
! 2138: }
! 2139: }
! 2140: else
! 2141: defaultHandler(handlerArg, (XML_Char *)s, (XML_Char *)end - (XML_Char *)s);
! 2142: }
! 2143:
! 2144:
! 2145: static int
! 2146: defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, int isCdata, const XML_Char *value)
! 2147: {
! 2148: DEFAULT_ATTRIBUTE *att;
! 2149: if (type->nDefaultAtts == type->allocDefaultAtts) {
! 2150: if (type->allocDefaultAtts == 0) {
! 2151: type->allocDefaultAtts = 8;
! 2152: type->defaultAtts = malloc(type->allocDefaultAtts*sizeof(DEFAULT_ATTRIBUTE));
! 2153: }
! 2154: else {
! 2155: type->allocDefaultAtts *= 2;
! 2156: type->defaultAtts = realloc(type->defaultAtts,
! 2157: type->allocDefaultAtts*sizeof(DEFAULT_ATTRIBUTE));
! 2158: }
! 2159: if (!type->defaultAtts)
! 2160: return 0;
! 2161: }
! 2162: att = type->defaultAtts + type->nDefaultAtts;
! 2163: att->id = attId;
! 2164: att->value = value;
! 2165: att->isCdata = isCdata;
! 2166: if (!isCdata)
! 2167: attId->maybeTokenized = 1;
! 2168: type->nDefaultAtts += 1;
! 2169: return 1;
! 2170: }
! 2171:
! 2172: static ATTRIBUTE_ID *
! 2173: getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start, const char *end)
! 2174: {
! 2175: ATTRIBUTE_ID *id;
! 2176: const XML_Char *name;
! 2177: if (!poolAppendChar(&dtd.pool, XML_T('\0')))
! 2178: return 0;
! 2179: name = poolStoreString(&dtd.pool, enc, start, end);
! 2180: if (!name)
! 2181: return 0;
! 2182: ++name;
! 2183: id = (ATTRIBUTE_ID *)lookup(&dtd.attributeIds, name, sizeof(ATTRIBUTE_ID));
! 2184: if (!id)
! 2185: return 0;
! 2186: if (id->name != name)
! 2187: poolDiscard(&dtd.pool);
! 2188: else
! 2189: poolFinish(&dtd.pool);
! 2190: return id;
! 2191: }
! 2192:
! 2193: static
! 2194: const XML_Char *getOpenEntityNames(XML_Parser parser)
! 2195: {
! 2196: HASH_TABLE_ITER iter;
! 2197:
! 2198: hashTableIterInit(&iter, &(dtd.generalEntities));
! 2199: for (;;) {
! 2200: const XML_Char *s;
! 2201: ENTITY *e = (ENTITY *)hashTableIterNext(&iter);
! 2202: if (!e)
! 2203: break;
! 2204: if (!e->open)
! 2205: continue;
! 2206: if (poolLength(&tempPool) > 0 && !poolAppendChar(&tempPool, XML_T(' ')))
! 2207: return 0;
! 2208: for (s = e->name; *s; s++)
! 2209: if (!poolAppendChar(&tempPool, *s))
! 2210: return 0;
! 2211: }
! 2212:
! 2213: if (!poolAppendChar(&tempPool, XML_T('\0')))
! 2214: return 0;
! 2215: return tempPool.start;
! 2216: }
! 2217:
! 2218: static
! 2219: int setOpenEntityNames(XML_Parser parser, const XML_Char *openEntityNames)
! 2220: {
! 2221: const XML_Char *s = openEntityNames;
! 2222: while (*openEntityNames != XML_T('\0')) {
! 2223: if (*s == XML_T(' ') || *s == XML_T('\0')) {
! 2224: ENTITY *e;
! 2225: if (!poolAppendChar(&tempPool, XML_T('\0')))
! 2226: return 0;
! 2227: e = (ENTITY *)lookup(&dtd.generalEntities, poolStart(&tempPool), 0);
! 2228: if (e)
! 2229: e->open = 1;
! 2230: if (*s == XML_T(' '))
! 2231: s++;
! 2232: openEntityNames = s;
! 2233: poolDiscard(&tempPool);
! 2234: }
! 2235: else {
! 2236: if (!poolAppendChar(&tempPool, *s))
! 2237: return 0;
! 2238: s++;
! 2239: }
! 2240: }
! 2241: return 1;
! 2242: }
! 2243:
! 2244:
! 2245: static
! 2246: void normalizePublicId(XML_Char *publicId)
! 2247: {
! 2248: XML_Char *p = publicId;
! 2249: XML_Char *s;
! 2250: for (s = publicId; *s; s++) {
! 2251: switch (*s) {
! 2252: case XML_T(' '):
! 2253: case XML_T('\r'):
! 2254: case XML_T('\n'):
! 2255: if (p != publicId && p[-1] != XML_T(' '))
! 2256: *p++ = XML_T(' ');
! 2257: break;
! 2258: default:
! 2259: *p++ = *s;
! 2260: }
! 2261: }
! 2262: if (p != publicId && p[-1] == XML_T(' '))
! 2263: --p;
! 2264: *p = XML_T('\0');
! 2265: }
! 2266:
! 2267: static int dtdInit(DTD *p)
! 2268: {
! 2269: poolInit(&(p->pool));
! 2270: hashTableInit(&(p->generalEntities));
! 2271: hashTableInit(&(p->elementTypes));
! 2272: hashTableInit(&(p->attributeIds));
! 2273: p->complete = 1;
! 2274: p->standalone = 0;
! 2275: p->base = 0;
! 2276: return 1;
! 2277: }
! 2278:
! 2279: static void dtdDestroy(DTD *p)
! 2280: {
! 2281: HASH_TABLE_ITER iter;
! 2282: hashTableIterInit(&iter, &(p->elementTypes));
! 2283: for (;;) {
! 2284: ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
! 2285: if (!e)
! 2286: break;
! 2287: if (e->allocDefaultAtts != 0)
! 2288: free(e->defaultAtts);
! 2289: }
! 2290: hashTableDestroy(&(p->generalEntities));
! 2291: hashTableDestroy(&(p->elementTypes));
! 2292: hashTableDestroy(&(p->attributeIds));
! 2293: poolDestroy(&(p->pool));
! 2294: }
! 2295:
! 2296: /* Do a deep copy of the DTD. Return 0 for out of memory; non-zero otherwise.
! 2297: The new DTD has already been initialized. */
! 2298:
! 2299: static int dtdCopy(DTD *newDtd, const DTD *oldDtd)
! 2300: {
! 2301: HASH_TABLE_ITER iter;
! 2302:
! 2303: if (oldDtd->base) {
! 2304: const XML_Char *tem = poolCopyString(&(newDtd->pool), oldDtd->base);
! 2305: if (!tem)
! 2306: return 0;
! 2307: newDtd->base = tem;
! 2308: }
! 2309:
! 2310: hashTableIterInit(&iter, &(oldDtd->attributeIds));
! 2311:
! 2312: /* Copy the attribute id table. */
! 2313:
! 2314: for (;;) {
! 2315: ATTRIBUTE_ID *newA;
! 2316: const XML_Char *name;
! 2317: const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);
! 2318:
! 2319: if (!oldA)
! 2320: break;
! 2321: /* Remember to allocate the scratch byte before the name. */
! 2322: if (!poolAppendChar(&(newDtd->pool), XML_T('\0')))
! 2323: return 0;
! 2324: name = poolCopyString(&(newDtd->pool), oldA->name);
! 2325: if (!name)
! 2326: return 0;
! 2327: ++name;
! 2328: newA = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), name, sizeof(ATTRIBUTE_ID));
! 2329: if (!newA)
! 2330: return 0;
! 2331: newA->maybeTokenized = oldA->maybeTokenized;
! 2332: }
! 2333:
! 2334: /* Copy the element type table. */
! 2335:
! 2336: hashTableIterInit(&iter, &(oldDtd->elementTypes));
! 2337:
! 2338: for (;;) {
! 2339: int i;
! 2340: ELEMENT_TYPE *newE;
! 2341: const XML_Char *name;
! 2342: const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);
! 2343: if (!oldE)
! 2344: break;
! 2345: name = poolCopyString(&(newDtd->pool), oldE->name);
! 2346: if (!name)
! 2347: return 0;
! 2348: newE = (ELEMENT_TYPE *)lookup(&(newDtd->elementTypes), name, sizeof(ELEMENT_TYPE));
! 2349: if (!newE)
! 2350: return 0;
! 2351: newE->defaultAtts = (DEFAULT_ATTRIBUTE *)malloc(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
! 2352: if (!newE->defaultAtts)
! 2353: return 0;
! 2354: newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
! 2355: for (i = 0; i < newE->nDefaultAtts; i++) {
! 2356: newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
! 2357: newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
! 2358: if (oldE->defaultAtts[i].value) {
! 2359: newE->defaultAtts[i].value = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);
! 2360: if (!newE->defaultAtts[i].value)
! 2361: return 0;
! 2362: }
! 2363: else
! 2364: newE->defaultAtts[i].value = 0;
! 2365: }
! 2366: }
! 2367:
! 2368: /* Copy the entity table. */
! 2369:
! 2370: hashTableIterInit(&iter, &(oldDtd->generalEntities));
! 2371:
! 2372: for (;;) {
! 2373: ENTITY *newE;
! 2374: const XML_Char *name;
! 2375: const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);
! 2376: if (!oldE)
! 2377: break;
! 2378: name = poolCopyString(&(newDtd->pool), oldE->name);
! 2379: if (!name)
! 2380: return 0;
! 2381: newE = (ENTITY *)lookup(&(newDtd->generalEntities), name, sizeof(ENTITY));
! 2382: if (!newE)
! 2383: return 0;
! 2384: if (oldE->systemId) {
! 2385: const XML_Char *tem = poolCopyString(&(newDtd->pool), oldE->systemId);
! 2386: if (!tem)
! 2387: return 0;
! 2388: newE->systemId = tem;
! 2389: if (oldE->base) {
! 2390: if (oldE->base == oldDtd->base)
! 2391: newE->base = newDtd->base;
! 2392: tem = poolCopyString(&(newDtd->pool), oldE->base);
! 2393: if (!tem)
! 2394: return 0;
! 2395: newE->base = tem;
! 2396: }
! 2397: }
! 2398: else {
! 2399: const XML_Char *tem = poolCopyStringN(&(newDtd->pool), oldE->textPtr, oldE->textLen);
! 2400: if (!tem)
! 2401: return 0;
! 2402: newE->textPtr = tem;
! 2403: newE->textLen = oldE->textLen;
! 2404: }
! 2405: if (oldE->notation) {
! 2406: const XML_Char *tem = poolCopyString(&(newDtd->pool), oldE->notation);
! 2407: if (!tem)
! 2408: return 0;
! 2409: newE->notation = tem;
! 2410: }
! 2411: }
! 2412:
! 2413: newDtd->complete = oldDtd->complete;
! 2414: newDtd->standalone = oldDtd->standalone;
! 2415: return 1;
! 2416: }
! 2417:
! 2418: static
! 2419: void poolInit(STRING_POOL *pool)
! 2420: {
! 2421: pool->blocks = 0;
! 2422: pool->freeBlocks = 0;
! 2423: pool->start = 0;
! 2424: pool->ptr = 0;
! 2425: pool->end = 0;
! 2426: }
! 2427:
! 2428: static
! 2429: void poolClear(STRING_POOL *pool)
! 2430: {
! 2431: if (!pool->freeBlocks)
! 2432: pool->freeBlocks = pool->blocks;
! 2433: else {
! 2434: BLOCK *p = pool->blocks;
! 2435: while (p) {
! 2436: BLOCK *tem = p->next;
! 2437: p->next = pool->freeBlocks;
! 2438: pool->freeBlocks = p;
! 2439: p = tem;
! 2440: }
! 2441: }
! 2442: pool->blocks = 0;
! 2443: pool->start = 0;
! 2444: pool->ptr = 0;
! 2445: pool->end = 0;
! 2446: }
! 2447:
! 2448: static
! 2449: void poolDestroy(STRING_POOL *pool)
! 2450: {
! 2451: BLOCK *p = pool->blocks;
! 2452: while (p) {
! 2453: BLOCK *tem = p->next;
! 2454: free(p);
! 2455: p = tem;
! 2456: }
! 2457: pool->blocks = 0;
! 2458: p = pool->freeBlocks;
! 2459: while (p) {
! 2460: BLOCK *tem = p->next;
! 2461: free(p);
! 2462: p = tem;
! 2463: }
! 2464: pool->freeBlocks = 0;
! 2465: pool->ptr = 0;
! 2466: pool->start = 0;
! 2467: pool->end = 0;
! 2468: }
! 2469:
! 2470: static
! 2471: XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
! 2472: const char *ptr, const char *end)
! 2473: {
! 2474: if (!pool->ptr && !poolGrow(pool))
! 2475: return 0;
! 2476: for (;;) {
! 2477: XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
! 2478: if (ptr == end)
! 2479: break;
! 2480: if (!poolGrow(pool))
! 2481: return 0;
! 2482: }
! 2483: return pool->start;
! 2484: }
! 2485:
! 2486: static const XML_Char *poolCopyString(STRING_POOL *pool, const XML_Char *s)
! 2487: {
! 2488: do {
! 2489: if (!poolAppendChar(pool, *s))
! 2490: return 0;
! 2491: } while (*s++);
! 2492: s = pool->start;
! 2493: poolFinish(pool);
! 2494: return s;
! 2495: }
! 2496:
! 2497: static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n)
! 2498: {
! 2499: if (!pool->ptr && !poolGrow(pool))
! 2500: return 0;
! 2501: for (; n > 0; --n, s++) {
! 2502: if (!poolAppendChar(pool, *s))
! 2503: return 0;
! 2504:
! 2505: }
! 2506: s = pool->start;
! 2507: poolFinish(pool);
! 2508: return s;
! 2509: }
! 2510:
! 2511: static
! 2512: XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
! 2513: const char *ptr, const char *end)
! 2514: {
! 2515: if (!poolAppend(pool, enc, ptr, end))
! 2516: return 0;
! 2517: if (pool->ptr == pool->end && !poolGrow(pool))
! 2518: return 0;
! 2519: *(pool->ptr)++ = 0;
! 2520: return pool->start;
! 2521: }
! 2522:
! 2523: static
! 2524: int poolGrow(STRING_POOL *pool)
! 2525: {
! 2526: if (pool->freeBlocks) {
! 2527: if (pool->start == 0) {
! 2528: pool->blocks = pool->freeBlocks;
! 2529: pool->freeBlocks = pool->freeBlocks->next;
! 2530: pool->blocks->next = 0;
! 2531: pool->start = pool->blocks->s;
! 2532: pool->end = pool->start + pool->blocks->size;
! 2533: pool->ptr = pool->start;
! 2534: return 1;
! 2535: }
! 2536: if (pool->end - pool->start < pool->freeBlocks->size) {
! 2537: BLOCK *tem = pool->freeBlocks->next;
! 2538: pool->freeBlocks->next = pool->blocks;
! 2539: pool->blocks = pool->freeBlocks;
! 2540: pool->freeBlocks = tem;
! 2541: memcpy(pool->blocks->s, pool->start, (pool->end - pool->start) * sizeof(XML_Char));
! 2542: pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
! 2543: pool->start = pool->blocks->s;
! 2544: pool->end = pool->start + pool->blocks->size;
! 2545: return 1;
! 2546: }
! 2547: }
! 2548: if (pool->blocks && pool->start == pool->blocks->s) {
! 2549: int blockSize = (pool->end - pool->start)*2;
! 2550: pool->blocks = realloc(pool->blocks, offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
! 2551: if (!pool->blocks)
! 2552: return 0;
! 2553: pool->blocks->size = blockSize;
! 2554: pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
! 2555: pool->start = pool->blocks->s;
! 2556: pool->end = pool->start + blockSize;
! 2557: }
! 2558: else {
! 2559: BLOCK *tem;
! 2560: int blockSize = pool->end - pool->start;
! 2561: if (blockSize < INIT_BLOCK_SIZE)
! 2562: blockSize = INIT_BLOCK_SIZE;
! 2563: else
! 2564: blockSize *= 2;
! 2565: tem = malloc(offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
! 2566: if (!tem)
! 2567: return 0;
! 2568: tem->size = blockSize;
! 2569: tem->next = pool->blocks;
! 2570: pool->blocks = tem;
! 2571: memcpy(tem->s, pool->start, (pool->ptr - pool->start) * sizeof(XML_Char));
! 2572: pool->ptr = tem->s + (pool->ptr - pool->start);
! 2573: pool->start = tem->s;
! 2574: pool->end = tem->s + blockSize;
! 2575: }
! 2576: return 1;
! 2577: }
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xmlparse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / libwww / modules / expat / xmlparse