gnulib-local/lib/libxml/parser.in.h

   1 /*
   2  * Summary: the core parser module
   3  * Description: Interfaces, constants and types related to the XML parser
   4  *
   5  * Copy: See Copyright for the status of this software.
   6  *
   7  * Author: Daniel Veillard
   8  */
   9
  10 #ifndef __XML_PARSER_H__
  11 #define __XML_PARSER_H__
  12
  13 #include <stdarg.h>
  14
  15 #include <libxml/xmlversion.h>
  16 #include <libxml/tree.h>
  17 #include <libxml/dict.h>
  18 #include <libxml/hash.h>
  19 #include <libxml/valid.h>
  20 #include <libxml/entities.h>
  21 #include <libxml/xmlerror.h>
  22 #include <libxml/xmlstring.h>
  23
  24 #ifdef __cplusplus
  25 extern "C" {
  26 #endif
  27
  28 /**
  29  * XML_DEFAULT_VERSION:
  30  *
  31  * The default version of XML used: 1.0
  32  */
  33 #define XML_DEFAULT_VERSION     "1.0"
  34
  35 /**
  36  * xmlParserInput:
  37  *
  38  * An xmlParserInput is an input flow for the XML processor.
  39  * Each entity parsed is associated an xmlParserInput (except the
  40  * few predefined ones). This is the case both for internal entities
  41  * - in which case the flow is already completely in memory - or
  42  * external entities - in which case we use the buf structure for
  43  * progressive reading and I18N conversions to the internal UTF-8 format.
  44  */
  45
  46 /**
  47  * xmlParserInputDeallocate:
  48  * @str:  the string to deallocate
  49  *
  50  * Callback for freeing some parser input allocations.
  51  */
  52 typedef void (* xmlParserInputDeallocate)(xmlChar *str);
  53
  54 struct _xmlParserInput {
  55     /* Input buffer */
  56     xmlParserInputBufferPtr buf;      /* UTF-8 encoded buffer */
  57
  58     const char *filename;             /* The file analyzed, if any */
  59     const char *directory;            /* the directory/base of the file */
  60     const xmlChar *base;              /* Base of the array to parse */
  61     const xmlChar *cur;               /* Current char being parsed */
  62     const xmlChar *end;               /* end of the array to parse */
  63     int length;                       /* length if known */
  64     int line;                         /* Current line */
  65     int col;                          /* Current column */
  66     /*
  67      * NOTE: consumed is only tested for equality in the parser code,
  68      *       so even if there is an overflow this should not give troubles
  69      *       for parsing very large instances.
  70      */
  71     unsigned long consumed;           /* How many xmlChars already consumed */
  72     xmlParserInputDeallocate free;    /* function to deallocate the base */
  73     const xmlChar *encoding;          /* the encoding string for entity */
  74     const xmlChar *version;           /* the version string for entity */
  75     int standalone;                   /* Was that entity marked standalone */
  76     int id;                           /* an unique identifier for the entity */
  77 };
  78
  79 /**
  80  * xmlParserNodeInfo:
  81  *
  82  * The parser can be asked to collect Node informations, i.e. at what
  83  * place in the file they were detected.
  84  * NOTE: This is off by default and not very well tested.
  85  */
  86 typedef struct _xmlParserNodeInfo xmlParserNodeInfo;
  87 typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;
  88
  89 struct _xmlParserNodeInfo {
  90   const struct _xmlNode* node;
  91   /* Position & line # that text that created the node begins & ends on */
  92   unsigned long begin_pos;
  93   unsigned long begin_line;
  94   unsigned long end_pos;
  95   unsigned long end_line;
  96 };
  97
  98 typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq;
  99 typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;
 100 struct _xmlParserNodeInfoSeq {
 101   unsigned long maximum;
 102   unsigned long length;
 103   xmlParserNodeInfo* buffer;
 104 };
 105
 106 /**
 107  * xmlParserInputState:
 108  *
 109  * The parser is now working also as a state based parser.
 110  * The recursive one use the state info for entities processing.
 111  */
 112 typedef enum {
 113     XML_PARSER_EOF = -1,        /* nothing is to be parsed */
 114     XML_PARSER_START = 0,       /* nothing has been parsed */
 115     XML_PARSER_MISC,            /* Misc* before int subset */
 116     XML_PARSER_PI,              /* Within a processing instruction */
 117     XML_PARSER_DTD,             /* within some DTD content */
 118     XML_PARSER_PROLOG,          /* Misc* after internal subset */
 119     XML_PARSER_COMMENT,         /* within a comment */
 120     XML_PARSER_START_TAG,       /* within a start tag */
 121     XML_PARSER_CONTENT,         /* within the content */
 122     XML_PARSER_CDATA_SECTION,   /* within a CDATA section */
 123     XML_PARSER_END_TAG,         /* within a closing tag */
 124     XML_PARSER_ENTITY_DECL,     /* within an entity declaration */
 125     XML_PARSER_ENTITY_VALUE,    /* within an entity value in a decl */
 126     XML_PARSER_ATTRIBUTE_VALUE, /* within an attribute value */
 127     XML_PARSER_SYSTEM_LITERAL,  /* within a SYSTEM value */
 128     XML_PARSER_EPILOG,          /* the Misc* after the last end tag */
 129     XML_PARSER_IGNORE,          /* within an IGNORED section */
 130     XML_PARSER_PUBLIC_LITERAL   /* within a PUBLIC value */
 131 } xmlParserInputState;
 132
 133 /**
 134  * XML_DETECT_IDS:
 135  *
 136  * Bit in the loadsubset context field to tell to do ID/REFs lookups.
 137  * Use it to initialize xmlLoadExtDtdDefaultValue.
 138  */
 139 #define XML_DETECT_IDS          2
 140
 141 /**
 142  * XML_COMPLETE_ATTRS:
 143  *
 144  * Bit in the loadsubset context field to tell to do complete the
 145  * elements attributes lists with the ones defaulted from the DTDs.
 146  * Use it to initialize xmlLoadExtDtdDefaultValue.
 147  */
 148 #define XML_COMPLETE_ATTRS      4
 149
 150 /**
 151  * XML_SKIP_IDS:
 152  *
 153  * Bit in the loadsubset context field to tell to not do ID/REFs registration.
 154  * Used to initialize xmlLoadExtDtdDefaultValue in some special cases.
 155  */
 156 #define XML_SKIP_IDS            8
 157
 158 /**
 159  * xmlParserMode:
 160  *
 161  * A parser can operate in various modes
 162  */
 163 typedef enum {
 164     XML_PARSE_UNKNOWN = 0,
 165     XML_PARSE_DOM = 1,
 166     XML_PARSE_SAX = 2,
 167     XML_PARSE_PUSH_DOM = 3,
 168     XML_PARSE_PUSH_SAX = 4,
 169     XML_PARSE_READER = 5
 170 } xmlParserMode;
 171
 172 /**
 173  * xmlParserCtxt:
 174  *
 175  * The parser context.
 176  * NOTE This doesn't completely define the parser state, the (current ?)
 177  *      design of the parser uses recursive function calls since this allow
 178  *      and easy mapping from the production rules of the specification
 179  *      to the actual code. The drawback is that the actual function call
 180  *      also reflect the parser state. However most of the parsing routines
 181  *      takes as the only argument the parser context pointer, so migrating
 182  *      to a state based parser for progressive parsing shouldn't be too hard.
 183  */
 184 struct _xmlParserCtxt {
 185     struct _xmlSAXHandler *sax;       /* The SAX handler */
 186     void            *userData;        /* For SAX interface only, used by DOM build */
 187     xmlDocPtr           myDoc;        /* the document being built */
 188     int            wellFormed;        /* is the document well formed */
 189     int       replaceEntities;        /* shall we replace entities ? */
 190     const xmlChar    *version;        /* the XML version string */
 191     const xmlChar   *encoding;        /* the declared encoding, if any */
 192     int            standalone;        /* standalone document */
 193     int                  html;        /* an HTML(1)/Docbook(2) document
 194                                        * 3 is HTML after <head>
 195                                        * 10 is HTML after <body>
 196                                        */
 197
 198     /* Input stream stack */
 199     xmlParserInputPtr  input;         /* Current input stream */
 200     int                inputNr;       /* Number of current input streams */
 201     int                inputMax;      /* Max number of input streams */
 202     xmlParserInputPtr *inputTab;      /* stack of inputs */
 203
 204     /* Node analysis stack only used for DOM building */
 205     xmlNodePtr         node;          /* Current parsed Node */
 206     int                nodeNr;        /* Depth of the parsing stack */
 207     int                nodeMax;       /* Max depth of the parsing stack */
 208     xmlNodePtr        *nodeTab;       /* array of nodes */
 209
 210     int record_info;                  /* Whether node info should be kept */
 211     xmlParserNodeInfoSeq node_seq;    /* info about each node parsed */
 212
 213     int errNo;                        /* error code */
 214
 215     int     hasExternalSubset;        /* reference and external subset */
 216     int             hasPErefs;        /* the internal subset has PE refs */
 217     int              external;        /* are we parsing an external entity */
 218
 219     int                 valid;        /* is the document valid */
 220     int              validate;        /* shall we try to validate ? */
 221     xmlValidCtxt        vctxt;        /* The validity context */
 222
 223     xmlParserInputState instate;      /* current type of input */
 224     int                 token;        /* next char look-ahead */
 225
 226     char           *directory;        /* the data directory */
 227
 228     /* Node name stack */
 229     const xmlChar     *name;          /* Current parsed Node */
 230     int                nameNr;        /* Depth of the parsing stack */
 231     int                nameMax;       /* Max depth of the parsing stack */
 232     const xmlChar *   *nameTab;       /* array of nodes */
 233
 234     long               nbChars;       /* number of xmlChar processed */
 235     long            checkIndex;       /* used by progressive parsing lookup */
 236     int             keepBlanks;       /* ugly but ... */
 237     int             disableSAX;       /* SAX callbacks are disabled */
 238     int               inSubset;       /* Parsing is in int 1/ext 2 subset */
 239     const xmlChar *    intSubName;    /* name of subset */
 240     xmlChar *          extSubURI;     /* URI of external subset */
 241     xmlChar *          extSubSystem;  /* SYSTEM ID of external subset */
 242
 243     /* xml:space values */
 244     int *              space;         /* Should the parser preserve spaces */
 245     int                spaceNr;       /* Depth of the parsing stack */
 246     int                spaceMax;      /* Max depth of the parsing stack */
 247     int *              spaceTab;      /* array of space infos */
 248
 249     int                depth;         /* to prevent entity substitution loops */
 250     xmlParserInputPtr  entity;        /* used to check entities boundaries */
 251     int                charset;       /* encoding of the in-memory content
 252                                          actually an xmlCharEncoding */
 253     int                nodelen;       /* Those two fields are there to */
 254     int                nodemem;       /* Speed up large node parsing */
 255     int                pedantic;      /* signal pedantic warnings */
 256     void              *_private;      /* For user data, libxml won't touch it */
 257
 258     int                loadsubset;    /* should the external subset be loaded */
 259     int                linenumbers;   /* set line number in element content */
 260     void              *catalogs;      /* document's own catalog */
 261     int                recovery;      /* run in recovery mode */
 262     int                progressive;   /* is this a progressive parsing */
 263     xmlDictPtr         dict;          /* dictionnary for the parser */
 264     const xmlChar *   *atts;          /* array for the attributes callbacks */
 265     int                maxatts;       /* the size of the array */
 266     int                docdict;       /* use strings from dict to build tree */
 267
 268     /*
 269      * pre-interned strings
 270      */
 271     const xmlChar *str_xml;
 272     const xmlChar *str_xmlns;
 273     const xmlChar *str_xml_ns;
 274
 275     /*
 276      * Everything below is used only by the new SAX mode
 277      */
 278     int                sax2;          /* operating in the new SAX mode */
 279     int                nsNr;          /* the number of inherited namespaces */
 280     int                nsMax;         /* the size of the arrays */
 281     const xmlChar *   *nsTab;         /* the array of prefix/namespace name */
 282     int               *attallocs;     /* which attribute were allocated */
 283     void *            *pushTab;       /* array of data for push */
 284     xmlHashTablePtr    attsDefault;   /* defaulted attributes if any */
 285     xmlHashTablePtr    attsSpecial;   /* non-CDATA attributes if any */
 286     int                nsWellFormed;  /* is the document XML Nanespace okay */
 287     int                options;       /* Extra options */
 288
 289     /*
 290      * Those fields are needed only for treaming parsing so far
 291      */
 292     int               dictNames;    /* Use dictionary names for the tree */
 293     int               freeElemsNr;  /* number of freed element nodes */
 294     xmlNodePtr        freeElems;    /* List of freed element nodes */
 295     int               freeAttrsNr;  /* number of freed attributes nodes */
 296     xmlAttrPtr        freeAttrs;    /* List of freed attributes nodes */
 297
 298     /*
 299      * the complete error informations for the last error.
 300      */
 301     xmlError          lastError;
 302     xmlParserMode     parseMode;    /* the parser mode */
 303     unsigned long    nbentities;    /* number of entities references */
 304     unsigned long  sizeentities;    /* size of parsed entities */
 305
 306     /* for use by HTML non-recursive parser */
 307     xmlParserNodeInfo *nodeInfo;      /* Current NodeInfo */
 308     int                nodeInfoNr;    /* Depth of the parsing stack */
 309     int                nodeInfoMax;   /* Max depth of the parsing stack */
 310     xmlParserNodeInfo *nodeInfoTab;   /* array of nodeInfos */
 311
 312     int                input_id;      /* we need to label inputs */
 313     unsigned long      sizeentcopy;   /* volume of entity copy */
 314 };
 315
 316 /**
 317  * xmlSAXLocator:
 318  *
 319  * A SAX Locator.
 320  */
 321 struct _xmlSAXLocator {
 322     const xmlChar *(*getPublicId)(void *ctx);
 323     const xmlChar *(*getSystemId)(void *ctx);
 324     int (*getLineNumber)(void *ctx);
 325     int (*getColumnNumber)(void *ctx);
 326 };
 327
 328 /**
 329  * xmlSAXHandler:
 330  *
 331  * A SAX handler is bunch of callbacks called by the parser when processing
 332  * of the input generate data or structure informations.
 333  */
 334
 335 /**
 336  * resolveEntitySAXFunc:
 337  * @ctx:  the user data (XML parser context)
 338  * @publicId: The public ID of the entity
 339  * @systemId: The system ID of the entity
 340  *
 341  * Callback:
 342  * The entity loader, to control the loading of external entities,
 343  * the application can either:
 344  *    - override this resolveEntity() callback in the SAX block
 345  *    - or better use the xmlSetExternalEntityLoader() function to
 346  *      set up it's own entity resolution routine
 347  *
 348  * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
 349  */
 350 typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx,
 351                                 const xmlChar *publicId,
 352                                 const xmlChar *systemId);
 353 /**
 354  * internalSubsetSAXFunc:
 355  * @ctx:  the user data (XML parser context)
 356  * @name:  the root element name
 357  * @ExternalID:  the external ID
 358  * @SystemID:  the SYSTEM ID (e.g. filename or URL)
 359  *
 360  * Callback on internal subset declaration.
 361  */
 362 typedef void (*internalSubsetSAXFunc) (void *ctx,
 363                                 const xmlChar *name,
 364                                 const xmlChar *ExternalID,
 365                                 const xmlChar *SystemID);
 366 /**
 367  * externalSubsetSAXFunc:
 368  * @ctx:  the user data (XML parser context)
 369  * @name:  the root element name
 370  * @ExternalID:  the external ID
 371  * @SystemID:  the SYSTEM ID (e.g. filename or URL)
 372  *
 373  * Callback on external subset declaration.
 374  */
 375 typedef void (*externalSubsetSAXFunc) (void *ctx,
 376                                 const xmlChar *name,
 377                                 const xmlChar *ExternalID,
 378                                 const xmlChar *SystemID);
 379 /**
 380  * getEntitySAXFunc:
 381  * @ctx:  the user data (XML parser context)
 382  * @name: The entity name
 383  *
 384  * Get an entity by name.
 385  *
 386  * Returns the xmlEntityPtr if found.
 387  */
 388 typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx,
 389                                 const xmlChar *name);
 390 /**
 391  * getParameterEntitySAXFunc:
 392  * @ctx:  the user data (XML parser context)
 393  * @name: The entity name
 394  *
 395  * Get a parameter entity by name.
 396  *
 397  * Returns the xmlEntityPtr if found.
 398  */
 399 typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx,
 400                                 const xmlChar *name);
 401 /**
 402  * entityDeclSAXFunc:
 403  * @ctx:  the user data (XML parser context)
 404  * @name:  the entity name
 405  * @type:  the entity type
 406  * @publicId: The public ID of the entity
 407  * @systemId: The system ID of the entity
 408  * @content: the entity value (without processing).
 409  *
 410  * An entity definition has been parsed.
 411  */
 412 typedef void (*entityDeclSAXFunc) (void *ctx,
 413                                 const xmlChar *name,
 414                                 int type,
 415                                 const xmlChar *publicId,
 416                                 const xmlChar *systemId,
 417                                 xmlChar *content);
 418 /**
 419  * notationDeclSAXFunc:
 420  * @ctx:  the user data (XML parser context)
 421  * @name: The name of the notation
 422  * @publicId: The public ID of the entity
 423  * @systemId: The system ID of the entity
 424  *
 425  * What to do when a notation declaration has been parsed.
 426  */
 427 typedef void (*notationDeclSAXFunc)(void *ctx,
 428                                 const xmlChar *name,
 429                                 const xmlChar *publicId,
 430                                 const xmlChar *systemId);
 431 /**
 432  * attributeDeclSAXFunc:
 433  * @ctx:  the user data (XML parser context)
 434  * @elem:  the name of the element
 435  * @fullname:  the attribute name
 436  * @type:  the attribute type
 437  * @def:  the type of default value
 438  * @defaultValue: the attribute default value
 439  * @tree:  the tree of enumerated value set
 440  *
 441  * An attribute definition has been parsed.
 442  */
 443 typedef void (*attributeDeclSAXFunc)(void *ctx,
 444                                 const xmlChar *elem,
 445                                 const xmlChar *fullname,
 446                                 int type,
 447                                 int def,
 448                                 const xmlChar *defaultValue,
 449                                 xmlEnumerationPtr tree);
 450 /**
 451  * elementDeclSAXFunc:
 452  * @ctx:  the user data (XML parser context)
 453  * @name:  the element name
 454  * @type:  the element type
 455  * @content: the element value tree
 456  *
 457  * An element definition has been parsed.
 458  */
 459 typedef void (*elementDeclSAXFunc)(void *ctx,
 460                                 const xmlChar *name,
 461                                 int type,
 462                                 xmlElementContentPtr content);
 463 /**
 464  * unparsedEntityDeclSAXFunc:
 465  * @ctx:  the user data (XML parser context)
 466  * @name: The name of the entity
 467  * @publicId: The public ID of the entity
 468  * @systemId: The system ID of the entity
 469  * @notationName: the name of the notation
 470  *
 471  * What to do when an unparsed entity declaration is parsed.
 472  */
 473 typedef void (*unparsedEntityDeclSAXFunc)(void *ctx,
 474                                 const xmlChar *name,
 475                                 const xmlChar *publicId,
 476                                 const xmlChar *systemId,
 477                                 const xmlChar *notationName);
 478 /**
 479  * setDocumentLocatorSAXFunc:
 480  * @ctx:  the user data (XML parser context)
 481  * @loc: A SAX Locator
 482  *
 483  * Receive the document locator at startup, actually xmlDefaultSAXLocator.
 484  * Everything is available on the context, so this is useless in our case.
 485  */
 486 typedef void (*setDocumentLocatorSAXFunc) (void *ctx,
 487                                 xmlSAXLocatorPtr loc);
 488 /**
 489  * startDocumentSAXFunc:
 490  * @ctx:  the user data (XML parser context)
 491  *
 492  * Called when the document start being processed.
 493  */
 494 typedef void (*startDocumentSAXFunc) (void *ctx);
 495 /**
 496  * endDocumentSAXFunc:
 497  * @ctx:  the user data (XML parser context)
 498  *
 499  * Called when the document end has been detected.
 500  */
 501 typedef void (*endDocumentSAXFunc) (void *ctx);
 502 /**
 503  * startElementSAXFunc:
 504  * @ctx:  the user data (XML parser context)
 505  * @name:  The element name, including namespace prefix
 506  * @atts:  An array of name/value attributes pairs, NULL terminated
 507  *
 508  * Called when an opening tag has been processed.
 509  */
 510 typedef void (*startElementSAXFunc) (void *ctx,
 511                                 const xmlChar *name,
 512                                 const xmlChar **atts);
 513 /**
 514  * endElementSAXFunc:
 515  * @ctx:  the user data (XML parser context)
 516  * @name:  The element name
 517  *
 518  * Called when the end of an element has been detected.
 519  */
 520 typedef void (*endElementSAXFunc) (void *ctx,
 521                                 const xmlChar *name);
 522 /**
 523  * attributeSAXFunc:
 524  * @ctx:  the user data (XML parser context)
 525  * @name:  The attribute name, including namespace prefix
 526  * @value:  The attribute value
 527  *
 528  * Handle an attribute that has been read by the parser.
 529  * The default handling is to convert the attribute into an
 530  * DOM subtree and past it in a new xmlAttr element added to
 531  * the element.
 532  */
 533 typedef void (*attributeSAXFunc) (void *ctx,
 534                                 const xmlChar *name,
 535                                 const xmlChar *value);
 536 /**
 537  * referenceSAXFunc:
 538  * @ctx:  the user data (XML parser context)
 539  * @name:  The entity name
 540  *
 541  * Called when an entity reference is detected.
 542  */
 543 typedef void (*referenceSAXFunc) (void *ctx,
 544                                 const xmlChar *name);
 545 /**
 546  * charactersSAXFunc:
 547  * @ctx:  the user data (XML parser context)
 548  * @ch:  a xmlChar string
 549  * @len: the number of xmlChar
 550  *
 551  * Receiving some chars from the parser.
 552  */
 553 typedef void (*charactersSAXFunc) (void *ctx,
 554                                 const xmlChar *ch,
 555                                 int len);
 556 /**
 557  * ignorableWhitespaceSAXFunc:
 558  * @ctx:  the user data (XML parser context)
 559  * @ch:  a xmlChar string
 560  * @len: the number of xmlChar
 561  *
 562  * Receiving some ignorable whitespaces from the parser.
 563  * UNUSED: by default the DOM building will use characters.
 564  */
 565 typedef void (*ignorableWhitespaceSAXFunc) (void *ctx,
 566                                 const xmlChar *ch,
 567                                 int len);
 568 /**
 569  * processingInstructionSAXFunc:
 570  * @ctx:  the user data (XML parser context)
 571  * @target:  the target name
 572  * @data: the PI data's
 573  *
 574  * A processing instruction has been parsed.
 575  */
 576 typedef void (*processingInstructionSAXFunc) (void *ctx,
 577                                 const xmlChar *target,
 578                                 const xmlChar *data);
 579 /**
 580  * commentSAXFunc:
 581  * @ctx:  the user data (XML parser context)
 582  * @value:  the comment content
 583  *
 584  * A comment has been parsed.
 585  */
 586 typedef void (*commentSAXFunc) (void *ctx,
 587                                 const xmlChar *value);
 588 /**
 589  * cdataBlockSAXFunc:
 590  * @ctx:  the user data (XML parser context)
 591  * @value:  The pcdata content
 592  * @len:  the block length
 593  *
 594  * Called when a pcdata block has been parsed.
 595  */
 596 typedef void (*cdataBlockSAXFunc) (
 597                                 void *ctx,
 598                                 const xmlChar *value,
 599                                 int len);
 600 /**
 601  * warningSAXFunc:
 602  * @ctx:  an XML parser context
 603  * @msg:  the message to display/transmit
 604  * @...:  extra parameters for the message display
 605  *
 606  * Display and format a warning messages, callback.
 607  */
 608 typedef void (XMLCDECL *warningSAXFunc) (void *ctx,
 609                                 const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
 610 /**
 611  * errorSAXFunc:
 612  * @ctx:  an XML parser context
 613  * @msg:  the message to display/transmit
 614  * @...:  extra parameters for the message display
 615  *
 616  * Display and format an error messages, callback.
 617  */
 618 typedef void (XMLCDECL *errorSAXFunc) (void *ctx,
 619                                 const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
 620 /**
 621  * fatalErrorSAXFunc:
 622  * @ctx:  an XML parser context
 623  * @msg:  the message to display/transmit
 624  * @...:  extra parameters for the message display
 625  *
 626  * Display and format fatal error messages, callback.
 627  * Note: so far fatalError() SAX callbacks are not used, error()
 628  *       get all the callbacks for errors.
 629  */
 630 typedef void (XMLCDECL *fatalErrorSAXFunc) (void *ctx,
 631                                 const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
 632 /**
 633  * isStandaloneSAXFunc:
 634  * @ctx:  the user data (XML parser context)
 635  *
 636  * Is this document tagged standalone?
 637  *
 638  * Returns 1 if true
 639  */
 640 typedef int (*isStandaloneSAXFunc) (void *ctx);
 641 /**
 642  * hasInternalSubsetSAXFunc:
 643  * @ctx:  the user data (XML parser context)
 644  *
 645  * Does this document has an internal subset.
 646  *
 647  * Returns 1 if true
 648  */
 649 typedef int (*hasInternalSubsetSAXFunc) (void *ctx);
 650
 651 /**
 652  * hasExternalSubsetSAXFunc:
 653  * @ctx:  the user data (XML parser context)
 654  *
 655  * Does this document has an external subset?
 656  *
 657  * Returns 1 if true
 658  */
 659 typedef int (*hasExternalSubsetSAXFunc) (void *ctx);
 660
 661 /************************************************************************
 662  *                                                                      *
 663  *                      The SAX version 2 API extensions                *
 664  *                                                                      *
 665  ************************************************************************/
 666 /**
 667  * XML_SAX2_MAGIC:
 668  *
 669  * Special constant found in SAX2 blocks initialized fields
 670  */
 671 #define XML_SAX2_MAGIC 0xDEEDBEAF
 672
 673 /**
 674  * startElementNsSAX2Func:
 675  * @ctx:  the user data (XML parser context)
 676  * @localname:  the local name of the element
 677  * @prefix:  the element namespace prefix if available
 678  * @URI:  the element namespace name if available
 679  * @nb_namespaces:  number of namespace definitions on that node
 680  * @namespaces:  pointer to the array of prefix/URI pairs namespace definitions
 681  * @nb_attributes:  the number of attributes on that node
 682  * @nb_defaulted:  the number of defaulted attributes. The defaulted
 683  *                  ones are at the end of the array
 684  * @attributes:  pointer to the array of (localname/prefix/URI/value/end)
 685  *               attribute values.
 686  *
 687  * SAX2 callback when an element start has been detected by the parser.
 688  * It provides the namespace informations for the element, as well as
 689  * the new namespace declarations on the element.
 690  */
 691
 692 typedef void (*startElementNsSAX2Func) (void *ctx,
 693                                         const xmlChar *localname,
 694                                         const xmlChar *prefix,
 695                                         const xmlChar *URI,
 696                                         int nb_namespaces,
 697                                         const xmlChar **namespaces,
 698                                         int nb_attributes,
 699                                         int nb_defaulted,
 700                                         const xmlChar **attributes);
 701
 702 /**
 703  * endElementNsSAX2Func:
 704  * @ctx:  the user data (XML parser context)
 705  * @localname:  the local name of the element
 706  * @prefix:  the element namespace prefix if available
 707  * @URI:  the element namespace name if available
 708  *
 709  * SAX2 callback when an element end has been detected by the parser.
 710  * It provides the namespace informations for the element.
 711  */
 712
 713 typedef void (*endElementNsSAX2Func)   (void *ctx,
 714                                         const xmlChar *localname,
 715                                         const xmlChar *prefix,
 716                                         const xmlChar *URI);
 717
 718
 719 struct _xmlSAXHandler {
 720     internalSubsetSAXFunc internalSubset;
 721     isStandaloneSAXFunc isStandalone;
 722     hasInternalSubsetSAXFunc hasInternalSubset;
 723     hasExternalSubsetSAXFunc hasExternalSubset;
 724     resolveEntitySAXFunc resolveEntity;
 725     getEntitySAXFunc getEntity;
 726     entityDeclSAXFunc entityDecl;
 727     notationDeclSAXFunc notationDecl;
 728     attributeDeclSAXFunc attributeDecl;
 729     elementDeclSAXFunc elementDecl;
 730     unparsedEntityDeclSAXFunc unparsedEntityDecl;
 731     setDocumentLocatorSAXFunc setDocumentLocator;
 732     startDocumentSAXFunc startDocument;
 733     endDocumentSAXFunc endDocument;
 734     startElementSAXFunc startElement;
 735     endElementSAXFunc endElement;
 736     referenceSAXFunc reference;
 737     charactersSAXFunc characters;
 738     ignorableWhitespaceSAXFunc ignorableWhitespace;
 739     processingInstructionSAXFunc processingInstruction;
 740     commentSAXFunc comment;
 741     warningSAXFunc warning;
 742     errorSAXFunc error;
 743     fatalErrorSAXFunc fatalError; /* unused error() get all the errors */
 744     getParameterEntitySAXFunc getParameterEntity;
 745     cdataBlockSAXFunc cdataBlock;
 746     externalSubsetSAXFunc externalSubset;
 747     unsigned int initialized;
 748     /* The following fields are extensions available only on version 2 */
 749     void *_private;
 750     startElementNsSAX2Func startElementNs;
 751     endElementNsSAX2Func endElementNs;
 752     xmlStructuredErrorFunc serror;
 753 };
 754
 755 /*
 756  * SAX Version 1
 757  */
 758 typedef struct _xmlSAXHandlerV1 xmlSAXHandlerV1;
 759 typedef xmlSAXHandlerV1 *xmlSAXHandlerV1Ptr;
 760 struct _xmlSAXHandlerV1 {
 761     internalSubsetSAXFunc internalSubset;
 762     isStandaloneSAXFunc isStandalone;
 763     hasInternalSubsetSAXFunc hasInternalSubset;
 764     hasExternalSubsetSAXFunc hasExternalSubset;
 765     resolveEntitySAXFunc resolveEntity;
 766     getEntitySAXFunc getEntity;
 767     entityDeclSAXFunc entityDecl;
 768     notationDeclSAXFunc notationDecl;
 769     attributeDeclSAXFunc attributeDecl;
 770     elementDeclSAXFunc elementDecl;
 771     unparsedEntityDeclSAXFunc unparsedEntityDecl;
 772     setDocumentLocatorSAXFunc setDocumentLocator;
 773     startDocumentSAXFunc startDocument;
 774     endDocumentSAXFunc endDocument;
 775     startElementSAXFunc startElement;
 776     endElementSAXFunc endElement;
 777     referenceSAXFunc reference;
 778     charactersSAXFunc characters;
 779     ignorableWhitespaceSAXFunc ignorableWhitespace;
 780     processingInstructionSAXFunc processingInstruction;
 781     commentSAXFunc comment;
 782     warningSAXFunc warning;
 783     errorSAXFunc error;
 784     fatalErrorSAXFunc fatalError; /* unused error() get all the errors */
 785     getParameterEntitySAXFunc getParameterEntity;
 786     cdataBlockSAXFunc cdataBlock;
 787     externalSubsetSAXFunc externalSubset;
 788     unsigned int initialized;
 789 };
 790
 791
 792 /**
 793  * xmlExternalEntityLoader:
 794  * @URL: The System ID of the resource requested
 795  * @ID: The Public ID of the resource requested
 796  * @context: the XML parser context
 797  *
 798  * External entity loaders types.
 799  *
 800  * Returns the entity input parser.
 801  */
 802 typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL,
 803                                          const char *ID,
 804                                          xmlParserCtxtPtr context);
 805
 806 #ifdef __cplusplus
 807 }
 808 #endif
 809
 810 #include <libxml/encoding.h>
 811 #include <libxml/xmlIO.h>
 812 #include <libxml/globals.h>
 813
 814 #ifdef __cplusplus
 815 extern "C" {
 816 #endif
 817
 818
 819 /*
 820  * Init/Cleanup
 821  */
 822 XMLPUBFUN void XMLCALL
 823                 xmlInitParser           (void);
 824 XMLPUBFUN void XMLCALL
 825                 xmlCleanupParser        (void);
 826
 827 /*
 828  * Input functions
 829  */
 830 XMLPUBFUN int XMLCALL
 831                 xmlParserInputRead      (xmlParserInputPtr in,
 832                                          int len);
 833 XMLPUBFUN int XMLCALL
 834                 xmlParserInputGrow      (xmlParserInputPtr in,
 835                                          int len);
 836
 837 /*
 838  * Basic parsing Interfaces
 839  */
 840 #ifdef LIBXML_SAX1_ENABLED
 841 XMLPUBFUN xmlDocPtr XMLCALL
 842                 xmlParseDoc             (const xmlChar *cur);
 843 XMLPUBFUN xmlDocPtr XMLCALL
 844                 xmlParseFile            (const char *filename);
 845 XMLPUBFUN xmlDocPtr XMLCALL
 846                 xmlParseMemory          (const char *buffer,
 847                                          int size);
 848 #endif /* LIBXML_SAX1_ENABLED */
 849 XMLPUBFUN int XMLCALL
 850                 xmlSubstituteEntitiesDefault(int val);
 851 XMLPUBFUN int XMLCALL
 852                 xmlKeepBlanksDefault    (int val);
 853 XMLPUBFUN void XMLCALL
 854                 xmlStopParser           (xmlParserCtxtPtr ctxt);
 855 XMLPUBFUN int XMLCALL
 856                 xmlPedanticParserDefault(int val);
 857 XMLPUBFUN int XMLCALL
 858                 xmlLineNumbersDefault   (int val);
 859
 860 #ifdef LIBXML_SAX1_ENABLED
 861 /*
 862  * Recovery mode
 863  */
 864 XMLPUBFUN xmlDocPtr XMLCALL
 865                 xmlRecoverDoc           (const xmlChar *cur);
 866 XMLPUBFUN xmlDocPtr XMLCALL
 867                 xmlRecoverMemory        (const char *buffer,
 868                                          int size);
 869 XMLPUBFUN xmlDocPtr XMLCALL
 870                 xmlRecoverFile          (const char *filename);
 871 #endif /* LIBXML_SAX1_ENABLED */
 872
 873 /*
 874  * Less common routines and SAX interfaces
 875  */
 876 XMLPUBFUN int XMLCALL
 877                 xmlParseDocument        (xmlParserCtxtPtr ctxt);
 878 XMLPUBFUN int XMLCALL
 879                 xmlParseExtParsedEnt    (xmlParserCtxtPtr ctxt);
 880 #ifdef LIBXML_SAX1_ENABLED
 881 XMLPUBFUN int XMLCALL
 882                 xmlSAXUserParseFile     (xmlSAXHandlerPtr sax,
 883                                          void *user_data,
 884                                          const char *filename);
 885 XMLPUBFUN int XMLCALL
 886                 xmlSAXUserParseMemory   (xmlSAXHandlerPtr sax,
 887                                          void *user_data,
 888                                          const char *buffer,
 889                                          int size);
 890 XMLPUBFUN xmlDocPtr XMLCALL
 891                 xmlSAXParseDoc          (xmlSAXHandlerPtr sax,
 892                                          const xmlChar *cur,
 893                                          int recovery);
 894 XMLPUBFUN xmlDocPtr XMLCALL
 895                 xmlSAXParseMemory       (xmlSAXHandlerPtr sax,
 896                                          const char *buffer,
 897                                          int size,
 898                                          int recovery);
 899 XMLPUBFUN xmlDocPtr XMLCALL
 900                 xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax,
 901                                          const char *buffer,
 902                                          int size,
 903                                          int recovery,
 904                                          void *data);
 905 XMLPUBFUN xmlDocPtr XMLCALL
 906                 xmlSAXParseFile         (xmlSAXHandlerPtr sax,
 907                                          const char *filename,
 908                                          int recovery);
 909 XMLPUBFUN xmlDocPtr XMLCALL
 910                 xmlSAXParseFileWithData (xmlSAXHandlerPtr sax,
 911                                          const char *filename,
 912                                          int recovery,
 913                                          void *data);
 914 XMLPUBFUN xmlDocPtr XMLCALL
 915                 xmlSAXParseEntity       (xmlSAXHandlerPtr sax,
 916                                          const char *filename);
 917 XMLPUBFUN xmlDocPtr XMLCALL
 918                 xmlParseEntity          (const char *filename);
 919 #endif /* LIBXML_SAX1_ENABLED */
 920
 921 #ifdef LIBXML_VALID_ENABLED
 922 XMLPUBFUN xmlDtdPtr XMLCALL
 923                 xmlSAXParseDTD          (xmlSAXHandlerPtr sax,
 924                                          const xmlChar *ExternalID,
 925                                          const xmlChar *SystemID);
 926 XMLPUBFUN xmlDtdPtr XMLCALL
 927                 xmlParseDTD             (const xmlChar *ExternalID,
 928                                          const xmlChar *SystemID);
 929 XMLPUBFUN xmlDtdPtr XMLCALL
 930                 xmlIOParseDTD           (xmlSAXHandlerPtr sax,
 931                                          xmlParserInputBufferPtr input,
 932                                          xmlCharEncoding enc);
 933 #endif /* LIBXML_VALID_ENABLE */
 934 #ifdef LIBXML_SAX1_ENABLED
 935 XMLPUBFUN int XMLCALL
 936                 xmlParseBalancedChunkMemory(xmlDocPtr doc,
 937                                          xmlSAXHandlerPtr sax,
 938                                          void *user_data,
 939                                          int depth,
 940                                          const xmlChar *string,
 941                                          xmlNodePtr *lst);
 942 #endif /* LIBXML_SAX1_ENABLED */
 943 XMLPUBFUN xmlParserErrors XMLCALL
 944                 xmlParseInNodeContext   (xmlNodePtr node,
 945                                          const char *data,
 946                                          int datalen,
 947                                          int options,
 948                                          xmlNodePtr *lst);
 949 #ifdef LIBXML_SAX1_ENABLED
 950 XMLPUBFUN int XMLCALL
 951                 xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,
 952                      xmlSAXHandlerPtr sax,
 953                      void *user_data,
 954                      int depth,
 955                      const xmlChar *string,
 956                      xmlNodePtr *lst,
 957                      int recover);
 958 XMLPUBFUN int XMLCALL
 959                 xmlParseExternalEntity  (xmlDocPtr doc,
 960                                          xmlSAXHandlerPtr sax,
 961                                          void *user_data,
 962                                          int depth,
 963                                          const xmlChar *URL,
 964                                          const xmlChar *ID,
 965                                          xmlNodePtr *lst);
 966 #endif /* LIBXML_SAX1_ENABLED */
 967 XMLPUBFUN int XMLCALL
 968                 xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
 969                                          const xmlChar *URL,
 970                                          const xmlChar *ID,
 971                                          xmlNodePtr *lst);
 972
 973 /*
 974  * Parser contexts handling.
 975  */
 976 XMLPUBFUN xmlParserCtxtPtr XMLCALL
 977                 xmlNewParserCtxt        (void);
 978 XMLPUBFUN int XMLCALL
 979                 xmlInitParserCtxt       (xmlParserCtxtPtr ctxt);
 980 XMLPUBFUN void XMLCALL
 981                 xmlClearParserCtxt      (xmlParserCtxtPtr ctxt);
 982 XMLPUBFUN void XMLCALL
 983                 xmlFreeParserCtxt       (xmlParserCtxtPtr ctxt);
 984 #ifdef LIBXML_SAX1_ENABLED
 985 XMLPUBFUN void XMLCALL
 986                 xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt,
 987                                          const xmlChar* buffer,
 988                                          const char *filename);
 989 #endif /* LIBXML_SAX1_ENABLED */
 990 XMLPUBFUN xmlParserCtxtPtr XMLCALL
 991                 xmlCreateDocParserCtxt  (const xmlChar *cur);
 992
 993 #ifdef LIBXML_LEGACY_ENABLED
 994 /*
 995  * Reading/setting optional parsing features.
 996  */
 997 XMLPUBFUN int XMLCALL
 998                 xmlGetFeaturesList      (int *len,
 999                                          const char **result);
