Annotation of embedaddon/expat/lib/expat.h, revision 1.1.1.2

1.1       misho       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: 
1.1.1.2 ! misho     745: #ifdef XML_ATTR_INFO
        !           746: /* Source file byte offsets for the start and end of attribute names and values.
        !           747:    The value indices are exclusive of surrounding quotes; thus in a UTF-8 source
        !           748:    file an attribute value of "blah" will yield:
        !           749:    info->valueEnd - info->valueStart = 4 bytes.
        !           750: */
        !           751: typedef struct {
        !           752:   XML_Index  nameStart;  /* Offset to beginning of the attribute name. */
        !           753:   XML_Index  nameEnd;    /* Offset after the attribute name's last byte. */
        !           754:   XML_Index  valueStart; /* Offset to beginning of the attribute value. */
        !           755:   XML_Index  valueEnd;   /* Offset after the attribute value's last byte. */
        !           756: } XML_AttrInfo;
        !           757: 
        !           758: /* Returns an array of XML_AttrInfo structures for the attribute/value pairs
        !           759:    passed in last call to the XML_StartElementHandler that were specified
        !           760:    in the start-tag rather than defaulted. Each attribute/value pair counts
        !           761:    as 1; thus the number of entries in the array is
        !           762:    XML_GetSpecifiedAttributeCount(parser) / 2.
        !           763: */
        !           764: XMLPARSEAPI(const XML_AttrInfo *)
        !           765: XML_GetAttributeInfo(XML_Parser parser);
        !           766: #endif
        !           767: 
