2
Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
3
See the file COPYING for copying permission.
6
#ifndef XmlParse_INCLUDED
7
#define XmlParse_INCLUDED 1
12
# if defined(__declspec) && !defined(__CYGWIN__)
13
# define XMLPARSEAPI __declspec(dllimport)
15
# define XMLPARSEAPI /* nothing */
17
#endif /* not defined XMLPARSEAPI */
23
typedef void *XML_Parser;
25
/* Information is UTF-8 encoded. */
26
typedef char XML_Char;
27
typedef char XML_LChar;
29
enum XML_Content_Type {
38
enum XML_Content_Quant {
45
/* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be
46
XML_CQUANT_NONE, and the other fields will be zero or NULL.
47
If type == XML_CTYPE_MIXED, then quant will be NONE or REP and
48
numchildren will contain number of elements that may be mixed in
49
and children point to an array of XML_Content cells that will be
50
all of XML_CTYPE_NAME type with no quantification.
52
If type == XML_CTYPE_NAME, then the name points to the name, and
53
the numchildren field will be zero and children will be NULL. The
54
quant fields indicates any quantifiers placed on the name.
56
CHOICE and SEQ will have name NULL, the number of children in
57
numchildren and children will point, recursively, to an array
60
The EMPTY, ANY, and MIXED types will only occur at top level.
63
typedef struct XML_cp XML_Content;
66
enum XML_Content_Type type;
67
enum XML_Content_Quant quant;
68
const XML_Char * name;
69
unsigned int numchildren;
70
XML_Content * children;
74
/* This is called for an element declaration. See above for
75
description of the model argument. It's the caller's responsibility
76
to free model when finished with it.
79
typedef void (*XML_ElementDeclHandler) (void *userData,
84
XML_SetElementDeclHandler(XML_Parser parser,
85
XML_ElementDeclHandler eldecl);
88
The Attlist declaration handler is called for *each* attribute. So
89
a single Attlist declaration with multiple attributes declared will
90
generate multiple calls to this handler. The "default" parameter
91
may be NULL in the case of the "#IMPLIED" or "#REQUIRED" keyword.
92
The "isrequired" parameter will be true and the default value will
93
be NULL in the case of "#REQUIRED". If "isrequired" is true and
94
default is non-NULL, then this is a "#FIXED" default.
97
typedef void (*XML_AttlistDeclHandler) (void *userData,
98
const XML_Char *elname,
99
const XML_Char *attname,
100
const XML_Char *att_type,
101
const XML_Char *dflt,
105
XML_SetAttlistDeclHandler(XML_Parser parser,
106
XML_AttlistDeclHandler attdecl);
109
/* The XML declaration handler is called for *both* XML declarations and
110
text declarations. The way to distinguish is that the version parameter
111
will be null for text declarations. The encoding parameter may be null
112
for XML declarations. The standalone parameter will be -1, 0, or 1
113
indicating respectively that there was no standalone parameter in
114
the declaration, that it was given as no, or that it was given as yes.
117
typedef void (*XML_XmlDeclHandler) (void *userData,
118
const XML_Char *version,
119
const XML_Char *encoding,
123
XML_SetXmlDeclHandler(XML_Parser parser,
124
XML_XmlDeclHandler xmldecl);
128
void *(*malloc_fcn)(size_t size);
129
void *(*realloc_fcn)(void *ptr, size_t size);
130
void (*free_fcn)(void *ptr);
131
} XML_Memory_Handling_Suite;
133
/* Constructs a new parser; encoding is the encoding specified by the
134
external protocol or null if there is none specified. */
136
XML_Parser XMLPARSEAPI
137
XML_ParserCreate(const XML_Char *encoding);
139
/* Constructs a new parser and namespace processor. Element type
140
names and attribute names that belong to a namespace will be expanded;
141
unprefixed attribute names are never expanded; unprefixed element type
142
names are expanded only if there is a default namespace. The expanded
143
name is the concatenation of the namespace URI, the namespace
144
separator character, and the local part of the name. If the namespace
145
separator is '\0' then the namespace URI and the local part will be
146
concatenated without any separator. When a namespace is not declared,
147
the name and prefix will be passed through without expansion. */
149
XML_Parser XMLPARSEAPI
150
XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
153
/* Constructs a new parser using the memory management suit referred to
154
by memsuite. If memsuite is NULL, then use the standard library memory
155
suite. If namespaceSeparator is non-NULL it creates a parser with
156
namespace processing as described above. The character pointed at
157
will serve as the namespace separator.
159
All further memory operations used for the created parser will come from
163
XML_Parser XMLPARSEAPI
164
XML_ParserCreate_MM(const XML_Char *encoding,
165
const XML_Memory_Handling_Suite *memsuite,
166
const XML_Char *namespaceSeparator);
168
/* atts is array of name/value pairs, terminated by 0;
169
names and values are 0 terminated. */
171
typedef void (*XML_StartElementHandler)(void *userData,
172
const XML_Char *name,
173
const XML_Char **atts);
175
typedef void (*XML_EndElementHandler)(void *userData,
176
const XML_Char *name);
179
/* s is not 0 terminated. */
180
typedef void (*XML_CharacterDataHandler)(void *userData,
184
/* target and data are 0 terminated */
185
typedef void (*XML_ProcessingInstructionHandler)(void *userData,
186
const XML_Char *target,
187
const XML_Char *data);
189
/* data is 0 terminated */
190
typedef void (*XML_CommentHandler)(void *userData, const XML_Char *data);
192
typedef void (*XML_StartCdataSectionHandler)(void *userData);
193
typedef void (*XML_EndCdataSectionHandler)(void *userData);
195
/* This is called for any characters in the XML document for
196
which there is no applicable handler. This includes both
197
characters that are part of markup which is of a kind that is
198
not reported (comments, markup declarations), or characters
199
that are part of a construct which could be reported but
200
for which no handler has been supplied. The characters are passed
201
exactly as they were in the XML document except that
202
they will be encoded in UTF-8. Line boundaries are not normalized.
203
Note that a byte order mark character is not passed to the default handler.
204
There are no guarantees about how characters are divided between calls
205
to the default handler: for example, a comment might be split between
208
typedef void (*XML_DefaultHandler)(void *userData,
212
/* This is called for the start of the DOCTYPE declaration, before
213
any DTD or internal subset is parsed. */
215
typedef void (*XML_StartDoctypeDeclHandler)(void *userData,
216
const XML_Char *doctypeName,
217
const XML_Char *sysid,
218
const XML_Char *pubid,
219
int has_internal_subset
222
/* This is called for the start of the DOCTYPE declaration when the
223
closing > is encountered, but after processing any external subset. */
224
typedef void (*XML_EndDoctypeDeclHandler)(void *userData);
226
/* This is called for entity declarations. The is_parameter_entity
227
argument will be non-zero if the entity is a parameter entity, zero
230
For internal entities (<!ENTITY foo "bar">), value will
231
be non-null and systemId, publicID, and notationName will be null.
232
The value string is NOT null terminated; the length is provided in
233
the value_length argument. Since it is legal to have zero-length
234
values, do not use this argument to test for internal entities.
236
For external entities, value will be null and systemId will be non-null.
237
The publicId argument will be null unless a public identifier was
238
provided. The notationName argument will have a non-null value only
239
for unparsed entity declarations.
242
typedef void (*XML_EntityDeclHandler) (void *userData,
243
const XML_Char *entityName,
244
int is_parameter_entity,
245
const XML_Char *value,
247
const XML_Char *base,
248
const XML_Char *systemId,
249
const XML_Char *publicId,
250
const XML_Char *notationName);
253
XML_SetEntityDeclHandler(XML_Parser parser,
254
XML_EntityDeclHandler handler);
256
/* OBSOLETE -- OBSOLETE -- OBSOLETE
257
This handler has been superceded by the EntityDeclHandler above.
258
It is provided here for backward compatibility.
259
This is called for a declaration of an unparsed (NDATA)
260
entity. The base argument is whatever was set by XML_SetBase.
261
The entityName, systemId and notationName arguments will never be null.
262
The other arguments may be. */
264
typedef void (*XML_UnparsedEntityDeclHandler)(void *userData,
265
const XML_Char *entityName,
266
const XML_Char *base,
267
const XML_Char *systemId,
268
const XML_Char *publicId,
269
const XML_Char *notationName);
271
/* This is called for a declaration of notation.
272
The base argument is whatever was set by XML_SetBase.
273
The notationName will never be null. The other arguments can be. */
275
typedef void (*XML_NotationDeclHandler)(void *userData,
276
const XML_Char *notationName,
277
const XML_Char *base,
278
const XML_Char *systemId,
279
const XML_Char *publicId);
281
/* When namespace processing is enabled, these are called once for
282
each namespace declaration. The call to the start and end element
283
handlers occur between the calls to the start and end namespace
284
declaration handlers. For an xmlns attribute, prefix will be null.
285
For an xmlns="" attribute, uri will be null. */
287
typedef void (*XML_StartNamespaceDeclHandler)(void *userData,
288
const XML_Char *prefix,
289
const XML_Char *uri);
291
typedef void (*XML_EndNamespaceDeclHandler)(void *userData,
292
const XML_Char *prefix);
294
/* This is called if the document is not standalone (it has an
295
external subset or a reference to a parameter entity, but does not
296
have standalone="yes"). If this handler returns 0, then processing
297
will not continue, and the parser will return a
298
XML_ERROR_NOT_STANDALONE error. */
300
typedef int (*XML_NotStandaloneHandler)(void *userData);
302
/* This is called for a reference to an external parsed general entity.
303
The referenced entity is not automatically parsed.
304
The application can parse it immediately or later using
305
XML_ExternalEntityParserCreate.
306
The parser argument is the parser parsing the entity containing the reference;
307
it can be passed as the parser argument to XML_ExternalEntityParserCreate.
308
The systemId argument is the system identifier as specified in the entity
309
declaration; it will not be null.
310
The base argument is the system identifier that should be used as the base for
311
resolving systemId if systemId was relative; this is set by XML_SetBase;
313
The publicId argument is the public identifier as specified in the entity
314
declaration, or null if none was specified; the whitespace in the public
315
identifier will have been normalized as required by the XML spec.
316
The context argument specifies the parsing context in the format
317
expected by the context argument to
318
XML_ExternalEntityParserCreate; context is valid only until the handler
319
returns, so if the referenced entity is to be parsed later, it must be copied.
320
The handler should return 0 if processing should not continue because of
321
a fatal error in the handling of the external entity.
322
In this case the calling parser will return an
323
XML_ERROR_EXTERNAL_ENTITY_HANDLING error.
324
Note that unlike other handlers the first argument is the parser, not
327
typedef int (*XML_ExternalEntityRefHandler)(XML_Parser parser,
328
const XML_Char *context,
329
const XML_Char *base,
330
const XML_Char *systemId,
331
const XML_Char *publicId);
333
/* This structure is filled in by the XML_UnknownEncodingHandler
334
to provide information to the parser about encodings that are unknown
336
The map[b] member gives information about byte sequences
337
whose first byte is b.
338
If map[b] is c where c is >= 0, then b by itself encodes the Unicode scalar
340
If map[b] is -1, then the byte sequence is malformed.
341
If map[b] is -n, where n >= 2, then b is the first byte of an n-byte
342
sequence that encodes a single Unicode scalar value.
343
The data member will be passed as the first argument to the convert function.
344
The convert function is used to convert multibyte sequences;
345
s will point to a n-byte sequence where map[(unsigned char)*s] == -n.
346
The convert function must return the Unicode scalar value
347
represented by this byte sequence or -1 if the byte sequence is malformed.
348
The convert function may be null if the encoding is a single-byte encoding,
349
that is if map[b] >= -1 for all bytes b.
350
When the parser is finished with the encoding, then if release is not null,
351
it will call release passing it the data member;
352
once release has been called, the convert function will not be called again.
354
Expat places certain restrictions on the encodings that are supported
355
using this mechanism.
357
1. Every ASCII character that can appear in a well-formed XML document,
358
other than the characters
362
must be represented by a single byte, and that byte must be the
363
same byte that represents that character in ASCII.
365
2. No character may require more than 4 bytes to encode.
367
3. All characters encoded must have Unicode scalar values <= 0xFFFF,
368
(ie characters that would be encoded by surrogates in UTF-16
369
are not allowed). Note that this restriction doesn't apply to
370
the built-in support for UTF-8 and UTF-16.
372
4. No Unicode character may be encoded by more than one distinct sequence
378
int (*convert)(void *data, const char *s);
379
void (*release)(void *data);
382
/* This is called for an encoding that is unknown to the parser.
383
The encodingHandlerData argument is that which was passed as the
384
second argument to XML_SetUnknownEncodingHandler.
385
The name argument gives the name of the encoding as specified in
386
the encoding declaration.
387
If the callback can provide information about the encoding,
388
it must fill in the XML_Encoding structure, and return 1.
389
Otherwise it must return 0.
390
If info does not describe a suitable encoding,
391
then the parser will return an XML_UNKNOWN_ENCODING error. */
393
typedef int (*XML_UnknownEncodingHandler)(void *encodingHandlerData,
394
const XML_Char *name,
398
XML_SetElementHandler(XML_Parser parser,
399
XML_StartElementHandler start,
400
XML_EndElementHandler end);
403
XML_SetStartElementHandler(XML_Parser, XML_StartElementHandler);
406
XML_SetEndElementHandler(XML_Parser, XML_EndElementHandler);
409
XML_SetCharacterDataHandler(XML_Parser parser,
410
XML_CharacterDataHandler handler);
413
XML_SetProcessingInstructionHandler(XML_Parser parser,
414
XML_ProcessingInstructionHandler handler);
416
XML_SetCommentHandler(XML_Parser parser,
417
XML_CommentHandler handler);
420
XML_SetCdataSectionHandler(XML_Parser parser,
421
XML_StartCdataSectionHandler start,
422
XML_EndCdataSectionHandler end);
425
XML_SetStartCdataSectionHandler(XML_Parser parser,
426
XML_StartCdataSectionHandler start);
429
XML_SetEndCdataSectionHandler(XML_Parser parser,
430
XML_EndCdataSectionHandler end);
432
/* This sets the default handler and also inhibits expansion of
433
internal entities. The entity reference will be passed to the default
437
XML_SetDefaultHandler(XML_Parser parser,
438
XML_DefaultHandler handler);
440
/* This sets the default handler but does not inhibit expansion of
441
internal entities. The entity reference will not be passed to the
445
XML_SetDefaultHandlerExpand(XML_Parser parser,
446
XML_DefaultHandler handler);
449
XML_SetDoctypeDeclHandler(XML_Parser parser,
450
XML_StartDoctypeDeclHandler start,
451
XML_EndDoctypeDeclHandler end);
454
XML_SetStartDoctypeDeclHandler(XML_Parser parser,
455
XML_StartDoctypeDeclHandler start);
458
XML_SetEndDoctypeDeclHandler(XML_Parser parser,
459
XML_EndDoctypeDeclHandler end);
462
XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
463
XML_UnparsedEntityDeclHandler handler);
466
XML_SetNotationDeclHandler(XML_Parser parser,
467
XML_NotationDeclHandler handler);
470
XML_SetNamespaceDeclHandler(XML_Parser parser,
471
XML_StartNamespaceDeclHandler start,
472
XML_EndNamespaceDeclHandler end);
475
XML_SetStartNamespaceDeclHandler(XML_Parser parser,
476
XML_StartNamespaceDeclHandler start);
479
XML_SetEndNamespaceDeclHandler(XML_Parser parser,
480
XML_EndNamespaceDeclHandler end);
483
XML_SetNotStandaloneHandler(XML_Parser parser,
484
XML_NotStandaloneHandler handler);
487
XML_SetExternalEntityRefHandler(XML_Parser parser,
488
XML_ExternalEntityRefHandler handler);
490
/* If a non-null value for arg is specified here, then it will be passed
491
as the first argument to the external entity ref handler instead
492
of the parser object. */
494
XML_SetExternalEntityRefHandlerArg(XML_Parser, void *arg);
497
XML_SetUnknownEncodingHandler(XML_Parser parser,
498
XML_UnknownEncodingHandler handler,
499
void *encodingHandlerData);
501
/* This can be called within a handler for a start element, end element,
502
processing instruction or character data. It causes the corresponding
503
markup to be passed to the default handler. */
505
XML_DefaultCurrent(XML_Parser parser);
507
/* If do_nst is non-zero, and namespace processing is in effect, and
508
a name has a prefix (i.e. an explicit namespace qualifier) then
509
that name is returned as a triplet in a single
510
string separated by the separator character specified when the parser
511
was created: URI + sep + local_name + sep + prefix.
513
If do_nst is zero, then namespace information is returned in the
514
default manner (URI + sep + local_name) whether or not the names
519
XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);
521
/* This value is passed as the userData argument to callbacks. */
523
XML_SetUserData(XML_Parser parser, void *userData);
525
/* Returns the last value set by XML_SetUserData or null. */
526
#define XML_GetUserData(parser) (*(void **)(parser))
528
/* This is equivalent to supplying an encoding argument
529
to XML_ParserCreate. It must not be called after XML_Parse
530
or XML_ParseBuffer. */
533
XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
535
/* If this function is called, then the parser will be passed
536
as the first argument to callbacks instead of userData.
537
The userData will still be accessible using XML_GetUserData. */
540
XML_UseParserAsHandlerArg(XML_Parser parser);
542
/* Sets the base to be used for resolving relative URIs in system
543
identifiers in declarations. Resolving relative identifiers is left
544
to the application: this value will be passed through as the base
545
argument to the XML_ExternalEntityRefHandler, XML_NotationDeclHandler
546
and XML_UnparsedEntityDeclHandler. The base argument will be copied.
547
Returns zero if out of memory, non-zero otherwise. */
550
XML_SetBase(XML_Parser parser, const XML_Char *base);
552
const XML_Char XMLPARSEAPI *
553
XML_GetBase(XML_Parser parser);
555
/* Returns the number of the attribute/value pairs passed in last call
556
to the XML_StartElementHandler that were specified in the start-tag
557
rather than defaulted. Each attribute/value pair counts as 2; thus
558
this correspondds to an index into the atts array passed to the
559
XML_StartElementHandler. */
562
XML_GetSpecifiedAttributeCount(XML_Parser parser);
564
/* Returns the index of the ID attribute passed in the last call to
565
XML_StartElementHandler, or -1 if there is no ID attribute. Each
566
attribute/value pair counts as 2; thus this correspondds to an index
567
into the atts array passed to the XML_StartElementHandler. */
570
XML_GetIdAttributeIndex(XML_Parser parser);
572
/* Parses some input. Returns 0 if a fatal error is detected.
573
The last call to XML_Parse must have isFinal true;
574
len may be zero for this call (or any other). */
576
XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
579
XML_GetBuffer(XML_Parser parser, int len);
582
XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
584
/* Creates an XML_Parser object that can parse an external general
585
entity; context is a '\0'-terminated string specifying the parse
586
context; encoding is a '\0'-terminated string giving the name of the
587
externally specified encoding, or null if there is no externally
588
specified encoding. The context string consists of a sequence of
589
tokens separated by formfeeds (\f); a token consisting of a name
590
specifies that the general entity of the name is open; a token of the
591
form prefix=uri specifies the namespace for a particular prefix; a
592
token of the form =uri specifies the default namespace. This can be
593
called at any point after the first call to an
594
ExternalEntityRefHandler so longer as the parser has not yet been
595
freed. The new parser is completely independent and may safely be
596
used in a separate thread. The handlers and userData are initialized
597
from the parser argument. Returns 0 if out of memory. Otherwise
598
returns a new XML_Parser object. */
599
XML_Parser XMLPARSEAPI
600
XML_ExternalEntityParserCreate(XML_Parser parser,
601
const XML_Char *context,
602
const XML_Char *encoding);
604
enum XML_ParamEntityParsing {
605
XML_PARAM_ENTITY_PARSING_NEVER,
606
XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
607
XML_PARAM_ENTITY_PARSING_ALWAYS
610
/* Controls parsing of parameter entities (including the external DTD
611
subset). If parsing of parameter entities is enabled, then references
612
to external parameter entities (including the external DTD subset)
613
will be passed to the handler set with
614
XML_SetExternalEntityRefHandler. The context passed will be 0.
615
Unlike external general entities, external parameter entities can only
616
be parsed synchronously. If the external parameter entity is to be
617
parsed, it must be parsed during the call to the external entity ref
618
handler: the complete sequence of XML_ExternalEntityParserCreate,
619
XML_Parse/XML_ParseBuffer and XML_ParserFree calls must be made during
620
this call. After XML_ExternalEntityParserCreate has been called to
621
create the parser for the external parameter entity (context must be 0
622
for this call), it is illegal to make any calls on the old parser
623
until XML_ParserFree has been called on the newly created parser. If
624
the library has been compiled without support for parameter entity
625
parsing (ie without XML_DTD being defined), then
626
XML_SetParamEntityParsing will return 0 if parsing of parameter
627
entities is requested; otherwise it will return non-zero. */
630
XML_SetParamEntityParsing(XML_Parser parser,
631
enum XML_ParamEntityParsing parsing);
637
XML_ERROR_NO_ELEMENTS,
638
XML_ERROR_INVALID_TOKEN,
639
XML_ERROR_UNCLOSED_TOKEN,
640
XML_ERROR_PARTIAL_CHAR,
641
XML_ERROR_TAG_MISMATCH,
642
XML_ERROR_DUPLICATE_ATTRIBUTE,
643
XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
644
XML_ERROR_PARAM_ENTITY_REF,
645
XML_ERROR_UNDEFINED_ENTITY,
646
XML_ERROR_RECURSIVE_ENTITY_REF,
647
XML_ERROR_ASYNC_ENTITY,
648
XML_ERROR_BAD_CHAR_REF,
649
XML_ERROR_BINARY_ENTITY_REF,
650
XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
651
XML_ERROR_MISPLACED_XML_PI,
652
XML_ERROR_UNKNOWN_ENCODING,
653
XML_ERROR_INCORRECT_ENCODING,
654
XML_ERROR_UNCLOSED_CDATA_SECTION,
655
XML_ERROR_EXTERNAL_ENTITY_HANDLING,
656
XML_ERROR_NOT_STANDALONE,
657
XML_ERROR_UNEXPECTED_STATE
660
/* If XML_Parse or XML_ParseBuffer have returned 0, then XML_GetErrorCode
661
returns information about the error. */
663
enum XML_Error XMLPARSEAPI
664
XML_GetErrorCode(XML_Parser parser);
666
/* These functions return information about the current parse location.
667
They may be called when XML_Parse or XML_ParseBuffer return 0;
668
in this case the location is the location of the character at which
669
the error was detected.
670
They may also be called from any other callback called to report
671
some parse event; in this the location is the location of the first
672
of the sequence of characters that generated the event. */
674
int XMLPARSEAPI XML_GetCurrentLineNumber(XML_Parser parser);
675
int XMLPARSEAPI XML_GetCurrentColumnNumber(XML_Parser parser);
676
long XMLPARSEAPI XML_GetCurrentByteIndex(XML_Parser parser);
678
/* Return the number of bytes in the current event.
679
Returns 0 if the event is in an internal entity. */
682
XML_GetCurrentByteCount(XML_Parser parser);
684
/* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets
685
the integer pointed to by offset to the offset within this buffer
686
of the current parse position, and sets the integer pointed to by size
687
to the size of this buffer (the number of input bytes). Otherwise
688
returns a null pointer. Also returns a null pointer if a parse isn't
691
NOTE: The character pointer returned should not be used outside
692
the handler that makes the call. */
694
const char XMLPARSEAPI *
695
XML_GetInputContext(XML_Parser parser,
699
/* For backwards compatibility with previous versions. */
700
#define XML_GetErrorLineNumber XML_GetCurrentLineNumber
701
#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
702
#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
704
/* Frees memory used by the parser. */
706
XML_ParserFree(XML_Parser parser);
708
/* Returns a string describing the error. */
709
const XML_LChar XMLPARSEAPI *
710
XML_ErrorString(int code);
712
/* Return a string containing the version number of this expat */
713
const XML_LChar XMLPARSEAPI *
714
XML_ExpatVersion(void);
722
/* Return an XML_Expat_Version structure containing numeric version
723
number information for this version of expat */
725
XML_Expat_Version XMLPARSEAPI
726
XML_ExpatVersionInfo(void);
728
#ifndef XML_MAJOR_VERSION
729
#define XML_MAJOR_VERSION 1
731
#ifndef XML_MINOR_VERSION
732
#define XML_MINOR_VERSION 95
734
#ifndef XML_MICRO_VERSION
735
#define XML_MICRO_VERSION 2
742
#endif /* not XmlParse_INCLUDED */
added
removed
srclib/apr-util/xml/expat/lib/expat.h.in
