172
|
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 */
|