|
1 /* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd |
|
2 See the file COPYING for copying permission. |
|
3 */ |
|
4 |
|
5 #ifndef Expat_INCLUDED |
|
6 #define Expat_INCLUDED 1 |
|
7 |
|
8 #ifdef __VMS |
|
9 /* 0 1 2 3 0 1 2 3 |
|
10 1234567890123456789012345678901 1234567890123456789012345678901 */ |
|
11 #define XML_SetProcessingInstructionHandler XML_SetProcessingInstrHandler |
|
12 #define XML_SetUnparsedEntityDeclHandler XML_SetUnparsedEntDeclHandler |
|
13 #define XML_SetStartNamespaceDeclHandler XML_SetStartNamespcDeclHandler |
|
14 #define XML_SetExternalEntityRefHandlerArg XML_SetExternalEntRefHandlerArg |
|
15 #endif |
|
16 |
|
17 #include <stdlib.h> |
|
18 #include "expat_external.h" |
|
19 |
|
20 #ifdef __cplusplus |
|
21 extern "C" { |
|
22 #endif |
|
23 |
|
24 struct XML_ParserStruct; |
|
25 typedef struct XML_ParserStruct *XML_Parser; |
|
26 |
|
27 /* Should this be defined using stdbool.h when C99 is available? */ |
|
28 typedef unsigned char XML_Bool; |
|
29 #define XML_TRUE ((XML_Bool) 1) |
|
30 #define XML_FALSE ((XML_Bool) 0) |
|
31 |
|
32 /* The XML_Status enum gives the possible return values for several |
|
33 API functions. The preprocessor #defines are included so this |
|
34 stanza can be added to code that still needs to support older |
|
35 versions of Expat 1.95.x: |
|
36 |
|
37 #ifndef XML_STATUS_OK |
|
38 #define XML_STATUS_OK 1 |
|
39 #define XML_STATUS_ERROR 0 |
|
40 #endif |
|
41 |
|
42 Otherwise, the #define hackery is quite ugly and would have been |
|
43 dropped. |
|
44 */ |
|
45 enum XML_Status { |
|
46 XML_STATUS_ERROR = 0, |
|
47 #define XML_STATUS_ERROR XML_STATUS_ERROR |
|
48 XML_STATUS_OK = 1, |
|
49 #define XML_STATUS_OK XML_STATUS_OK |
|
50 XML_STATUS_SUSPENDED = 2 |
|
51 #define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED |
|
52 }; |
|
53 |
|
54 enum XML_Error { |
|
55 XML_ERROR_NONE, |
|
56 XML_ERROR_NO_MEMORY, |
|
57 XML_ERROR_SYNTAX, |
|
58 XML_ERROR_NO_ELEMENTS, |
|
59 XML_ERROR_INVALID_TOKEN, |
|
60 XML_ERROR_UNCLOSED_TOKEN, |
|
61 XML_ERROR_PARTIAL_CHAR, |
|
62 XML_ERROR_TAG_MISMATCH, |
|
63 XML_ERROR_DUPLICATE_ATTRIBUTE, |
|
64 XML_ERROR_JUNK_AFTER_DOC_ELEMENT, |
|
65 XML_ERROR_PARAM_ENTITY_REF, |
|
66 XML_ERROR_UNDEFINED_ENTITY, |
|
67 XML_ERROR_RECURSIVE_ENTITY_REF, |
|
68 XML_ERROR_ASYNC_ENTITY, |
|
69 XML_ERROR_BAD_CHAR_REF, |
|
70 XML_ERROR_BINARY_ENTITY_REF, |
|
71 XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF, |
|
72 XML_ERROR_MISPLACED_XML_PI, |
|
73 XML_ERROR_UNKNOWN_ENCODING, |
|
74 XML_ERROR_INCORRECT_ENCODING, |
|
75 XML_ERROR_UNCLOSED_CDATA_SECTION, |
|
76 XML_ERROR_EXTERNAL_ENTITY_HANDLING, |
|
77 XML_ERROR_NOT_STANDALONE, |
|
78 XML_ERROR_UNEXPECTED_STATE, |
|
79 XML_ERROR_ENTITY_DECLARED_IN_PE, |
|
80 XML_ERROR_FEATURE_REQUIRES_XML_DTD, |
|
81 XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING, |
|
82 /* Added in 1.95.7. */ |
|
83 XML_ERROR_UNBOUND_PREFIX, |
|
84 /* Added in 1.95.8. */ |
|
85 XML_ERROR_UNDECLARING_PREFIX, |
|
86 XML_ERROR_INCOMPLETE_PE, |
|
87 XML_ERROR_XML_DECL, |
|
88 XML_ERROR_TEXT_DECL, |
|
89 XML_ERROR_PUBLICID, |
|
90 XML_ERROR_SUSPENDED, |
|
91 XML_ERROR_NOT_SUSPENDED, |
|
92 XML_ERROR_ABORTED, |
|
93 XML_ERROR_FINISHED, |
|
94 XML_ERROR_SUSPEND_PE, |
|
95 /* Added in 2.0. */ |
|
96 XML_ERROR_RESERVED_PREFIX_XML, |
|
97 XML_ERROR_RESERVED_PREFIX_XMLNS, |
|
98 XML_ERROR_RESERVED_NAMESPACE_URI |
|
99 }; |
|
100 |
|
101 enum XML_Content_Type { |
|
102 XML_CTYPE_EMPTY = 1, |
|
103 XML_CTYPE_ANY, |
|
104 XML_CTYPE_MIXED, |
|
105 XML_CTYPE_NAME, |
|
106 XML_CTYPE_CHOICE, |
|
107 XML_CTYPE_SEQ |
|
108 }; |
|
109 |
|
110 enum XML_Content_Quant { |
|
111 XML_CQUANT_NONE, |
|
112 XML_CQUANT_OPT, |
|
113 XML_CQUANT_REP, |
|
114 XML_CQUANT_PLUS |
|
115 }; |
|
116 |
|
117 /* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be |
|
118 XML_CQUANT_NONE, and the other fields will be zero or NULL. |
|
119 If type == XML_CTYPE_MIXED, then quant will be NONE or REP and |
|
120 numchildren will contain number of elements that may be mixed in |
|
121 and children point to an array of XML_Content cells that will be |
|
122 all of XML_CTYPE_NAME type with no quantification. |
|
123 |
|
124 If type == XML_CTYPE_NAME, then the name points to the name, and |
|
125 the numchildren field will be zero and children will be NULL. The |
|
126 quant fields indicates any quantifiers placed on the name. |
|
127 |
|
128 CHOICE and SEQ will have name NULL, the number of children in |
|
129 numchildren and children will point, recursively, to an array |
|
130 of XML_Content cells. |
|
131 |
|
132 The EMPTY, ANY, and MIXED types will only occur at top level. |
|
133 */ |
|
134 |
|
135 typedef struct XML_cp XML_Content; |
|
136 |
|
137 struct XML_cp { |
|
138 enum XML_Content_Type type; |
|
139 enum XML_Content_Quant quant; |
|
140 XML_Char * name; |
|
141 unsigned int numchildren; |
|
142 XML_Content * children; |
|
143 }; |
|
144 |
|
145 |
|
146 /* This is called for an element declaration. See above for |
|
147 description of the model argument. It's the caller's responsibility |
|
148 to free model when finished with it. |
|
149 */ |
|
150 typedef void (XMLCALL *XML_ElementDeclHandler) (void *userData, |
|
151 const XML_Char *name, |
|
152 XML_Content *model); |
|
153 |
|
154 XMLPARSEAPI(void) |
|
155 XML_SetElementDeclHandler(XML_Parser parser, |
|
156 XML_ElementDeclHandler eldecl); |
|
157 |
|
158 /* The Attlist declaration handler is called for *each* attribute. So |
|
159 a single Attlist declaration with multiple attributes declared will |
|
160 generate multiple calls to this handler. The "default" parameter |
|
161 may be NULL in the case of the "#IMPLIED" or "#REQUIRED" |
|
162 keyword. The "isrequired" parameter will be true and the default |
|
163 value will be NULL in the case of "#REQUIRED". If "isrequired" is |
|
164 true and default is non-NULL, then this is a "#FIXED" default. |
|
165 */ |
|
166 typedef void (XMLCALL *XML_AttlistDeclHandler) ( |
|
167 void *userData, |
|
168 const XML_Char *elname, |
|
169 const XML_Char *attname, |
|
170 const XML_Char *att_type, |
|
171 const XML_Char *dflt, |
|
172 int isrequired); |
|
173 |
|
174 XMLPARSEAPI(void) |
|
175 XML_SetAttlistDeclHandler(XML_Parser parser, |
|
176 XML_AttlistDeclHandler attdecl); |
|
177 |
|
178 /* The XML declaration handler is called for *both* XML declarations |
|
179 and text declarations. The way to distinguish is that the version |
|
180 parameter will be NULL for text declarations. The encoding |
|
181 parameter may be NULL for XML declarations. The standalone |
|
182 parameter will be -1, 0, or 1 indicating respectively that there |
|
183 was no standalone parameter in the declaration, that it was given |
|
184 as no, or that it was given as yes. |
|
185 */ |
|
186 typedef void (XMLCALL *XML_XmlDeclHandler) (void *userData, |
|
187 const XML_Char *version, |
|
188 const XML_Char *encoding, |
|
189 int standalone); |
|
190 |
|
191 XMLPARSEAPI(void) |
|
192 XML_SetXmlDeclHandler(XML_Parser parser, |
|
193 XML_XmlDeclHandler xmldecl); |
|
194 |
|
195 |
|
196 typedef struct { |
|
197 void *(*malloc_fcn)(size_t size); |
|
198 void *(*realloc_fcn)(void *ptr, size_t size); |
|
199 void (*free_fcn)(void *ptr); |
|
200 } XML_Memory_Handling_Suite; |
|
201 |
|
202 /* Constructs a new parser; encoding is the encoding specified by the |
|
203 external protocol or NULL if there is none specified. |
|
204 */ |
|
205 XMLPARSEAPI(XML_Parser) |
|
206 XML_ParserCreate(const XML_Char *encoding); |
|
207 |
|
208 /* Constructs a new parser and namespace processor. Element type |
|
209 names and attribute names that belong to a namespace will be |
|
210 expanded; unprefixed attribute names are never expanded; unprefixed |
|
211 element type names are expanded only if there is a default |
|
212 namespace. The expanded name is the concatenation of the namespace |
|
213 URI, the namespace separator character, and the local part of the |
|
214 name. If the namespace separator is '\0' then the namespace URI |
|
215 and the local part will be concatenated without any separator. |
|
216 It is a programming error to use the separator '\0' with namespace |
|
217 triplets (see XML_SetReturnNSTriplet). |
|
218 */ |
|
219 XMLPARSEAPI(XML_Parser) |
|
220 XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator); |
|
221 |
|
222 |
|
223 /* Constructs a new parser using the memory management suite referred to |
|
224 by memsuite. If memsuite is NULL, then use the standard library memory |
|
225 suite. If namespaceSeparator is non-NULL it creates a parser with |
|
226 namespace processing as described above. The character pointed at |
|
227 will serve as the namespace separator. |
|
228 |
|
229 All further memory operations used for the created parser will come from |
|
230 the given suite. |
|
231 */ |
|
232 XMLPARSEAPI(XML_Parser) |
|
233 XML_ParserCreate_MM(const XML_Char *encoding, |
|
234 const XML_Memory_Handling_Suite *memsuite, |
|
235 const XML_Char *namespaceSeparator); |
|
236 |
|
237 /* Prepare a parser object to be re-used. This is particularly |
|
238 valuable when memory allocation overhead is disproportionatly high, |
|
239 such as when a large number of small documnents need to be parsed. |
|
240 All handlers are cleared from the parser, except for the |
|
241 unknownEncodingHandler. The parser's external state is re-initialized |
|
242 except for the values of ns and ns_triplets. |
|
243 |
|
244 Added in Expat 1.95.3. |
|
245 */ |
|
246 XMLPARSEAPI(XML_Bool) |
|
247 XML_ParserReset(XML_Parser parser, const XML_Char *encoding); |
|
248 |
|
249 /* atts is array of name/value pairs, terminated by 0; |
|
250 names and values are 0 terminated. |
|
251 */ |
|
252 typedef void (XMLCALL *XML_StartElementHandler) (void *userData, |
|
253 const XML_Char *name, |
|
254 const XML_Char **atts); |
|
255 |
|
256 typedef void (XMLCALL *XML_EndElementHandler) (void *userData, |
|
257 const XML_Char *name); |
|
258 |
|
259 |
|
260 /* s is not 0 terminated. */ |
|
261 typedef void (XMLCALL *XML_CharacterDataHandler) (void *userData, |
|
262 const XML_Char *s, |
|
263 int len); |
|
264 |
|
265 /* target and data are 0 terminated */ |
|
266 typedef void (XMLCALL *XML_ProcessingInstructionHandler) ( |
|
267 void *userData, |
|
268 const XML_Char *target, |
|
269 const XML_Char *data); |
|
270 |
|
271 /* data is 0 terminated */ |
|
272 typedef void (XMLCALL *XML_CommentHandler) (void *userData, |
|
273 const XML_Char *data); |
|
274 |
|
275 typedef void (XMLCALL *XML_StartCdataSectionHandler) (void *userData); |
|
276 typedef void (XMLCALL *XML_EndCdataSectionHandler) (void *userData); |
|
277 |
|
278 /* This is called for any characters in the XML document for which |
|
279 there is no applicable handler. This includes both characters that |
|
280 are part of markup which is of a kind that is not reported |
|
281 (comments, markup declarations), or characters that are part of a |
|
282 construct which could be reported but for which no handler has been |
|
283 supplied. The characters are passed exactly as they were in the XML |
|
284 document except that they will be encoded in UTF-8 or UTF-16. |
|
285 Line boundaries are not normalized. Note that a byte order mark |
|
286 character is not passed to the default handler. There are no |
|
287 guarantees about how characters are divided between calls to the |
|
288 default handler: for example, a comment might be split between |
|
289 multiple calls. |
|
290 */ |
|
291 typedef void (XMLCALL *XML_DefaultHandler) (void *userData, |
|
292 const XML_Char *s, |
|
293 int len); |
|
294 |
|
295 /* This is called for the start of the DOCTYPE declaration, before |
|
296 any DTD or internal subset is parsed. |
|
297 */ |
|
298 typedef void (XMLCALL *XML_StartDoctypeDeclHandler) ( |
|
299 void *userData, |
|
300 const XML_Char *doctypeName, |
|
301 const XML_Char *sysid, |
|
302 const XML_Char *pubid, |
|
303 int has_internal_subset); |
|
304 |
|
305 /* This is called for the start of the DOCTYPE declaration when the |
|
306 closing > is encountered, but after processing any external |
|
307 subset. |
|
308 */ |
|
309 typedef void (XMLCALL *XML_EndDoctypeDeclHandler)(void *userData); |
|
310 |
|
311 /* This is called for entity declarations. The is_parameter_entity |
|
312 argument will be non-zero if the entity is a parameter entity, zero |
|
313 otherwise. |
|
314 |
|
315 For internal entities (<!ENTITY foo "bar">), value will |
|
316 be non-NULL and systemId, publicID, and notationName will be NULL. |
|
317 The value string is NOT nul-terminated; the length is provided in |
|
318 the value_length argument. Since it is legal to have zero-length |
|
319 values, do not use this argument to test for internal entities. |
|
320 |
|
321 For external entities, value will be NULL and systemId will be |
|
322 non-NULL. The publicId argument will be NULL unless a public |
|
323 identifier was provided. The notationName argument will have a |
|
324 non-NULL value only for unparsed entity declarations. |
|
325 |
|
326 Note that is_parameter_entity can't be changed to XML_Bool, since |
|
327 that would break binary compatibility. |
|
328 */ |
|
329 typedef void (XMLCALL *XML_EntityDeclHandler) ( |
|
330 void *userData, |
|
331 const XML_Char *entityName, |
|
332 int is_parameter_entity, |
|
333 const XML_Char *value, |
|
334 int value_length, |
|
335 const XML_Char *base, |
|
336 const XML_Char *systemId, |
|
337 const XML_Char *publicId, |
|
338 const XML_Char *notationName); |
|
339 |
|
340 XMLPARSEAPI(void) |
|
341 XML_SetEntityDeclHandler(XML_Parser parser, |
|
342 XML_EntityDeclHandler handler); |
|
343 |
|
344 /* OBSOLETE -- OBSOLETE -- OBSOLETE |
|
345 This handler has been superceded by the EntityDeclHandler above. |
|
346 It is provided here for backward compatibility. |
|
347 |
|
348 This is called for a declaration of an unparsed (NDATA) entity. |
|
349 The base argument is whatever was set by XML_SetBase. The |
|
350 entityName, systemId and notationName arguments will never be |
|
351 NULL. The other arguments may be. |
|
352 */ |
|
353 typedef void (XMLCALL *XML_UnparsedEntityDeclHandler) ( |
|
354 void *userData, |
|
355 const XML_Char *entityName, |
|
356 const XML_Char *base, |
|
357 const XML_Char *systemId, |
|
358 const XML_Char *publicId, |
|
359 const XML_Char *notationName); |
|
360 |
|
361 /* This is called for a declaration of notation. The base argument is |
|
362 whatever was set by XML_SetBase. The notationName will never be |
|
363 NULL. The other arguments can be. |
|
364 */ |
|
365 typedef void (XMLCALL *XML_NotationDeclHandler) ( |
|
366 void *userData, |
|
367 const XML_Char *notationName, |
|
368 const XML_Char *base, |
|
369 const XML_Char *systemId, |
|
370 const XML_Char *publicId); |
|
371 |
|
372 /* When namespace processing is enabled, these are called once for |
|
373 each namespace declaration. The call to the start and end element |
|
374 handlers occur between the calls to the start and end namespace |
|
375 declaration handlers. For an xmlns attribute, prefix will be |
|
376 NULL. For an xmlns="" attribute, uri will be NULL. |
|
377 */ |
|
378 typedef void (XMLCALL *XML_StartNamespaceDeclHandler) ( |
|
379 void *userData, |
|
380 const XML_Char *prefix, |
|
381 const XML_Char *uri); |
|
382 |
|
383 typedef void (XMLCALL *XML_EndNamespaceDeclHandler) ( |
|
384 void *userData, |
|
385 const XML_Char *prefix); |
|
386 |
|
387 /* This is called if the document is not standalone, that is, it has an |
|
388 external subset or a reference to a parameter entity, but does not |
|
389 have standalone="yes". If this handler returns XML_STATUS_ERROR, |
|
390 then processing will not continue, and the parser will return a |
|
391 XML_ERROR_NOT_STANDALONE error. |
|
392 If parameter entity parsing is enabled, then in addition to the |
|
393 conditions above this handler will only be called if the referenced |
|
394 entity was actually read. |
|
395 */ |
|
396 typedef int (XMLCALL *XML_NotStandaloneHandler) (void *userData); |
|
397 |
|
398 /* This is called for a reference to an external parsed general |
|
399 entity. The referenced entity is not automatically parsed. The |
|
400 application can parse it immediately or later using |
|
401 XML_ExternalEntityParserCreate. |
|
402 |
|
403 The parser argument is the parser parsing the entity containing the |
|
404 reference; it can be passed as the parser argument to |
|
405 XML_ExternalEntityParserCreate. The systemId argument is the |
|
406 system identifier as specified in the entity declaration; it will |
|
407 not be NULL. |
|
408 |
|
409 The base argument is the system identifier that should be used as |
|
410 the base for resolving systemId if systemId was relative; this is |
|
411 set by XML_SetBase; it may be NULL. |
|
412 |
|
413 The publicId argument is the public identifier as specified in the |
|
414 entity declaration, or NULL if none was specified; the whitespace |
|
415 in the public identifier will have been normalized as required by |
|
416 the XML spec. |
|
417 |
|
418 The context argument specifies the parsing context in the format |
|
419 expected by the context argument to XML_ExternalEntityParserCreate; |
|
420 context is valid only until the handler returns, so if the |
|
421 referenced entity is to be parsed later, it must be copied. |
|
422 context is NULL only when the entity is a parameter entity. |
|
423 |
|
424 The handler should return XML_STATUS_ERROR if processing should not |
|
425 continue because of a fatal error in the handling of the external |
|
426 entity. In this case the calling parser will return an |
|
427 XML_ERROR_EXTERNAL_ENTITY_HANDLING error. |
|
428 |
|
429 Note that unlike other handlers the first argument is the parser, |
|
430 not userData. |
|
431 */ |
|
432 typedef int (XMLCALL *XML_ExternalEntityRefHandler) ( |
|
433 XML_Parser parser, |
|
434 const XML_Char *context, |
|
435 const XML_Char *base, |
|
436 const XML_Char *systemId, |
|
437 const XML_Char *publicId); |
|
438 |
|
439 /* This is called in two situations: |
|
440 1) An entity reference is encountered for which no declaration |
|
441 has been read *and* this is not an error. |
|
442 2) An internal entity reference is read, but not expanded, because |
|
443 XML_SetDefaultHandler has been called. |
|
444 Note: skipped parameter entities in declarations and skipped general |
|
445 entities in attribute values cannot be reported, because |
|
446 the event would be out of sync with the reporting of the |
|
447 declarations or attribute values |
|
448 */ |
|
449 typedef void (XMLCALL *XML_SkippedEntityHandler) ( |
|
450 void *userData, |
|
451 const XML_Char *entityName, |
|
452 int is_parameter_entity); |
|
453 |
|
454 /* This structure is filled in by the XML_UnknownEncodingHandler to |
|
455 provide information to the parser about encodings that are unknown |
|
456 to the parser. |
|
457 |
|
458 The map[b] member gives information about byte sequences whose |
|
459 first byte is b. |
|
460 |
|
461 If map[b] is c where c is >= 0, then b by itself encodes the |
|
462 Unicode scalar value c. |
|
463 |
|
464 If map[b] is -1, then the byte sequence is malformed. |
|
465 |
|
466 If map[b] is -n, where n >= 2, then b is the first byte of an |
|
467 n-byte sequence that encodes a single Unicode scalar value. |
|
468 |
|
469 The data member will be passed as the first argument to the convert |
|
470 function. |
|
471 |
|
472 The convert function is used to convert multibyte sequences; s will |
|
473 point to a n-byte sequence where map[(unsigned char)*s] == -n. The |
|
474 convert function must return the Unicode scalar value represented |
|
475 by this byte sequence or -1 if the byte sequence is malformed. |
|
476 |
|
477 The convert function may be NULL if the encoding is a single-byte |
|
478 encoding, that is if map[b] >= -1 for all bytes b. |
|
479 |
|
480 When the parser is finished with the encoding, then if release is |
|
481 not NULL, it will call release passing it the data member; once |
|
482 release has been called, the convert function will not be called |
|
483 again. |
|
484 |
|
485 Expat places certain restrictions on the encodings that are supported |
|
486 using this mechanism. |
|
487 |
|
488 1. Every ASCII character that can appear in a well-formed XML document, |
|
489 other than the characters |
|
490 |
|
491 $@\^`{}~ |
|
492 |
|
493 must be represented by a single byte, and that byte must be the |
|
494 same byte that represents that character in ASCII. |
|
495 |
|
496 2. No character may require more than 4 bytes to encode. |
|
497 |
|
498 3. All characters encoded must have Unicode scalar values <= |
|
499 0xFFFF, (i.e., characters that would be encoded by surrogates in |
|
500 UTF-16 are not allowed). Note that this restriction doesn't |
|
501 apply to the built-in support for UTF-8 and UTF-16. |
|
502 |
|
503 4. No Unicode character may be encoded by more than one distinct |
|
504 sequence of bytes. |
|
505 */ |
|
506 typedef struct { |
|
507 int map[256]; |
|
508 void *data; |
|
509 int (XMLCALL *convert)(void *data, const char *s); |
|
510 void (XMLCALL *release)(void *data); |
|
511 } XML_Encoding; |
|
512 |
|
513 /* This is called for an encoding that is unknown to the parser. |
|
514 |
|
515 The encodingHandlerData argument is that which was passed as the |
|
516 second argument to XML_SetUnknownEncodingHandler. |
|
517 |
|
518 The name argument gives the name of the encoding as specified in |
|
519 the encoding declaration. |
|
520 |
|
521 If the callback can provide information about the encoding, it must |
|
522 fill in the XML_Encoding structure, and return XML_STATUS_OK. |
|
523 Otherwise it must return XML_STATUS_ERROR. |
|
524 |
|
525 If info does not describe a suitable encoding, then the parser will |
|
526 return an XML_UNKNOWN_ENCODING error. |
|
527 */ |
|
528 typedef int (XMLCALL *XML_UnknownEncodingHandler) ( |
|
529 void *encodingHandlerData, |
|
530 const XML_Char *name, |
|
531 XML_Encoding *info); |
|
532 |
|
533 XMLPARSEAPI(void) |
|
534 XML_SetElementHandler(XML_Parser parser, |
|
535 XML_StartElementHandler start, |
|
536 XML_EndElementHandler end); |
|
537 |
|
538 XMLPARSEAPI(void) |
|
539 XML_SetStartElementHandler(XML_Parser parser, |
|
540 XML_StartElementHandler handler); |
|
541 |
|
542 XMLPARSEAPI(void) |
|
543 XML_SetEndElementHandler(XML_Parser parser, |
|
544 XML_EndElementHandler handler); |
|
545 |
|
546 XMLPARSEAPI(void) |
|
547 XML_SetCharacterDataHandler(XML_Parser parser, |
|
548 XML_CharacterDataHandler handler); |
|
549 |
|
550 XMLPARSEAPI(void) |
|
551 XML_SetProcessingInstructionHandler(XML_Parser parser, |
|
552 XML_ProcessingInstructionHandler handler); |
|
553 XMLPARSEAPI(void) |
|
554 XML_SetCommentHandler(XML_Parser parser, |
|
555 XML_CommentHandler handler); |
|
556 |
|
557 XMLPARSEAPI(void) |
|
558 XML_SetCdataSectionHandler(XML_Parser parser, |
|
559 XML_StartCdataSectionHandler start, |
|
560 XML_EndCdataSectionHandler end); |
|
561 |
|
562 XMLPARSEAPI(void) |
|
563 XML_SetStartCdataSectionHandler(XML_Parser parser, |
|
564 XML_StartCdataSectionHandler start); |
|
565 |
|
566 XMLPARSEAPI(void) |
|
567 XML_SetEndCdataSectionHandler(XML_Parser parser, |
|
568 XML_EndCdataSectionHandler end); |
|
569 |
|
570 /* This sets the default handler and also inhibits expansion of |
|
571 internal entities. These entity references will be passed to the |
|
572 default handler, or to the skipped entity handler, if one is set. |
|
573 */ |
|
574 XMLPARSEAPI(void) |
|
575 XML_SetDefaultHandler(XML_Parser parser, |
|
576 XML_DefaultHandler handler); |
|
577 |
|
578 /* This sets the default handler but does not inhibit expansion of |
|
579 internal entities. The entity reference will not be passed to the |
|
580 default handler. |
|
581 */ |
|
582 XMLPARSEAPI(void) |
|
583 XML_SetDefaultHandlerExpand(XML_Parser parser, |
|
584 XML_DefaultHandler handler); |
|
585 |
|
586 XMLPARSEAPI(void) |
|
587 XML_SetDoctypeDeclHandler(XML_Parser parser, |
|
588 XML_StartDoctypeDeclHandler start, |
|
589 XML_EndDoctypeDeclHandler end); |
|
590 |
|
591 XMLPARSEAPI(void) |
|
592 XML_SetStartDoctypeDeclHandler(XML_Parser parser, |
|
593 XML_StartDoctypeDeclHandler start); |
|
594 |
|
595 XMLPARSEAPI(void) |
|
596 XML_SetEndDoctypeDeclHandler(XML_Parser parser, |
|
597 XML_EndDoctypeDeclHandler end); |
|
598 |
|
599 XMLPARSEAPI(void) |
|
600 XML_SetUnparsedEntityDeclHandler(XML_Parser parser, |
|
601 XML_UnparsedEntityDeclHandler handler); |
|
602 |
|
603 XMLPARSEAPI(void) |
|
604 XML_SetNotationDeclHandler(XML_Parser parser, |
|
605 XML_NotationDeclHandler handler); |
|
606 |
|
607 XMLPARSEAPI(void) |
|
608 XML_SetNamespaceDeclHandler(XML_Parser parser, |
|
609 XML_StartNamespaceDeclHandler start, |
|
610 XML_EndNamespaceDeclHandler end); |
|
611 |
|
612 XMLPARSEAPI(void) |
|
613 XML_SetStartNamespaceDeclHandler(XML_Parser parser, |
|
614 XML_StartNamespaceDeclHandler start); |
|
615 |
|
616 XMLPARSEAPI(void) |
|
617 XML_SetEndNamespaceDeclHandler(XML_Parser parser, |
|
618 XML_EndNamespaceDeclHandler end); |
|
619 |
|
620 XMLPARSEAPI(void) |
|
621 XML_SetNotStandaloneHandler(XML_Parser parser, |
|
622 XML_NotStandaloneHandler handler); |
|
623 |
|
624 XMLPARSEAPI(void) |
|
625 XML_SetExternalEntityRefHandler(XML_Parser parser, |
|
626 XML_ExternalEntityRefHandler handler); |
|
627 |
|
628 /* If a non-NULL value for arg is specified here, then it will be |
|
629 passed as the first argument to the external entity ref handler |
|
630 instead of the parser object. |
|
631 */ |
|
632 XMLPARSEAPI(void) |
|
633 XML_SetExternalEntityRefHandlerArg(XML_Parser parser, |
|
634 void *arg); |
|
635 |
|
636 XMLPARSEAPI(void) |
|
637 XML_SetSkippedEntityHandler(XML_Parser parser, |
|
638 XML_SkippedEntityHandler handler); |
|
639 |
|
640 XMLPARSEAPI(void) |
|
641 XML_SetUnknownEncodingHandler(XML_Parser parser, |
|
642 XML_UnknownEncodingHandler handler, |
|
643 void *encodingHandlerData); |
|
644 |
|
645 /* This can be called within a handler for a start element, end |
|
646 element, processing instruction or character data. It causes the |
|
647 corresponding markup to be passed to the default handler. |
|
648 */ |
|
649 XMLPARSEAPI(void) |
|
650 XML_DefaultCurrent(XML_Parser parser); |
|
651 |
|
652 /* If do_nst is non-zero, and namespace processing is in effect, and |
|
653 a name has a prefix (i.e. an explicit namespace qualifier) then |
|
654 that name is returned as a triplet in a single string separated by |
|
655 the separator character specified when the parser was created: URI |
|
656 + sep + local_name + sep + prefix. |
|
657 |
|
658 If do_nst is zero, then namespace information is returned in the |
|
659 default manner (URI + sep + local_name) whether or not the name |
|
660 has a prefix. |
|
661 |
|
662 Note: Calling XML_SetReturnNSTriplet after XML_Parse or |
|
663 XML_ParseBuffer has no effect. |
|
664 */ |
|
665 |
|
666 XMLPARSEAPI(void) |
|
667 XML_SetReturnNSTriplet(XML_Parser parser, int do_nst); |
|
668 |
|
669 /* This value is passed as the userData argument to callbacks. */ |
|
670 XMLPARSEAPI(void) |
|
671 XML_SetUserData(XML_Parser parser, void *userData); |
|
672 |
|
673 /* Returns the last value set by XML_SetUserData or NULL. */ |
|
674 #define XML_GetUserData(parser) (*(void **)(parser)) |
|
675 |
|
676 /* This is equivalent to supplying an encoding argument to |
|
677 XML_ParserCreate. On success XML_SetEncoding returns non-zero, |
|
678 zero otherwise. |
|
679 Note: Calling XML_SetEncoding after XML_Parse or XML_ParseBuffer |
|
680 has no effect and returns XML_STATUS_ERROR. |
|
681 */ |
|
682 XMLPARSEAPI(enum XML_Status) |
|
683 XML_SetEncoding(XML_Parser parser, const XML_Char *encoding); |
|
684 |
|
685 /* If this function is called, then the parser will be passed as the |
|
686 first argument to callbacks instead of userData. The userData will |
|
687 still be accessible using XML_GetUserData. |
|
688 */ |
|
689 XMLPARSEAPI(void) |
|
690 XML_UseParserAsHandlerArg(XML_Parser parser); |
|
691 |
|
692 /* If useDTD == XML_TRUE is passed to this function, then the parser |
|
693 will assume that there is an external subset, even if none is |
|
694 specified in the document. In such a case the parser will call the |
|
695 externalEntityRefHandler with a value of NULL for the systemId |
|
696 argument (the publicId and context arguments will be NULL as well). |
|
697 Note: For the purpose of checking WFC: Entity Declared, passing |
|
698 useDTD == XML_TRUE will make the parser behave as if the document |
|
699 had a DTD with an external subset. |
|
700 Note: If this function is called, then this must be done before |
|
701 the first call to XML_Parse or XML_ParseBuffer, since it will |
|
702 have no effect after that. Returns |
|
703 XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING. |
|
704 Note: If the document does not have a DOCTYPE declaration at all, |
|
705 then startDoctypeDeclHandler and endDoctypeDeclHandler will not |
|
706 be called, despite an external subset being parsed. |
|
707 Note: If XML_DTD is not defined when Expat is compiled, returns |
|
708 XML_ERROR_FEATURE_REQUIRES_XML_DTD. |
|
709 */ |
|
710 XMLPARSEAPI(enum XML_Error) |
|
711 XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD); |
|
712 |
|
713 |
|
714 /* Sets the base to be used for resolving relative URIs in system |
|
715 identifiers in declarations. Resolving relative identifiers is |
|
716 left to the application: this value will be passed through as the |
|
717 base argument to the XML_ExternalEntityRefHandler, |
|
718 XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base |
|
719 argument will be copied. Returns XML_STATUS_ERROR if out of memory, |
|
720 XML_STATUS_OK otherwise. |
|
721 */ |
|
722 XMLPARSEAPI(enum XML_Status) |
|
723 XML_SetBase(XML_Parser parser, const XML_Char *base); |
|
724 |
|
725 XMLPARSEAPI(const XML_Char *) |
|
726 XML_GetBase(XML_Parser parser); |
|
727 |
|
728 /* Returns the number of the attribute/value pairs passed in last call |
|
729 to the XML_StartElementHandler that were specified in the start-tag |
|
730 rather than defaulted. Each attribute/value pair counts as 2; thus |
|
731 this correspondds to an index into the atts array passed to the |
|
732 XML_StartElementHandler. |
|
733 */ |
|
734 XMLPARSEAPI(int) |
|
735 XML_GetSpecifiedAttributeCount(XML_Parser parser); |
|
736 |
|
737 /* Returns the index of the ID attribute passed in the last call to |
|
738 XML_StartElementHandler, or -1 if there is no ID attribute. Each |
|
739 attribute/value pair counts as 2; thus this correspondds to an |
|
740 index into the atts array passed to the XML_StartElementHandler. |
|
741 */ |
|
742 XMLPARSEAPI(int) |
|
743 XML_GetIdAttributeIndex(XML_Parser parser); |
|
744 |
|
745 /* Parses some input. Returns XML_STATUS_ERROR if a fatal error is |
|
746 detected. The last call to XML_Parse must have isFinal true; len |
|
747 may be zero for this call (or any other). |
|
748 |
|
749 Though the return values for these functions has always been |
|
750 described as a Boolean value, the implementation, at least for the |
|
751 1.95.x series, has always returned exactly one of the XML_Status |
|
752 values. |
|
753 */ |
|
754 XMLPARSEAPI(enum XML_Status) |
|
755 XML_Parse(XML_Parser parser, const char *s, int len, int isFinal); |
|
756 |
|
757 XMLPARSEAPI(void *) |
|
758 XML_GetBuffer(XML_Parser parser, int len); |
|
759 |
|
760 XMLPARSEAPI(enum XML_Status) |
|
761 XML_ParseBuffer(XML_Parser parser, int len, int isFinal); |
|
762 |
|
763 /* Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return. |
|
764 Must be called from within a call-back handler, except when aborting |
|
765 (resumable = 0) an already suspended parser. Some call-backs may |
|
766 still follow because they would otherwise get lost. Examples: |
|
767 - endElementHandler() for empty elements when stopped in |
|
768 startElementHandler(), |
|
769 - endNameSpaceDeclHandler() when stopped in endElementHandler(), |
|
770 and possibly others. |
|
771 |
|
772 Can be called from most handlers, including DTD related call-backs, |
|
773 except when parsing an external parameter entity and resumable != 0. |
|
774 Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise. |
|
775 Possible error codes: |
|
776 - XML_ERROR_SUSPENDED: when suspending an already suspended parser. |
|
777 - XML_ERROR_FINISHED: when the parser has already finished. |
|
778 - XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE. |
|
779 |
|
780 When resumable != 0 (true) then parsing is suspended, that is, |
|
781 XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED. |
|
782 Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer() |
|
783 return XML_STATUS_ERROR with error code XML_ERROR_ABORTED. |
|
784 |
|
785 *Note*: |
|
786 This will be applied to the current parser instance only, that is, if |
|
787 there is a parent parser then it will continue parsing when the |
|
788 externalEntityRefHandler() returns. It is up to the implementation of |
|
789 the externalEntityRefHandler() to call XML_StopParser() on the parent |
|
790 parser (recursively), if one wants to stop parsing altogether. |
|
791 |
|
792 When suspended, parsing can be resumed by calling XML_ResumeParser(). |
|
793 */ |
|
794 XMLPARSEAPI(enum XML_Status) |
|
795 XML_StopParser(XML_Parser parser, XML_Bool resumable); |
|
796 |
|
797 /* Resumes parsing after it has been suspended with XML_StopParser(). |
|
798 Must not be called from within a handler call-back. Returns same |
|
799 status codes as XML_Parse() or XML_ParseBuffer(). |
|
800 Additional error code XML_ERROR_NOT_SUSPENDED possible. |
|
801 |
|
802 *Note*: |
|
803 This must be called on the most deeply nested child parser instance |
|
804 first, and on its parent parser only after the child parser has finished, |
|
805 to be applied recursively until the document entity's parser is restarted. |
|
806 That is, the parent parser will not resume by itself and it is up to the |
|
807 application to call XML_ResumeParser() on it at the appropriate moment. |
|
808 */ |
|
809 XMLPARSEAPI(enum XML_Status) |
|
810 XML_ResumeParser(XML_Parser parser); |
|
811 |
|
812 enum XML_Parsing { |
|
813 XML_INITIALIZED, |
|
814 XML_PARSING, |
|
815 XML_FINISHED, |
|
816 XML_SUSPENDED |
|
817 }; |
|
818 |
|
819 typedef struct { |
|
820 enum XML_Parsing parsing; |
|
821 XML_Bool finalBuffer; |
|
822 } XML_ParsingStatus; |
|
823 |
|
824 /* Returns status of parser with respect to being initialized, parsing, |
|
825 finished, or suspended and processing the final buffer. |
|
826 XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus, |
|
827 XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED |
|
828 */ |
|
829 XMLPARSEAPI(void) |
|
830 XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status); |
|
831 |
|
832 /* Creates an XML_Parser object that can parse an external general |
|
833 entity; context is a '\0'-terminated string specifying the parse |
|
834 context; encoding is a '\0'-terminated string giving the name of |
|
835 the externally specified encoding, or NULL if there is no |
|
836 externally specified encoding. The context string consists of a |
|
837 sequence of tokens separated by formfeeds (\f); a token consisting |
|
838 of a name specifies that the general entity of the name is open; a |
|
839 token of the form prefix=uri specifies the namespace for a |
|
840 particular prefix; a token of the form =uri specifies the default |
|
841 namespace. This can be called at any point after the first call to |
|
842 an ExternalEntityRefHandler so longer as the parser has not yet |
|
843 been freed. The new parser is completely independent and may |
|
844 safely be used in a separate thread. The handlers and userData are |
|
845 initialized from the parser argument. Returns NULL if out of memory. |
|
846 Otherwise returns a new XML_Parser object. |
|
847 */ |
|
848 XMLPARSEAPI(XML_Parser) |
|
849 XML_ExternalEntityParserCreate(XML_Parser parser, |
|
850 const XML_Char *context, |
|
851 const XML_Char *encoding); |
|
852 |
|
853 enum XML_ParamEntityParsing { |
|
854 XML_PARAM_ENTITY_PARSING_NEVER, |
|
855 XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE, |
|
856 XML_PARAM_ENTITY_PARSING_ALWAYS |
|
857 }; |
|
858 |
|
859 /* Controls parsing of parameter entities (including the external DTD |
|
860 subset). If parsing of parameter entities is enabled, then |
|
861 references to external parameter entities (including the external |
|
862 DTD subset) will be passed to the handler set with |
|
863 XML_SetExternalEntityRefHandler. The context passed will be 0. |
|
864 |
|
865 Unlike external general entities, external parameter entities can |
|
866 only be parsed synchronously. If the external parameter entity is |
|
867 to be parsed, it must be parsed during the call to the external |
|
868 entity ref handler: the complete sequence of |
|
869 XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and |
|
870 XML_ParserFree calls must be made during this call. After |
|
871 XML_ExternalEntityParserCreate has been called to create the parser |
|
872 for the external parameter entity (context must be 0 for this |
|
873 call), it is illegal to make any calls on the old parser until |
|
874 XML_ParserFree has been called on the newly created parser. |
|
875 If the library has been compiled without support for parameter |
|
876 entity parsing (ie without XML_DTD being defined), then |
|
877 XML_SetParamEntityParsing will return 0 if parsing of parameter |
|
878 entities is requested; otherwise it will return non-zero. |
|
879 Note: If XML_SetParamEntityParsing is called after XML_Parse or |
|
880 XML_ParseBuffer, then it has no effect and will always return 0. |
|
881 */ |
|
882 XMLPARSEAPI(int) |
|
883 XML_SetParamEntityParsing(XML_Parser parser, |
|
884 enum XML_ParamEntityParsing parsing); |
|
885 |
|
886 /* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then |
|
887 XML_GetErrorCode returns information about the error. |
|
888 */ |
|
889 XMLPARSEAPI(enum XML_Error) |
|
890 XML_GetErrorCode(XML_Parser parser); |
|
891 |
|
892 /* These functions return information about the current parse |
|
893 location. They may be called from any callback called to report |
|
894 some parse event; in this case the location is the location of the |
|
895 first of the sequence of characters that generated the event. When |
|
896 called from callbacks generated by declarations in the document |
|
897 prologue, the location identified isn't as neatly defined, but will |
|
898 be within the relevant markup. When called outside of the callback |
|
899 functions, the position indicated will be just past the last parse |
|
900 event (regardless of whether there was an associated callback). |
|
901 |
|
902 They may also be called after returning from a call to XML_Parse |
|
903 or XML_ParseBuffer. If the return value is XML_STATUS_ERROR then |
|
904 the location is the location of the character at which the error |
|
905 was detected; otherwise the location is the location of the last |
|
906 parse event, as described above. |
|
907 */ |
|
908 XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser); |
|
909 XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser); |
|
910 XMLPARSEAPI(XML_Index) XML_GetCurrentByteIndex(XML_Parser parser); |
|
911 |
|
912 /* Return the number of bytes in the current event. |
|
913 Returns 0 if the event is in an internal entity. |
|
914 */ |
|
915 XMLPARSEAPI(int) |
|
916 XML_GetCurrentByteCount(XML_Parser parser); |
|
917 |
|
918 /* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets |
|
919 the integer pointed to by offset to the offset within this buffer |
|
920 of the current parse position, and sets the integer pointed to by size |
|
921 to the size of this buffer (the number of input bytes). Otherwise |
|
922 returns a NULL pointer. Also returns a NULL pointer if a parse isn't |
|
923 active. |
|
924 |
|
925 NOTE: The character pointer returned should not be used outside |
|
926 the handler that makes the call. |
|
927 */ |
|
928 XMLPARSEAPI(const char *) |
|
929 XML_GetInputContext(XML_Parser parser, |
|
930 int *offset, |
|
931 int *size); |
|
932 |
|
933 /* For backwards compatibility with previous versions. */ |
|
934 #define XML_GetErrorLineNumber XML_GetCurrentLineNumber |
|
935 #define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber |
|
936 #define XML_GetErrorByteIndex XML_GetCurrentByteIndex |
|
937 |
|
938 /* Frees the content model passed to the element declaration handler */ |
|
939 XMLPARSEAPI(void) |
|
940 XML_FreeContentModel(XML_Parser parser, XML_Content *model); |
|
941 |
|
942 /* Exposing the memory handling functions used in Expat */ |
|
943 XMLPARSEAPI(void *) |
|
944 XML_MemMalloc(XML_Parser parser, size_t size); |
|
945 |
|
946 XMLPARSEAPI(void *) |
|
947 XML_MemRealloc(XML_Parser parser, void *ptr, size_t size); |
|
948 |
|
949 XMLPARSEAPI(void) |
|
950 XML_MemFree(XML_Parser parser, void *ptr); |
|
951 |
|
952 /* Frees memory used by the parser. */ |
|
953 XMLPARSEAPI(void) |
|
954 XML_ParserFree(XML_Parser parser); |
|
955 |
|
956 /* Returns a string describing the error. */ |
|
957 XMLPARSEAPI(const XML_LChar *) |
|
958 XML_ErrorString(enum XML_Error code); |
|
959 |
|
960 /* Return a string containing the version number of this expat */ |
|
961 XMLPARSEAPI(const XML_LChar *) |
|
962 XML_ExpatVersion(void); |
|
963 |
|
964 typedef struct { |
|
965 int major; |
|
966 int minor; |
|
967 int micro; |
|
968 } XML_Expat_Version; |
|
969 |
|
970 /* Return an XML_Expat_Version structure containing numeric version |
|
971 number information for this version of expat. |
|
972 */ |
|
973 XMLPARSEAPI(XML_Expat_Version) |
|
974 XML_ExpatVersionInfo(void); |
|
975 |
|
976 /* Added in Expat 1.95.5. */ |
|
977 enum XML_FeatureEnum { |
|
978 XML_FEATURE_END = 0, |
|
979 XML_FEATURE_UNICODE, |
|
980 XML_FEATURE_UNICODE_WCHAR_T, |
|
981 XML_FEATURE_DTD, |
|
982 XML_FEATURE_CONTEXT_BYTES, |
|
983 XML_FEATURE_MIN_SIZE, |
|
984 XML_FEATURE_SIZEOF_XML_CHAR, |
|
985 XML_FEATURE_SIZEOF_XML_LCHAR, |
|
986 XML_FEATURE_NS, |
|
987 XML_FEATURE_LARGE_SIZE |
|
988 /* Additional features must be added to the end of this enum. */ |
|
989 }; |
|
990 |
|
991 typedef struct { |
|
992 enum XML_FeatureEnum feature; |
|
993 const XML_LChar *name; |
|
994 long int value; |
|
995 } XML_Feature; |
|
996 |
|
997 XMLPARSEAPI(const XML_Feature *) |
|
998 XML_GetFeatureList(void); |
|
999 |
|
1000 |
|
1001 /* Expat follows the GNU/Linux convention of odd number minor version for |
|
1002 beta/development releases and even number minor version for stable |
|
1003 releases. Micro is bumped with each release, and set to 0 with each |
|
1004 change to major or minor version. |
|
1005 */ |
|
1006 #define XML_MAJOR_VERSION 2 |
|
1007 #define XML_MINOR_VERSION 0 |
|
1008 #define XML_MICRO_VERSION 1 |
|
1009 |
|
1010 #ifdef __cplusplus |
|
1011 } |
|
1012 #endif |
|
1013 |
|
1014 #endif /* not Expat_INCLUDED */ |