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