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