Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(277)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/expat/files/lib/xmlparse.c.original

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

Powered by Google App Engine
This is Rietveld 408576698