1.1       misho     768: /* Parses some input. Returns XML_STATUS_ERROR if a fatal error is
                    769:    detected.  The last call to XML_Parse must have isFinal true; len
                    770:    may be zero for this call (or any other).
                    771: 
                    772:    Though the return values for these functions has always been
                    773:    described as a Boolean value, the implementation, at least for the
                    774:    1.95.x series, has always returned exactly one of the XML_Status
                    775:    values.
                    776: */
                    777: XMLPARSEAPI(enum XML_Status)
                    778: XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
                    779: 
                    780: XMLPARSEAPI(void *)
                    781: XML_GetBuffer(XML_Parser parser, int len);
                    782: 
                    783: XMLPARSEAPI(enum XML_Status)
                    784: XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
                    785: 
                    786: /* Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return.
                    787:    Must be called from within a call-back handler, except when aborting
                    788:    (resumable = 0) an already suspended parser. Some call-backs may
                    789:    still follow because they would otherwise get lost. Examples:
                    790:    - endElementHandler() for empty elements when stopped in
                    791:      startElementHandler(), 
                    792:    - endNameSpaceDeclHandler() when stopped in endElementHandler(), 
                    793:    and possibly others.
                    794: 
                    795:    Can be called from most handlers, including DTD related call-backs,
                    796:    except when parsing an external parameter entity and resumable != 0.
                    797:    Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise.
                    798:    Possible error codes: 
                    799:    - XML_ERROR_SUSPENDED: when suspending an already suspended parser.
                    800:    - XML_ERROR_FINISHED: when the parser has already finished.
                    801:    - XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE.
                    802: 
                    803:    When resumable != 0 (true) then parsing is suspended, that is, 
                    804:    XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED. 
                    805:    Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer()
                    806:    return XML_STATUS_ERROR with error code XML_ERROR_ABORTED.
                    807: 
                    808:    *Note*:
                    809:    This will be applied to the current parser instance only, that is, if
                    810:    there is a parent parser then it will continue parsing when the
                    811:    externalEntityRefHandler() returns. It is up to the implementation of
                    812:    the externalEntityRefHandler() to call XML_StopParser() on the parent
                    813:    parser (recursively), if one wants to stop parsing altogether.
                    814: 
                    815:    When suspended, parsing can be resumed by calling XML_ResumeParser(). 
                    816: */
                    817: XMLPARSEAPI(enum XML_Status)
                    818: XML_StopParser(XML_Parser parser, XML_Bool resumable);
                    819: 
                    820: /* Resumes parsing after it has been suspended with XML_StopParser().
                    821:    Must not be called from within a handler call-back. Returns same
                    822:    status codes as XML_Parse() or XML_ParseBuffer().
                    823:    Additional error code XML_ERROR_NOT_SUSPENDED possible.   
                    824: 
                    825:    *Note*:
                    826:    This must be called on the most deeply nested child parser instance
                    827:    first, and on its parent parser only after the child parser has finished,
                    828:    to be applied recursively until the document entity's parser is restarted.
                    829:    That is, the parent parser will not resume by itself and it is up to the
                    830:    application to call XML_ResumeParser() on it at the appropriate moment.
                    831: */
                    832: XMLPARSEAPI(enum XML_Status)
                    833: XML_ResumeParser(XML_Parser parser);
                    834: 
                    835: enum XML_Parsing {
                    836:   XML_INITIALIZED,
                    837:   XML_PARSING,
                    838:   XML_FINISHED,
                    839:   XML_SUSPENDED
                    840: };
                    841: 
                    842: typedef struct {
                    843:   enum XML_Parsing parsing;
                    844:   XML_Bool finalBuffer;
                    845: } XML_ParsingStatus;
                    846: 
                    847: /* Returns status of parser with respect to being initialized, parsing,
                    848:    finished, or suspended and processing the final buffer.
                    849:    XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus,
                    850:    XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED
                    851: */
                    852: XMLPARSEAPI(void)
                    853: XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);
                    854: 
                    855: /* Creates an XML_Parser object that can parse an external general
                    856:    entity; context is a '\0'-terminated string specifying the parse
                    857:    context; encoding is a '\0'-terminated string giving the name of
                    858:    the externally specified encoding, or NULL if there is no
                    859:    externally specified encoding.  The context string consists of a
                    860:    sequence of tokens separated by formfeeds (\f); a token consisting
                    861:    of a name specifies that the general entity of the name is open; a
                    862:    token of the form prefix=uri specifies the namespace for a
                    863:    particular prefix; a token of the form =uri specifies the default
                    864:    namespace.  This can be called at any point after the first call to
                    865:    an ExternalEntityRefHandler so longer as the parser has not yet
                    866:    been freed.  The new parser is completely independent and may
                    867:    safely be used in a separate thread.  The handlers and userData are
                    868:    initialized from the parser argument.  Returns NULL if out of memory.
                    869:    Otherwise returns a new XML_Parser object.
                    870: */
                    871: XMLPARSEAPI(XML_Parser)
                    872: XML_ExternalEntityParserCreate(XML_Parser parser,
                    873:                                const XML_Char *context,
                    874:                                const XML_Char *encoding);
                    875: 
                    876: enum XML_ParamEntityParsing {
                    877:   XML_PARAM_ENTITY_PARSING_NEVER,
                    878:   XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
                    879:   XML_PARAM_ENTITY_PARSING_ALWAYS
                    880: };
                    881: 
                    882: /* Controls parsing of parameter entities (including the external DTD
                    883:    subset). If parsing of parameter entities is enabled, then
                    884:    references to external parameter entities (including the external
                    885:    DTD subset) will be passed to the handler set with
                    886:    XML_SetExternalEntityRefHandler.  The context passed will be 0.
                    887: 
                    888:    Unlike external general entities, external parameter entities can
                    889:    only be parsed synchronously.  If the external parameter entity is
                    890:    to be parsed, it must be parsed during the call to the external
                    891:    entity ref handler: the complete sequence of
                    892:    XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and
                    893:    XML_ParserFree calls must be made during this call.  After
                    894:    XML_ExternalEntityParserCreate has been called to create the parser
                    895:    for the external parameter entity (context must be 0 for this
                    896:    call), it is illegal to make any calls on the old parser until
                    897:    XML_ParserFree has been called on the newly created parser.
                    898:    If the library has been compiled without support for parameter
                    899:    entity parsing (ie without XML_DTD being defined), then
                    900:    XML_SetParamEntityParsing will return 0 if parsing of parameter
                    901:    entities is requested; otherwise it will return non-zero.
                    902:    Note: If XML_SetParamEntityParsing is called after XML_Parse or
                    903:       XML_ParseBuffer, then it has no effect and will always return 0.
                    904: */
                    905: XMLPARSEAPI(int)
                    906: XML_SetParamEntityParsing(XML_Parser parser,
                    907:                           enum XML_ParamEntityParsing parsing);
                    908: 
1.1.1.2 ! misho     909: /* Sets the hash salt to use for internal hash calculations.
        !           910:    Helps in preventing DoS attacks based on predicting hash
        !           911:    function behavior. This must be called before parsing is started.
        !           912:    Returns 1 if successful, 0 when called after parsing has started.
        !           913: */
        !           914: XMLPARSEAPI(int)
        !           915: XML_SetHashSalt(XML_Parser parser,
        !           916:                 unsigned long hash_salt);
        !           917: 
