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