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