1000 XMLPUBFUN int XMLCALL
1001                 xmlGetFeature           (xmlParserCtxtPtr ctxt,
1002                                          const char *name,
1003                                          void *result);
1004 XMLPUBFUN int XMLCALL
1005                 xmlSetFeature           (xmlParserCtxtPtr ctxt,
1006                                          const char *name,
1007                                          void *value);
1008 #endif /* LIBXML_LEGACY_ENABLED */
1009
1010 #ifdef LIBXML_PUSH_ENABLED
1011 /*
1012  * Interfaces for the Push mode.
1013  */
1014 XMLPUBFUN xmlParserCtxtPtr XMLCALL
1015                 xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
1016                                          void *user_data,
1017                                          const char *chunk,
1018                                          int size,
1019                                          const char *filename);
1020 XMLPUBFUN int XMLCALL
1021                 xmlParseChunk           (xmlParserCtxtPtr ctxt,
1022                                          const char *chunk,
1023                                          int size,
1024                                          int terminate);
1025 #endif /* LIBXML_PUSH_ENABLED */
1026
1027 /*
1028  * Special I/O mode.
1029  */
1030
1031 XMLPUBFUN xmlParserCtxtPtr XMLCALL
1032                 xmlCreateIOParserCtxt   (xmlSAXHandlerPtr sax,
1033                                          void *user_data,
1034                                          xmlInputReadCallback   ioread,
1035                                          xmlInputCloseCallback  ioclose,
1036                                          void *ioctx,
1037                                          xmlCharEncoding enc);
1038
1039 XMLPUBFUN xmlParserInputPtr XMLCALL
1040                 xmlNewIOInputStream     (xmlParserCtxtPtr ctxt,
1041                                          xmlParserInputBufferPtr input,
1042                                          xmlCharEncoding enc);
1043
1044 /*
1045  * Node infos.
1046  */
1047 XMLPUBFUN const xmlParserNodeInfo* XMLCALL
1048                 xmlParserFindNodeInfo   (const xmlParserCtxtPtr ctxt,
1049                                          const xmlNodePtr node);
1050 XMLPUBFUN void XMLCALL
1051                 xmlInitNodeInfoSeq      (xmlParserNodeInfoSeqPtr seq);
1052 XMLPUBFUN void XMLCALL
1053                 xmlClearNodeInfoSeq     (xmlParserNodeInfoSeqPtr seq);
1054 XMLPUBFUN unsigned long XMLCALL
1055                 xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq,
1056                                          const xmlNodePtr node);
1057 XMLPUBFUN void XMLCALL
1058                 xmlParserAddNodeInfo    (xmlParserCtxtPtr ctxt,
1059                                          const xmlParserNodeInfoPtr info);
1060
1061 /*
1062  * External entities handling actually implemented in xmlIO.
1063  */
1064
1065 XMLPUBFUN void XMLCALL
1066                 xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
1067 XMLPUBFUN xmlExternalEntityLoader XMLCALL
1068                 xmlGetExternalEntityLoader(void);
1069 XMLPUBFUN xmlParserInputPtr XMLCALL
1070                 xmlLoadExternalEntity   (const char *URL,
1071                                          const char *ID,
1072                                          xmlParserCtxtPtr ctxt);
1073
1074 /*
1075  * Index lookup, actually implemented in the encoding module
1076  */
1077 XMLPUBFUN long XMLCALL
1078                 xmlByteConsumed         (xmlParserCtxtPtr ctxt);
1079
1080 /*
1081  * New set of simpler/more flexible APIs
1082  */
1083 /**
1084  * xmlParserOption:
1085  *
1086  * This is the set of XML parser options that can be passed down
1087  * to the xmlReadDoc() and similar calls.
1088  */
1089 typedef enum {
1090     XML_PARSE_RECOVER   = 1<<0, /* recover on errors */
1091     XML_PARSE_NOENT     = 1<<1, /* substitute entities */
1092     XML_PARSE_DTDLOAD   = 1<<2, /* load the external subset */
1093     XML_PARSE_DTDATTR   = 1<<3, /* default DTD attributes */
1094     XML_PARSE_DTDVALID  = 1<<4, /* validate with the DTD */
1095     XML_PARSE_NOERROR   = 1<<5, /* suppress error reports */
1096     XML_PARSE_NOWARNING = 1<<6, /* suppress warning reports */
1097     XML_PARSE_PEDANTIC  = 1<<7, /* pedantic error reporting */
1098     XML_PARSE_NOBLANKS  = 1<<8, /* remove blank nodes */
1099     XML_PARSE_SAX1      = 1<<9, /* use the SAX1 interface internally */
1100     XML_PARSE_XINCLUDE  = 1<<10,/* Implement XInclude substitition  */
1101     XML_PARSE_NONET     = 1<<11,/* Forbid network access */
1102     XML_PARSE_NODICT    = 1<<12,/* Do not reuse the context dictionnary */
1103     XML_PARSE_NSCLEAN   = 1<<13,/* remove redundant namespaces declarations */
1104     XML_PARSE_NOCDATA   = 1<<14,/* merge CDATA as text nodes */
1105     XML_PARSE_NOXINCNODE= 1<<15,/* do not generate XINCLUDE START/END nodes */
1106     XML_PARSE_COMPACT   = 1<<16,/* compact small text nodes; no modification of
1107                                    the tree allowed afterwards (will possibly
1108                                    crash if you try to modify the tree) */
1109     XML_PARSE_OLD10     = 1<<17,/* parse using XML-1.0 before update 5 */
1110     XML_PARSE_NOBASEFIX = 1<<18,/* do not fixup XINCLUDE xml:base uris */
1111     XML_PARSE_HUGE      = 1<<19,/* relax any hardcoded limit from the parser */
1112     XML_PARSE_OLDSAX    = 1<<20,/* parse using SAX2 interface before 2.7.0 */
1113     XML_PARSE_IGNORE_ENC= 1<<21,/* ignore internal document encoding hint */
1114     XML_PARSE_BIG_LINES = 1<<22 /* Store big lines numbers in text PSVI field */
1115 } xmlParserOption;
1116
1117 XMLPUBFUN void XMLCALL
1118                 xmlCtxtReset            (xmlParserCtxtPtr ctxt);
1119 XMLPUBFUN int XMLCALL
1120                 xmlCtxtResetPush        (xmlParserCtxtPtr ctxt,
1121                                          const char *chunk,
1122                                          int size,
1123                                          const char *filename,
1124                                          const char *encoding);
1125 XMLPUBFUN int XMLCALL
1126                 xmlCtxtUseOptions       (xmlParserCtxtPtr ctxt,
1127                                          int options);
1128 XMLPUBFUN xmlDocPtr XMLCALL
1129                 xmlReadDoc              (const xmlChar *cur,
1130                                          const char *URL,
1131                                          const char *encoding,
1132                                          int options);
1133 XMLPUBFUN xmlDocPtr XMLCALL
1134                 xmlReadFile             (const char *URL,
1135                                          const char *encoding,
1136                                          int options);
1137 XMLPUBFUN xmlDocPtr XMLCALL
1138                 xmlReadMemory           (const char *buffer,
1139                                          int size,
1140                                          const char *URL,
1141                                          const char *encoding,
1142                                          int options);
1143 XMLPUBFUN xmlDocPtr XMLCALL
1144                 xmlReadFd               (int fd,
1145                                          const char *URL,
1146                                          const char *encoding,
1147                                          int options);
1148 XMLPUBFUN xmlDocPtr XMLCALL
1149                 xmlReadIO               (xmlInputReadCallback ioread,
1150                                          xmlInputCloseCallback ioclose,
1151                                          void *ioctx,
1152                                          const char *URL,
1153                                          const char *encoding,
1154                                          int options);
1155 XMLPUBFUN xmlDocPtr XMLCALL
1156                 xmlCtxtReadDoc          (xmlParserCtxtPtr ctxt,
1157                                          const xmlChar *cur,
1158                                          const char *URL,
1159                                          const char *encoding,
1160                                          int options);
1161 XMLPUBFUN xmlDocPtr XMLCALL
1162                 xmlCtxtReadFile         (xmlParserCtxtPtr ctxt,
1163                                          const char *filename,
1164                                          const char *encoding,
1165                                          int options);
1166 XMLPUBFUN xmlDocPtr XMLCALL
1167                 xmlCtxtReadMemory               (xmlParserCtxtPtr ctxt,
1168                                          const char *buffer,
1169                                          int size,
1170                                          const char *URL,
1171                                          const char *encoding,
1172                                          int options);
1173 XMLPUBFUN xmlDocPtr XMLCALL
1174                 xmlCtxtReadFd           (xmlParserCtxtPtr ctxt,
1175                                          int fd,
1176                                          const char *URL,
1177                                          const char *encoding,
1178                                          int options);
1179 XMLPUBFUN xmlDocPtr XMLCALL
1180                 xmlCtxtReadIO           (xmlParserCtxtPtr ctxt,
1181                                          xmlInputReadCallback ioread,
1182                                          xmlInputCloseCallback ioclose,
1183                                          void *ioctx,
1184                                          const char *URL,
1185                                          const char *encoding,
1186                                          int options);
1187
1188 /*
1189  * Library wide options
1190  */
1191 /**
1192  * xmlFeature:
1193  *
1194  * Used to examine the existance of features that can be enabled
1195  * or disabled at compile-time.
1196  * They used to be called XML_FEATURE_xxx but this clashed with Expat
1197  */
1198 typedef enum {
1199     XML_WITH_THREAD = 1,
1200     XML_WITH_TREE = 2,
1201     XML_WITH_OUTPUT = 3,
1202     XML_WITH_PUSH = 4,
1203     XML_WITH_READER = 5,
1204     XML_WITH_PATTERN = 6,
1205     XML_WITH_WRITER = 7,
1206     XML_WITH_SAX1 = 8,
1207     XML_WITH_FTP = 9,
1208     XML_WITH_HTTP = 10,
1209     XML_WITH_VALID = 11,
1210     XML_WITH_HTML = 12,
1211     XML_WITH_LEGACY = 13,
1212     XML_WITH_C14N = 14,
1213     XML_WITH_CATALOG = 15,
1214     XML_WITH_XPATH = 16,
1215     XML_WITH_XPTR = 17,
1216     XML_WITH_XINCLUDE = 18,
1217     XML_WITH_ICONV = 19,
1218     XML_WITH_ISO8859X = 20,
1219     XML_WITH_UNICODE = 21,
1220     XML_WITH_REGEXP = 22,
1221     XML_WITH_AUTOMATA = 23,
1222     XML_WITH_EXPR = 24,
1223     XML_WITH_SCHEMAS = 25,
1224     XML_WITH_SCHEMATRON = 26,
1225     XML_WITH_MODULES = 27,
1226     XML_WITH_DEBUG = 28,
1227     XML_WITH_DEBUG_MEM = 29,
1228     XML_WITH_DEBUG_RUN = 30,
1229     XML_WITH_ZLIB = 31,
1230     XML_WITH_ICU = 32,
1231     XML_WITH_LZMA = 33,
1232     XML_WITH_NONE = 99999 /* just to be sure of allocation size */
1233 } xmlFeature;
1234
1235 XMLPUBFUN int XMLCALL
1236                 xmlHasFeature           (xmlFeature feature);
1237
1238 #ifdef __cplusplus
1239 }
1240 #endif
1241 #endif /* __XML_PARSER_H__ */