1.1       misho     918: /* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
                    919:    XML_GetErrorCode returns information about the error.
                    920: */
                    921: XMLPARSEAPI(enum XML_Error)
                    922: XML_GetErrorCode(XML_Parser parser);
                    923: 
                    924: /* These functions return information about the current parse
                    925:    location.  They may be called from any callback called to report
                    926:    some parse event; in this case the location is the location of the
                    927:    first of the sequence of characters that generated the event.  When
                    928:    called from callbacks generated by declarations in the document
                    929:    prologue, the location identified isn't as neatly defined, but will
                    930:    be within the relevant markup.  When called outside of the callback
                    931:    functions, the position indicated will be just past the last parse
                    932:    event (regardless of whether there was an associated callback).
                    933:    
                    934:    They may also be called after returning from a call to XML_Parse
                    935:    or XML_ParseBuffer.  If the return value is XML_STATUS_ERROR then
                    936:    the location is the location of the character at which the error
                    937:    was detected; otherwise the location is the location of the last
                    938:    parse event, as described above.
                    939: */
                    940: XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser);
                    941: XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser);
                    942: XMLPARSEAPI(XML_Index) XML_GetCurrentByteIndex(XML_Parser parser);
                    943: 
                    944: /* Return the number of bytes in the current event.
                    945:    Returns 0 if the event is in an internal entity.
                    946: */
                    947: XMLPARSEAPI(int)
                    948: XML_GetCurrentByteCount(XML_Parser parser);
                    949: 
                    950: /* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets
                    951:    the integer pointed to by offset to the offset within this buffer
                    952:    of the current parse position, and sets the integer pointed to by size
                    953:    to the size of this buffer (the number of input bytes). Otherwise
                    954:    returns a NULL pointer. Also returns a NULL pointer if a parse isn't
                    955:    active.
                    956: 
                    957:    NOTE: The character pointer returned should not be used outside
                    958:    the handler that makes the call.
                    959: */
                    960: XMLPARSEAPI(const char *)
                    961: XML_GetInputContext(XML_Parser parser,
                    962:                     int *offset,
                    963:                     int *size);
                    964: 
                    965: /* For backwards compatibility with previous versions. */
                    966: #define XML_GetErrorLineNumber   XML_GetCurrentLineNumber
                    967: #define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
                    968: #define XML_GetErrorByteIndex    XML_GetCurrentByteIndex
                    969: 
                    970: /* Frees the content model passed to the element declaration handler */
                    971: XMLPARSEAPI(void)
                    972: XML_FreeContentModel(XML_Parser parser, XML_Content *model);
                    973: 
                    974: /* Exposing the memory handling functions used in Expat */
                    975: XMLPARSEAPI(void *)
                    976: XML_MemMalloc(XML_Parser parser, size_t size);
                    977: 
                    978: XMLPARSEAPI(void *)
                    979: XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);
                    980: 
                    981: XMLPARSEAPI(void)
                    982: XML_MemFree(XML_Parser parser, void *ptr);
                    983: 
                    984: /* Frees memory used by the parser. */
                    985: XMLPARSEAPI(void)
                    986: XML_ParserFree(XML_Parser parser);
                    987: 
                    988: /* Returns a string describing the error. */
                    989: XMLPARSEAPI(const XML_LChar *)
                    990: XML_ErrorString(enum XML_Error code);
                    991: 
                    992: /* Return a string containing the version number of this expat */
                    993: XMLPARSEAPI(const XML_LChar *)
                    994: XML_ExpatVersion(void);
                    995: 
                    996: typedef struct {
                    997:   int major;
                    998:   int minor;
                    999:   int micro;
                   1000: } XML_Expat_Version;
                   1001: 
                   1002: /* Return an XML_Expat_Version structure containing numeric version
                   1003:    number information for this version of expat.
                   1004: */
                   1005: XMLPARSEAPI(XML_Expat_Version)
                   1006: XML_ExpatVersionInfo(void);
                   1007: 
                   1008: /* Added in Expat 1.95.5. */
                   1009: enum XML_FeatureEnum {
                   1010:   XML_FEATURE_END = 0,
                   1011:   XML_FEATURE_UNICODE,
                   1012:   XML_FEATURE_UNICODE_WCHAR_T,
                   1013:   XML_FEATURE_DTD,
                   1014:   XML_FEATURE_CONTEXT_BYTES,
                   1015:   XML_FEATURE_MIN_SIZE,
                   1016:   XML_FEATURE_SIZEOF_XML_CHAR,
                   1017:   XML_FEATURE_SIZEOF_XML_LCHAR,
                   1018:   XML_FEATURE_NS,
1.1.1.2 ! misho    1019:   XML_FEATURE_LARGE_SIZE,
        !          1020:   XML_FEATURE_ATTR_INFO
1.1       misho    1021:   /* Additional features must be added to the end of this enum. */
                   1022: };
                   1023: 
                   1024: typedef struct {
                   1025:   enum XML_FeatureEnum  feature;
                   1026:   const XML_LChar       *name;
                   1027:   long int              value;
                   1028: } XML_Feature;
                   1029: 
                   1030: XMLPARSEAPI(const XML_Feature *)
                   1031: XML_GetFeatureList(void);
                   1032: 
                   1033: 
                   1034: /* Expat follows the GNU/Linux convention of odd number minor version for
                   1035:    beta/development releases and even number minor version for stable
                   1036:    releases. Micro is bumped with each release, and set to 0 with each
                   1037:    change to major or minor version.
                   1038: */
                   1039: #define XML_MAJOR_VERSION 2
1.1.1.2 ! misho    1040: #define XML_MINOR_VERSION 1
        !          1041: #define XML_MICRO_VERSION 0
1.1       misho    1042: 
                   1043: #ifdef __cplusplus
                   1044: }
                   1045: #endif
                   1046: 
                   1047: #endif /* not Expat_INCLUDED */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>