Utilities/cmexpat/expat.h

   1 #include "cm_expat_mangle.h"
   2 /*
   3 Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
   4 See the file COPYING for copying permission.
   5 */
   6
   7 #ifndef XmlParse_INCLUDED
   8 #define XmlParse_INCLUDED 1
   9
  10 #include <stdlib.h>
  11
  12 #include <cmexpat/expatDllConfig.h>
  13
  14 #if defined(_WIN32) && !defined(CM_EXPAT_STATIC)
  15 #  if defined(cmexpat_EXPORTS)
  16 #    define XMLPARSEAPI(type) __declspec( dllexport ) type __cdecl
  17 #  else
  18 #    define XMLPARSEAPI(type) __declspec( dllimport ) type __cdecl
  19 #  endif
  20 #else
  21 #  define XMLPARSEAPI(type) type
  22 #endif
  23
  24 #ifdef __cplusplus
  25 extern "C" {
  26 #endif
  27
  28 typedef void *XML_Parser;
  29
  30 /* Information is UTF-8 encoded. */
  31 typedef char XML_Char;
  32 typedef char XML_LChar;
  33
  34 enum XML_Content_Type {
  35   XML_CTYPE_EMPTY = 1,
  36   XML_CTYPE_ANY,
  37   XML_CTYPE_MIXED,
  38   XML_CTYPE_NAME,
  39   XML_CTYPE_CHOICE,
  40   XML_CTYPE_SEQ
  41 };
  42
  43 enum XML_Content_Quant {
  44   XML_CQUANT_NONE,
  45   XML_CQUANT_OPT,
  46   XML_CQUANT_REP,
  47   XML_CQUANT_PLUS
  48 };
  49
  50 /* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be
  51    XML_CQUANT_NONE, and the other fields will be zero or NULL.
  52    If type == XML_CTYPE_MIXED, then quant will be NONE or REP and
  53    numchildren will contain number of elements that may be mixed in
  54    and children point to an array of XML_Content cells that will be
  55    all of XML_CTYPE_NAME type with no quantification.
  56
  57    If type == XML_CTYPE_NAME, then the name points to the name, and
  58    the numchildren field will be zero and children will be NULL. The
  59    quant fields indicates any quantifiers placed on the name.
  60
  61    CHOICE and SEQ will have name NULL, the number of children in
  62    numchildren and children will point, recursively, to an array
  63    of XML_Content cells.
  64
  65    The EMPTY, ANY, and MIXED types will only occur at top level.
  66 */
  67
  68 typedef struct XML_cp XML_Content;
  69
  70 struct XML_cp {
  71   enum XML_Content_Type         type;
  72   enum XML_Content_Quant        quant;
  73   XML_Char *                    name;
  74   unsigned int                  numchildren;
  75   XML_Content *                 children;
  76 };
  77
  78
  79 /* This is called for an element declaration. See above for
  80    description of the model argument. It's the caller's responsibility
  81    to free model when finished with it.
  82 */
  83
  84 typedef void (*XML_ElementDeclHandler) (void *userData,
  85                                         const XML_Char *name,
  86                                         XML_Content *model);
  87
  88 XMLPARSEAPI(void)
  89 XML_SetElementDeclHandler(XML_Parser parser,
  90                           XML_ElementDeclHandler eldecl);
  91
  92 /*
  93   The Attlist declaration handler is called for *each* attribute. So
  94   a single Attlist declaration with multiple attributes declared will
  95   generate multiple calls to this handler. The "default" parameter
  96   may be NULL in the case of the "#IMPLIED" or "#REQUIRED" keyword.
  97   The "isrequired" parameter will be true and the default value will
  98   be NULL in the case of "#REQUIRED". If "isrequired" is true and
  99   default is non-NULL, then this is a "#FIXED" default.
 100  */
 101
 102 typedef void (*XML_AttlistDeclHandler) (void           *userData,
 103                                         const XML_Char *elname,
 104                                         const XML_Char *attname,
 105                                         const XML_Char *att_type,
 106                                         const XML_Char *dflt,
 107                                         int             isrequired);
 108
 109 XMLPARSEAPI(void)
 110 XML_SetAttlistDeclHandler(XML_Parser parser,
 111                           XML_AttlistDeclHandler attdecl);
 112
 113
 114   /* The XML declaration handler is called for *both* XML declarations and
 115      text declarations. The way to distinguish is that the version parameter
 116      will be null for text declarations. The encoding parameter may be null
 117      for XML declarations. The standalone parameter will be -1, 0, or 1
 118      indicating respectively that there was no standalone parameter in
 119      the declaration, that it was given as no, or that it was given as yes.
 120   */
 121
 122 typedef void (*XML_XmlDeclHandler) (void                *userData,
 123                                     const XML_Char      *version,
 124                                     const XML_Char      *encoding,
 125                                     int                  standalone);
 126
 127 XMLPARSEAPI(void)
 128 XML_SetXmlDeclHandler(XML_Parser parser,
 129                       XML_XmlDeclHandler xmldecl);
 130
 131
 132 typedef struct {
 133   void *(*malloc_fcn)(size_t size);
 134   void *(*realloc_fcn)(void *ptr, size_t size);
 135   void (*free_fcn)(void *ptr);
 136 } XML_Memory_Handling_Suite;
 137
 138 /* Constructs a new parser; encoding is the encoding specified by the
 139 external protocol or null if there is none specified. */
 140
 141 XMLPARSEAPI(XML_Parser)
 142 XML_ParserCreate(const XML_Char *encoding);
 143
 144 /* Constructs a new parser and namespace processor.  Element type
 145 names and attribute names that belong to a namespace will be expanded;
 146 unprefixed attribute names are never expanded; unprefixed element type
 147 names are expanded only if there is a default namespace. The expanded
 148 name is the concatenation of the namespace URI, the namespace
 149 separator character, and the local part of the name.  If the namespace
 150 separator is '\0' then the namespace URI and the local part will be
 151 concatenated without any separator.  When a namespace is not declared,
 152 the name and prefix will be passed through without expansion. */
 153
 154 XMLPARSEAPI(XML_Parser)
 155 XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
 156
 157
 158 /* Constructs a new parser using the memory management suit referred to
 159    by memsuite. If memsuite is NULL, then use the standard library memory
 160    suite. If namespaceSeparator is non-NULL it creates a parser with
 161    namespace processing as described above. The character pointed at
 162    will serve as the namespace separator.
 163
 164    All further memory operations used for the created parser will come from
 165    the given suite.
 166 */
 167
 168 XMLPARSEAPI(XML_Parser)
 169 XML_ParserCreate_MM(const XML_Char *encoding,
 170                     const XML_Memory_Handling_Suite *memsuite,
 171                     const XML_Char *namespaceSeparator);
 172
 173 /* atts is array of name/value pairs, terminated by 0;
 174    names and values are 0 terminated. */
 175
 176 typedef void (*XML_StartElementHandler)(void *userData,
 177                                         const XML_Char *name,
 178                                         const XML_Char **atts);
 179
 180 typedef void (*XML_EndElementHandler)(void *userData,
 181                                       const XML_Char *name);
 182
 183
 184 /* s is not 0 terminated. */
 185 typedef void (*XML_CharacterDataHandler)(void *userData,
 186                                          const XML_Char *s,
 187                                          int len);
 188
 189 /* target and data are 0 terminated */
 190 typedef void (*XML_ProcessingInstructionHandler)(void *userData,
 191                                                  const XML_Char *target,
 192                                                  const XML_Char *data);
 193
 194 /* data is 0 terminated */
 195 typedef void (*XML_CommentHandler)(void *userData, const XML_Char *data);
 196
 197 typedef void (*XML_StartCdataSectionHandler)(void *userData);
 198 typedef void (*XML_EndCdataSectionHandler)(void *userData);
 199
 200 /* This is called for any characters in the XML document for
 201 which there is no applicable handler.  This includes both
 202 characters that are part of markup which is of a kind that is
 203 not reported (comments, markup declarations), or characters
 204 that are part of a construct which could be reported but
 205 for which no handler has been supplied. The characters are passed
 206 exactly as they were in the XML document except that
 207 they will be encoded in UTF-8.  Line boundaries are not normalized.
 208 Note that a byte order mark character is not passed to the default handler.
 209 There are no guarantees about how characters are divided between calls
 210 to the default handler: for example, a comment might be split between
 211 multiple calls. */
 212
 213 typedef void (*XML_DefaultHandler)(void *userData,
 214                                    const XML_Char *s,
 215                                    int len);
 216
 217 /* This is called for the start of the DOCTYPE declaration, before
 218    any DTD or internal subset is parsed. */
 219
 220 typedef void (*XML_StartDoctypeDeclHandler)(void *userData,
 221                                             const XML_Char *doctypeName,
 222                                             const XML_Char *sysid,
 223                                             const XML_Char *pubid,
 224                                             int has_internal_subset);
 225
 226 /* This is called for the start of the DOCTYPE declaration when the
 227 closing > is encountered, but after processing any external subset. */
 228 typedef void (*XML_EndDoctypeDeclHandler)(void *userData);
 229
 230 /* This is called for entity declarations. The is_parameter_entity
 231    argument will be non-zero if the entity is a parameter entity, zero
 232    otherwise.
 233
 234    For internal entities (<!ENTITY foo "bar">), value will
 235    be non-null and systemId, publicID, and notationName will be null.
 236    The value string is NOT null terminated; the length is provided in
 237    the value_length argument. Since it is legal to have zero-length
 238    values, do not use this argument to test for internal entities.
 239
 240    For external entities, value will be null and systemId will be non-null.
 241    The publicId argument will be null unless a public identifier was
 242    provided. The notationName argument will have a non-null value only
 243    for unparsed entity declarations.
 244 */
 245
 246 typedef void (*XML_EntityDeclHandler) (void *userData,
 247                                        const XML_Char *entityName,
 248                                        int is_parameter_entity,
 249                                        const XML_Char *value,
 250                                        int value_length,
 251                                        const XML_Char *base,
 252                                        const XML_Char *systemId,
 253                                        const XML_Char *publicId,
 254                                        const XML_Char *notationName);
 255
 256 XMLPARSEAPI(void)
 257 XML_SetEntityDeclHandler(XML_Parser parser,
 258                          XML_EntityDeclHandler handler);
 259
 260 /* OBSOLETE -- OBSOLETE -- OBSOLETE
 261    This handler has been superceded by the EntityDeclHandler above.
 262    It is provided here for backward compatibility.
 263 This is called for a declaration of an unparsed (NDATA)
 264 entity.  The base argument is whatever was set by XML_SetBase.
 265 The entityName, systemId and notationName arguments will never be null.
 266 The other arguments may be. */
 267
 268 typedef void (*XML_UnparsedEntityDeclHandler)(void *userData,
 269                                               const XML_Char *entityName,
 270                                               const XML_Char *base,
 271                                               const XML_Char *systemId,
 272                                               const XML_Char *publicId,
 273                                               const XML_Char *notationName);
 274
 275 /* This is called for a declaration of notation.
 276 The base argument is whatever was set by XML_SetBase.
 277 The notationName will never be null.  The other arguments can be. */
 278
 279 typedef void (*XML_NotationDeclHandler)(void *userData,
 280                                         const XML_Char *notationName,
 281                                         const XML_Char *base,
 282                                         const XML_Char *systemId,
 283                                         const XML_Char *publicId);
 284
 285 /* When namespace processing is enabled, these are called once for
 286 each namespace declaration. The call to the start and end element
 287 handlers occur between the calls to the start and end namespace
 288 declaration handlers. For an xmlns attribute, prefix will be null.
 289 For an xmlns="" attribute, uri will be null. */
 290
 291 typedef void (*XML_StartNamespaceDeclHandler)(void *userData,
 292                                               const XML_Char *prefix,
 293                                               const XML_Char *uri);
 294
 295 typedef void (*XML_EndNamespaceDeclHandler)(void *userData,
 296                                             const XML_Char *prefix);
 297
 298 /* This is called if the document is not standalone (it has an
 299 external subset or a reference to a parameter entity, but does not
 300 have standalone="yes"). If this handler returns 0, then processing
 301 will not continue, and the parser will return a
 302 XML_ERROR_NOT_STANDALONE error. */
 303
 304 typedef int (*XML_NotStandaloneHandler)(void *userData);
 305
 306 /* This is called for a reference to an external parsed general entity.
 307 The referenced entity is not automatically parsed.
 308 The application can parse it immediately or later using
 309 XML_ExternalEntityParserCreate.
 310 The parser argument is the parser parsing the entity containing the reference;
 311 it can be passed as the parser argument to XML_ExternalEntityParserCreate.
 312 The systemId argument is the system identifier as specified in the entity
 313 declaration; it will not be null.
 314 The base argument is the system identifier that should be used as the base for
 315 resolving systemId if systemId was relative; this is set by XML_SetBase;
 316 it may be null.
 317 The publicId argument is the public identifier as specified in the entity
 318 declaration, or null if none was specified; the whitespace in the public
 319 identifier will have been normalized as required by the XML spec.
 320 The context argument specifies the parsing context in the format
 321 expected by the context argument to
 322 XML_ExternalEntityParserCreate; context is valid only until the handler
 323 returns, so if the referenced entity is to be parsed later, it must be copied.
 324 The handler should return 0 if processing should not continue because of
 325 a fatal error in the handling of the external entity.
 326 In this case the calling parser will return an
 327 XML_ERROR_EXTERNAL_ENTITY_HANDLING error.
 328 Note that unlike other handlers the first argument is the parser, not
 329 userData. */
 330
 331 typedef int (*XML_ExternalEntityRefHandler)(XML_Parser parser,
 332                                             const XML_Char *context,
 333                                             const XML_Char *base,
 334                                             const XML_Char *systemId,
 335                                             const XML_Char *publicId);
 336
 337 /* This structure is filled in by the XML_UnknownEncodingHandler
 338 to provide information to the parser about encodings that are unknown
 339 to the parser.
 340 The map[b] member gives information about byte sequences
 341 whose first byte is b.
 342 If map[b] is c where c is >= 0, then b by itself encodes the Unicode scalar
 343 value c.
 344 If map[b] is -1, then the byte sequence is malformed.
 345 If map[b] is -n, where n >= 2, then b is the first byte of an n-byte
 346 sequence that encodes a single Unicode scalar value.
 347 The data member will be passed as the first argument to the convert function.
 348 The convert function is used to convert multibyte sequences;
 349 s will point to a n-byte sequence where map[(unsigned char)*s] == -n.
 350 The convert function must return the Unicode scalar value
 351 represented by this byte sequence or -1 if the byte sequence is malformed.
 352 The convert function may be null if the encoding is a single-byte encoding,
 353 that is if map[b] >= -1 for all bytes b.
 354 When the parser is finished with the encoding, then if release is not null,
 355 it will call release passing it the data member;
 356 once release has been called, the convert function will not be called again.
 357
 358 Expat places certain restrictions on the encodings that are supported
 359 using this mechanism.
 360
 361 1. Every ASCII character that can appear in a well-formed XML document,
 362 other than the characters
 363
 364   $@\^`{}~
 365
 366 must be represented by a single byte, and that byte must be the
 367 same byte that represents that character in ASCII.
 368
 369 2. No character may require more than 4 bytes to encode.
 370
 371 3. All characters encoded must have Unicode scalar values <= 0xFFFF, (i.e.,
 372 characters that would be encoded by surrogates in UTF-16 are  not
 373 allowed).  Note that this restriction doesn't apply to the built-in
 374 support for UTF-8 and UTF-16.
 375
 376 4. No Unicode character may be encoded by more than one distinct sequence
 377 of bytes. */
 378
 379 typedef struct {
 380   int map[256];
 381   void *data;
 382   int (*convert)(void *data, const char *s);
 383   void (*release)(void *data);
 384 } XML_Encoding;
 385
 386 /* This is called for an encoding that is unknown to the parser.
 387 The encodingHandlerData argument is that which was passed as the
 388 second argument to XML_SetUnknownEncodingHandler.
 389 The name argument gives the name of the encoding as specified in
 390 the encoding declaration.
 391 If the callback can provide information about the encoding,
 392 it must fill in the XML_Encoding structure, and return 1.
 393 Otherwise it must return 0.
 394 If info does not describe a suitable encoding,
 395 then the parser will return an XML_UNKNOWN_ENCODING error. */
 396
 397 typedef int (*XML_UnknownEncodingHandler)(void *encodingHandlerData,
 398                                           const XML_Char *name,
 399                                           XML_Encoding *info);
 400
 401 XMLPARSEAPI(void)
 402 XML_SetElementHandler(XML_Parser parser,
 403                       XML_StartElementHandler start,
 404                       XML_EndElementHandler end);
 405
 406 XMLPARSEAPI(void)
 407 XML_SetStartElementHandler(XML_Parser, XML_StartElementHandler);
 408
 409 XMLPARSEAPI(void)
 410 XML_SetEndElementHandler(XML_Parser, XML_EndElementHandler);
 411
 412 XMLPARSEAPI(void)
 413 XML_SetCharacterDataHandler(XML_Parser parser,
 414                             XML_CharacterDataHandler handler);
 415
 416 XMLPARSEAPI(void)
 417 XML_SetProcessingInstructionHandler(XML_Parser parser,
 418                                     XML_ProcessingInstructionHandler handler);
 419 XMLPARSEAPI(void)
 420 XML_SetCommentHandler(XML_Parser parser,
 421                       XML_CommentHandler handler);
 422
 423 XMLPARSEAPI(void)
 424 XML_SetCdataSectionHandler(XML_Parser parser,
 425                            XML_StartCdataSectionHandler start,
 426                            XML_EndCdataSectionHandler end);
 427
 428 XMLPARSEAPI(void)
 429 XML_SetStartCdataSectionHandler(XML_Parser parser,
 430                                 XML_StartCdataSectionHandler start);
 431
 432 XMLPARSEAPI(void)
 433 XML_SetEndCdataSectionHandler(XML_Parser parser,
 434                               XML_EndCdataSectionHandler end);
 435
 436 /* This sets the default handler and also inhibits expansion of
 437 internal entities.  The entity reference will be passed to the default
 438 handler. */
 439
 440 XMLPARSEAPI(void)
 441 XML_SetDefaultHandler(XML_Parser parser,
 442                       XML_DefaultHandler handler);
 443
 444 /* This sets the default handler but does not inhibit expansion of
 445 internal entities.  The entity reference will not be passed to the
 446 default handler. */
 447
 448 XMLPARSEAPI(void)
 449 XML_SetDefaultHandlerExpand(XML_Parser parser,
 450                             XML_DefaultHandler handler);
 451
 452 XMLPARSEAPI(void)
 453 XML_SetDoctypeDeclHandler(XML_Parser parser,
 454                           XML_StartDoctypeDeclHandler start,
 455                           XML_EndDoctypeDeclHandler end);
 456
 457 XMLPARSEAPI(void)
 458 XML_SetStartDoctypeDeclHandler(XML_Parser parser,
 459                                XML_StartDoctypeDeclHandler start);
 460
 461 XMLPARSEAPI(void)
 462 XML_SetEndDoctypeDeclHandler(XML_Parser parser,
 463                              XML_EndDoctypeDeclHandler end);
 464
 465 XMLPARSEAPI(void)
 466 XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
 467                                  XML_UnparsedEntityDeclHandler handler);
 468
 469 XMLPARSEAPI(void)
 470 XML_SetNotationDeclHandler(XML_Parser parser,
 471                            XML_NotationDeclHandler handler);
 472
 473 XMLPARSEAPI(void)
 474 XML_SetNamespaceDeclHandler(XML_Parser parser,
 475                             XML_StartNamespaceDeclHandler start,
 476                             XML_EndNamespaceDeclHandler end);
 477
 478 XMLPARSEAPI(void)
 479 XML_SetStartNamespaceDeclHandler(XML_Parser parser,
 480                                  XML_StartNamespaceDeclHandler start);
 481
 482 XMLPARSEAPI(void)
 483 XML_SetEndNamespaceDeclHandler(XML_Parser parser,
 484                                XML_EndNamespaceDeclHandler end);
 485
 486 XMLPARSEAPI(void)
 487 XML_SetNotStandaloneHandler(XML_Parser parser,
 488                             XML_NotStandaloneHandler handler);
 489
 490 XMLPARSEAPI(void)
 491 XML_SetExternalEntityRefHandler(XML_Parser parser,
 492                                 XML_ExternalEntityRefHandler handler);
 493
 494 /* If a non-null value for arg is specified here, then it will be passed
 495 as the first argument to the external entity ref handler instead
 496 of the parser object. */
 497 XMLPARSEAPI(void)
 498 XML_SetExternalEntityRefHandlerArg(XML_Parser, void *arg);
 499
 500 XMLPARSEAPI(void)
 501 XML_SetUnknownEncodingHandler(XML_Parser parser,
 502                               XML_UnknownEncodingHandler handler,
 503                               void *encodingHandlerData);
 504
 505 /* This can be called within a handler for a start element, end element,
 506 processing instruction or character data.  It causes the corresponding
 507 markup to be passed to the default handler. */
 508 XMLPARSEAPI(void)
 509 XML_DefaultCurrent(XML_Parser parser);
 510
 511 /* If do_nst is non-zero, and namespace processing is in effect, and
 512    a name has a prefix (i.e. an explicit namespace qualifier) then
 513    that name is returned as a triplet in a single
 514    string separated by the separator character specified when the parser
 515    was created: URI + sep + local_name + sep + prefix.
 516
 517    If do_nst is zero, then namespace information is returned in the
 518    default manner (URI + sep + local_name) whether or not the names
 519    has a prefix.
 520 */
 521
 522 XMLPARSEAPI(void)
 523 XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);
 524
 525 /* This value is passed as the userData argument to callbacks. */
 526 XMLPARSEAPI(void)
 527 XML_SetUserData(XML_Parser parser, void *userData);
 528
 529 /* Returns the last value set by XML_SetUserData or null. */
 530 #define XML_GetUserData(parser) (*(void **)(parser))
 531
 532 /* This is equivalent to supplying an encoding argument
 533 to XML_ParserCreate. It must not be called after XML_Parse
 534 or XML_ParseBuffer. */
 535
 536 XMLPARSEAPI(int)
 537 XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
 538
 539 /* If this function is called, then the parser will be passed
 540 as the first argument to callbacks instead of userData.
 541 The userData will still be accessible using XML_GetUserData. */
 542
 543 XMLPARSEAPI(void)
 544 XML_UseParserAsHandlerArg(XML_Parser parser);
 545
 546 /* Sets the base to be used for resolving relative URIs in system
 547 identifiers in declarations.  Resolving relative identifiers is left
 548 to the application: this value will be passed through as the base
 549 argument to the XML_ExternalEntityRefHandler, XML_NotationDeclHandler
 550 and XML_UnparsedEntityDeclHandler. The base argument will be copied.
 551 Returns zero if out of memory, non-zero otherwise. */
 552
 553 XMLPARSEAPI(int)
 554 XML_SetBase(XML_Parser parser, const XML_Char *base);
 555
 556 XMLPARSEAPI(const XML_Char *)
 557 XML_GetBase(XML_Parser parser);
 558
 559 /* Returns the number of the attribute/value pairs passed in last call
 560 to the XML_StartElementHandler that were specified in the start-tag
 561 rather than defaulted. Each attribute/value pair counts as 2; thus
 562 this correspondds to an index into the atts array passed to the
 563 XML_StartElementHandler. */
 564
 565 XMLPARSEAPI(int)
 566 XML_GetSpecifiedAttributeCount(XML_Parser parser);
 567
 568 /* Returns the index of the ID attribute passed in the last call to
 569 XML_StartElementHandler, or -1 if there is no ID attribute.  Each
 570 attribute/value pair counts as 2; thus this correspondds to an index
 571 into the atts array passed to the XML_StartElementHandler. */
 572
 573 XMLPARSEAPI(int)
 574 XML_GetIdAttributeIndex(XML_Parser parser);
 575
 576 /* Parses some input. Returns 0 if a fatal error is detected.
 577 The last call to XML_Parse must have isFinal true;
 578 len may be zero for this call (or any other). */
 579 XMLPARSEAPI(int)
 580 XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
 581
 582 XMLPARSEAPI(void *)
 583 XML_GetBuffer(XML_Parser parser, int len);
 584
 585 XMLPARSEAPI(int)
 586 XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
 587
 588 /* Creates an XML_Parser object that can parse an external general
 589 entity; context is a '\0'-terminated string specifying the parse
 590 context; encoding is a '\0'-terminated string giving the name of the
 591 externally specified encoding, or null if there is no externally
 592 specified encoding.  The context string consists of a sequence of
 593 tokens separated by formfeeds (\f); a token consisting of a name
 594 specifies that the general entity of the name is open; a token of the
 595 form prefix=uri specifies the namespace for a particular prefix; a
 596 token of the form =uri specifies the default namespace.  This can be
 597 called at any point after the first call to an
 598 ExternalEntityRefHandler so longer as the parser has not yet been
 599 freed.  The new parser is completely independent and may safely be
 600 used in a separate thread.  The handlers and userData are initialized
 601 from the parser argument.  Returns 0 if out of memory.  Otherwise
 602 returns a new XML_Parser object. */
 603 XMLPARSEAPI(XML_Parser)
 604 XML_ExternalEntityParserCreate(XML_Parser parser,
 605                                const XML_Char *context,
 606                                const XML_Char *encoding);
 607
 608 enum XML_ParamEntityParsing {
 609   XML_PARAM_ENTITY_PARSING_NEVER,
 610   XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
 611   XML_PARAM_ENTITY_PARSING_ALWAYS
 612 };
 613
 614 /* Controls parsing of parameter entities (including the external DTD
 615 subset). If parsing of parameter entities is enabled, then references
 616 to external parameter entities (including the external DTD subset)
 617 will be passed to the handler set with
 618 XML_SetExternalEntityRefHandler.  The context passed will be 0.
 619 Unlike external general entities, external parameter entities can only
 620 be parsed synchronously.  If the external parameter entity is to be
 621 parsed, it must be parsed during the call to the external entity ref
 622 handler: the complete sequence of XML_ExternalEntityParserCreate,
 623 XML_Parse/XML_ParseBuffer and XML_ParserFree calls must be made during
 624 this call.  After XML_ExternalEntityParserCreate has been called to
 625 create the parser for the external parameter entity (context must be 0
 626 for this call), it is illegal to make any calls on the old parser
 627 until XML_ParserFree has been called on the newly created parser.  If
 628 the library has been compiled without support for parameter entity
 629 parsing (ie without XML_DTD being defined), then
 630 XML_SetParamEntityParsing will return 0 if parsing of parameter
 631 entities is requested; otherwise it will return non-zero. */
 632
 633 XMLPARSEAPI(int)
 634 XML_SetParamEntityParsing(XML_Parser parser,
 635                           enum XML_ParamEntityParsing parsing);
 636
 637 enum XML_Error {
 638   XML_ERROR_NONE,
 639   XML_ERROR_NO_MEMORY,
 640   XML_ERROR_SYNTAX,
 641   XML_ERROR_NO_ELEMENTS,
 642   XML_ERROR_INVALID_TOKEN,
 643   XML_ERROR_UNCLOSED_TOKEN,
 644   XML_ERROR_PARTIAL_CHAR,
 645   XML_ERROR_TAG_MISMATCH,
 646   XML_ERROR_DUPLICATE_ATTRIBUTE,
 647   XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
 648   XML_ERROR_PARAM_ENTITY_REF,
 649   XML_ERROR_UNDEFINED_ENTITY,
 650   XML_ERROR_RECURSIVE_ENTITY_REF,
 651   XML_ERROR_ASYNC_ENTITY,
 652   XML_ERROR_BAD_CHAR_REF,
 653   XML_ERROR_BINARY_ENTITY_REF,
 654   XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
 655   XML_ERROR_MISPLACED_XML_PI,
 656   XML_ERROR_UNKNOWN_ENCODING,
 657   XML_ERROR_INCORRECT_ENCODING,
 658   XML_ERROR_UNCLOSED_CDATA_SECTION,
 659   XML_ERROR_EXTERNAL_ENTITY_HANDLING,
 660   XML_ERROR_NOT_STANDALONE,
 661   XML_ERROR_UNEXPECTED_STATE
 662 };
 663
 664 /* If XML_Parse or XML_ParseBuffer have returned 0, then XML_GetErrorCode
 665 returns information about the error. */
 666
 667 XMLPARSEAPI(enum XML_Error)
 668 XML_GetErrorCode(XML_Parser parser);
 669
 670 /* These functions return information about the current parse location.
 671 They may be called when XML_Parse or XML_ParseBuffer return 0;
 672 in this case the location is the location of the character at which
 673 the error was detected.
 674 They may also be called from any other callback called to report
 675 some parse event; in this the location is the location of the first
 676 of the sequence of characters that generated the event. */
 677
 678 XMLPARSEAPI(int) XML_GetCurrentLineNumber(XML_Parser parser);
 679 XMLPARSEAPI(int) XML_GetCurrentColumnNumber(XML_Parser parser);
 680 XMLPARSEAPI(long) XML_GetCurrentByteIndex(XML_Parser parser);
 681
 682 /* Return the number of bytes in the current event.
 683 Returns 0 if the event is in an internal entity. */
 684
 685 XMLPARSEAPI(int)
 686 XML_GetCurrentByteCount(XML_Parser parser);
 687
 688 /* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets
 689    the integer pointed to by offset to the offset within this buffer
 690    of the current parse position, and sets the integer pointed to by size
 691    to the size of this buffer (the number of input bytes). Otherwise
 692    returns a null pointer. Also returns a null pointer if a parse isn't
 693    active.
 694
 695    NOTE: The character pointer returned should not be used outside
 696    the handler that makes the call. */
 697
 698 XMLPARSEAPI(const char *)
 699 XML_GetInputContext(XML_Parser parser,
 700                     int *offset,
 701                     int *size);
 702
 703 /* For backwards compatibility with previous versions. */
 704 #define XML_GetErrorLineNumber XML_GetCurrentLineNumber
 705 #define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
 706 #define XML_GetErrorByteIndex XML_GetCurrentByteIndex
 707
 708 /* Frees memory used by the parser. */
 709 XMLPARSEAPI(void)
 710 XML_ParserFree(XML_Parser parser);
 711
 712 /* Returns a string describing the error. */
 713 XMLPARSEAPI(const XML_LChar *)
 714 XML_ErrorString(int code);
 715
 716 /* Return a string containing the version number of this expat */
 717 XMLPARSEAPI(const XML_LChar *)
 718 XML_ExpatVersion(void);
 719
 720 typedef struct {
 721   int major;
 722   int minor;
 723   int micro;
 724 } XML_Expat_Version;
 725
 726 /* Return an XML_Expat_Version structure containing numeric version
 727    number information for this version of expat */
 728
 729 XMLPARSEAPI(XML_Expat_Version)
 730 XML_ExpatVersionInfo(void);
 731
 732 #define XML_MAJOR_VERSION 1
 733 #define XML_MINOR_VERSION 95
 734 #define XML_MICRO_VERSION 2
 735
 736 #ifdef __cplusplus
 737 }
 738 #endif
 739
 740 #endif /* not XmlParse_INCLUDED */