/app/libxml2-2.4.28/include/libxml2/libxml/parser.h


    1 /*
    2  * parser.h : Interfaces, constants and types related to the XML parser.
    3  *
    4  * See Copyright for the status of this software.
    5  *
    6  * daniel@veillard.com
    7  */
    8 
    9 #ifndef __XML_PARSER_H__
   10 #define __XML_PARSER_H__
   11 
   12 #include <libxml/tree.h>
   13 #include <libxml/valid.h>
   14 #include <libxml/entities.h>
   15 
   16 #ifdef __cplusplus
   17 extern "C" {
   18 #endif
   19 
   20 /**
   21  * XML_DEFAULT_VERSION:
   22  *
   23  * The default version of XML used: 1.0
   24  */
   25 #define XML_DEFAULT_VERSION	"1.0"
   26 
   27 /**
   28  * xmlParserInput:
   29  *
   30  * An xmlParserInput is an input flow for the XML processor.
   31  * Each entity parsed is associated an xmlParserInput (except the
   32  * few predefined ones). This is the case both for internal entities
   33  * - in which case the flow is already completely in memory - or
   34  * external entities - in which case we use the buf structure for
   35  * progressive reading and I18N conversions to the internal UTF-8 format.
   36  */
   37 
   38 /**
   39  * xmlParserInputDeallocate:
   40  * @str:  the string to deallocate
   41  *
   42  * Callback for freeing some parser input allocations.
   43  */
   44 typedef void (* xmlParserInputDeallocate)(xmlChar *str);
   45 
   46 struct _xmlParserInput {
   47     /* Input buffer */
   48     xmlParserInputBufferPtr buf;      /* UTF-8 encoded buffer */
   49 
   50     const char *filename;             /* The file analyzed, if any */
   51     const char *directory;            /* the directory/base of the file */
   52     const xmlChar *base;              /* Base of the array to parse */
   53     const xmlChar *cur;               /* Current char being parsed */
   54     const xmlChar *end;               /* end of the array to parse */
   55     int length;                       /* length if known */
   56     int line;                         /* Current line */
   57     int col;                          /* Current column */
   58     int consumed;                     /* How many xmlChars already consumed */
   59     xmlParserInputDeallocate free;    /* function to deallocate the base */
   60     const xmlChar *encoding;          /* the encoding string for entity */
   61     const xmlChar *version;           /* the version string for entity */
   62     int standalone;                   /* Was that entity marked standalone */
   63 };
   64 
   65 /**
   66  * xmlParserNodeInfo:
   67  *
   68  * The parser can be asked to collect Node informations, i.e. at what
   69  * place in the file they were detected. 
   70  * NOTE: This is off by default and not very well tested.
   71  */
   72 typedef struct _xmlParserNodeInfo xmlParserNodeInfo;
   73 typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;
   74 
   75 struct _xmlParserNodeInfo {
   76   const struct _xmlNode* node;
   77   /* Position & line # that text that created the node begins & ends on */
   78   unsigned long begin_pos;
   79   unsigned long begin_line;
   80   unsigned long end_pos;
   81   unsigned long end_line;
   82 };
   83 
   84 typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq;
   85 typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;
   86 struct _xmlParserNodeInfoSeq {
   87   unsigned long maximum;
   88   unsigned long length;
   89   xmlParserNodeInfo* buffer;
   90 };
   91 
   92 /**
   93  * xmlParserInputState:
   94  *
   95  * The parser is now working also as a state based parser.
   96  * The recursive one use the state info for entities processing.
   97  */
   98 typedef enum {
   99     XML_PARSER_EOF = -1,	/* nothing is to be parsed */
  100     XML_PARSER_START = 0,	/* nothing has been parsed */
  101     XML_PARSER_MISC,		/* Misc* before int subset */
  102     XML_PARSER_PI,		/* Within a processing instruction */
  103     XML_PARSER_DTD,		/* within some DTD content */
  104     XML_PARSER_PROLOG,		/* Misc* after internal subset */
  105     XML_PARSER_COMMENT,		/* within a comment */
  106     XML_PARSER_START_TAG,	/* within a start tag */
  107     XML_PARSER_CONTENT,		/* within the content */
  108     XML_PARSER_CDATA_SECTION,	/* within a CDATA section */
  109     XML_PARSER_END_TAG,		/* within a closing tag */
  110     XML_PARSER_ENTITY_DECL,	/* within an entity declaration */
  111     XML_PARSER_ENTITY_VALUE,	/* within an entity value in a decl */
  112     XML_PARSER_ATTRIBUTE_VALUE,	/* within an attribute value */
  113     XML_PARSER_SYSTEM_LITERAL,	/* within a SYSTEM value */
  114     XML_PARSER_EPILOG, 		/* the Misc* after the last end tag */
  115     XML_PARSER_IGNORE,		/* within an IGNORED section */
  116     XML_PARSER_PUBLIC_LITERAL 	/* within a PUBLIC value */
  117 } xmlParserInputState;
  118 
  119 /**
  120  * XML_DETECT_IDS:
  121  *
  122  * Bit in the loadsubset context field to tell to do ID/REFs lookups.
  123  * Use it to initialize xmlLoadExtDtdDefaultValue.
  124  */
  125 #define XML_DETECT_IDS		2
  126 
  127 /**
  128  * XML_COMPLETE_ATTRS:
  129  *
  130  * Bit in the loadsubset context field to tell to do complete the
  131  * elements attributes lists with the ones defaulted from the DTDs.
  132  * Use it to initialize xmlLoadExtDtdDefaultValue.
  133  */
  134 #define XML_COMPLETE_ATTRS	4
  135 
  136 /**
  137  * xmlParserCtxt:
  138  *
  139  * The parser context.
  140  * NOTE This doesn't completely define the parser state, the (current ?)
  141  *      design of the parser uses recursive function calls since this allow
  142  *      and easy mapping from the production rules of the specification
  143  *      to the actual code. The drawback is that the actual function call
  144  *      also reflect the parser state. However most of the parsing routines
  145  *      takes as the only argument the parser context pointer, so migrating
  146  *      to a state based parser for progressive parsing shouldn't be too hard.
  147  */
  148 struct _xmlParserCtxt {
  149     struct _xmlSAXHandler *sax;       /* The SAX handler */
  150     void            *userData;        /* For SAX interface only, used by DOM build */
  151     xmlDocPtr           myDoc;        /* the document being built */
  152     int            wellFormed;        /* is the document well formed */
  153     int       replaceEntities;        /* shall we replace entities ? */
  154     const xmlChar    *version;        /* the XML version string */
  155     const xmlChar   *encoding;        /* the declared encoding, if any */
  156     int            standalone;        /* standalone document */
  157     int                  html;        /* an HTML(1)/Docbook(2) document */
  158 
  159     /* Input stream stack */
  160     xmlParserInputPtr  input;         /* Current input stream */
  161     int                inputNr;       /* Number of current input streams */
  162     int                inputMax;      /* Max number of input streams */
  163     xmlParserInputPtr *inputTab;      /* stack of inputs */
  164 
  165     /* Node analysis stack only used for DOM building */
  166     xmlNodePtr         node;          /* Current parsed Node */
  167     int                nodeNr;        /* Depth of the parsing stack */
  168     int                nodeMax;       /* Max depth of the parsing stack */
  169     xmlNodePtr        *nodeTab;       /* array of nodes */
  170 
  171     int record_info;                  /* Whether node info should be kept */
  172     xmlParserNodeInfoSeq node_seq;    /* info about each node parsed */
  173 
  174     int errNo;                        /* error code */
  175 
  176     int     hasExternalSubset;        /* reference and external subset */
  177     int             hasPErefs;        /* the internal subset has PE refs */
  178     int              external;        /* are we parsing an external entity */
  179 
  180     int                 valid;        /* is the document valid */
  181     int              validate;        /* shall we try to validate ? */
  182     xmlValidCtxt        vctxt;        /* The validity context */
  183 
  184     xmlParserInputState instate;      /* current type of input */
  185     int                 token;        /* next char look-ahead */    
  186 
  187     char           *directory;        /* the data directory */
  188 
  189     /* Node name stack */
  190     xmlChar           *name;          /* Current parsed Node */
  191     int                nameNr;        /* Depth of the parsing stack */
  192     int                nameMax;       /* Max depth of the parsing stack */
  193     xmlChar *         *nameTab;       /* array of nodes */
  194 
  195     long               nbChars;       /* number of xmlChar processed */
  196     long            checkIndex;       /* used by progressive parsing lookup */
  197     int             keepBlanks;       /* ugly but ... */
  198     int             disableSAX;       /* SAX callbacks are disabled */
  199     int               inSubset;       /* Parsing is in int 1/ext 2 subset */
  200     xmlChar *          intSubName;    /* name of subset */
  201     xmlChar *          extSubURI;     /* URI of external subset */
  202     xmlChar *          extSubSystem;  /* SYSTEM ID of external subset */
  203 
  204     /* xml:space values */
  205     int *              space;         /* Should the parser preserve spaces */
  206     int                spaceNr;       /* Depth of the parsing stack */
  207     int                spaceMax;      /* Max depth of the parsing stack */
  208     int *              spaceTab;      /* array of space infos */
  209 
  210     int                depth;         /* to prevent entity substitution loops */
  211     xmlParserInputPtr  entity;        /* used to check entities boundaries */
  212     int                charset;       /* encoding of the in-memory content
  213 				         actually an xmlCharEncoding */
  214     int                nodelen;       /* Those two fields are there to */
  215     int                nodemem;       /* Speed up large node parsing */
  216     int                pedantic;      /* signal pedantic warnings */
  217     void              *_private;      /* For user data, libxml won't touch it */
  218 
  219     int                loadsubset;    /* should the external subset be loaded */
  220     int                linenumbers;   /* set line number in element content */
  221     void              *catalogs;       /* document's own catalog */
  222     int                recovery;      /* run in recovery mode */
  223 };
  224 
  225 /**
  226  * xmlSAXLocator:
  227  *
  228  * A SAX Locator.
  229  */
  230 struct _xmlSAXLocator {
  231     const xmlChar *(*getPublicId)(void *ctx);
  232     const xmlChar *(*getSystemId)(void *ctx);
  233     int (*getLineNumber)(void *ctx);
  234     int (*getColumnNumber)(void *ctx);
  235 };
  236 
  237 /**
  238  * xmlSAXHandler:
  239  *
  240  * A SAX handler is bunch of callbacks called by the parser when processing
  241  * of the input generate data or structure informations.
  242  */
  243 
  244 /**
  245  * resolveEntitySAXFunc:
  246  * @ctx:  the user data (XML parser context)
  247  * @publicId: The public ID of the entity
  248  * @systemId: The system ID of the entity
  249  *
  250  * Callback:
  251  * The entity loader, to control the loading of external entities,
  252  * the application can either:
  253  *    - override this resolveEntity() callback in the SAX block
  254  *    - or better use the xmlSetExternalEntityLoader() function to
  255  *      set up it's own entity resolution routine
  256  *
  257  * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
  258  */
  259 typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx,
  260 				const xmlChar *publicId,
  261 				const xmlChar *systemId);
  262 /**
  263  * internalSubsetSAXFunc:
  264  * @ctx:  the user data (XML parser context)
  265  * @name:  the root element name
  266  * @ExternalID:  the external ID
  267  * @SystemID:  the SYSTEM ID (e.g. filename or URL)
  268  *
  269  * Callback on internal subset declaration.
  270  */
  271 typedef void (*internalSubsetSAXFunc) (void *ctx,
  272 				const xmlChar *name,
  273 				const xmlChar *ExternalID,
  274 				const xmlChar *SystemID);
  275 /**
  276  * externalSubsetSAXFunc:
  277  * @ctx:  the user data (XML parser context)
  278  * @name:  the root element name
  279  * @ExternalID:  the external ID
  280  * @SystemID:  the SYSTEM ID (e.g. filename or URL)
  281  *
  282  * Callback on external subset declaration.
  283  */
  284 typedef void (*externalSubsetSAXFunc) (void *ctx,
  285 				const xmlChar *name,
  286 				const xmlChar *ExternalID,
  287 				const xmlChar *SystemID);
  288 /**
  289  * getEntitySAXFunc:
  290  * @ctx:  the user data (XML parser context)
  291  * @name: The entity name
  292  *
  293  * Get an entity by name.
  294  *
  295  * Returns the xmlEntityPtr if found.
  296  */
  297 typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx,
  298 				const xmlChar *name);
  299 /**
  300  * getParameterEntitySAXFunc:
  301  * @ctx:  the user data (XML parser context)
  302  * @name: The entity name
  303  *
  304  * Get a parameter entity by name.
  305  *
  306  * Returns the xmlEntityPtr if found.
  307  */
  308 typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx,
  309 				const xmlChar *name);
  310 /**
  311  * entityDeclSAXFunc:
  312  * @ctx:  the user data (XML parser context)
  313  * @name:  the entity name 
  314  * @type:  the entity type 
  315  * @publicId: The public ID of the entity
  316  * @systemId: The system ID of the entity
  317  * @content: the entity value (without processing).
  318  *
  319  * An entity definition has been parsed.
  320  */
  321 typedef void (*entityDeclSAXFunc) (void *ctx,
  322 				const xmlChar *name,
  323 				int type,
  324 				const xmlChar *publicId,
  325 				const xmlChar *systemId,
  326 				xmlChar *content);
  327 /**
  328  * notationDeclSAXFunc:
  329  * @ctx:  the user data (XML parser context)
  330  * @name: The name of the notation
  331  * @publicId: The public ID of the entity
  332  * @systemId: The system ID of the entity
  333  *
  334  * What to do when a notation declaration has been parsed.
  335  */
  336 typedef void (*notationDeclSAXFunc)(void *ctx,
  337 				const xmlChar *name,
  338 				const xmlChar *publicId,
  339 				const xmlChar *systemId);
  340 /**
  341  * attributeDeclSAXFunc:
  342  * @ctx:  the user data (XML parser context)
  343  * @elem:  the name of the element
  344  * @fullname:  the attribute name 
  345  * @type:  the attribute type 
  346  * @def:  the type of default value
  347  * @defaultValue: the attribute default value
  348  * @tree:  the tree of enumerated value set
  349  *
  350  * An attribute definition has been parsed.
  351  */
  352 typedef void (*attributeDeclSAXFunc)(void *ctx,
  353 				const xmlChar *elem,
  354 				const xmlChar *fullname,
  355 				int type,
  356 				int def,
  357 				const xmlChar *defaultValue,
  358 				xmlEnumerationPtr tree);
  359 /**
  360  * elementDeclSAXFunc:
  361  * @ctx:  the user data (XML parser context)
  362  * @name:  the element name 
  363  * @type:  the element type 
  364  * @content: the element value tree
  365  *
  366  * An element definition has been parsed.
  367  */
  368 typedef void (*elementDeclSAXFunc)(void *ctx,
  369 				const xmlChar *name,
  370 				int type,
  371 				xmlElementContentPtr content);
  372 /**
  373  * unparsedEntityDeclSAXFunc:
  374  * @ctx:  the user data (XML parser context)
  375  * @name: The name of the entity
  376  * @publicId: The public ID of the entity
  377  * @systemId: The system ID of the entity
  378  * @notationName: the name of the notation
  379  *
  380  * What to do when an unparsed entity declaration is parsed.
  381  */
  382 typedef void (*unparsedEntityDeclSAXFunc)(void *ctx,
  383 				const xmlChar *name,
  384 				const xmlChar *publicId,
  385 				const xmlChar *systemId,
  386 				const xmlChar *notationName);
  387 /**
  388  * setDocumentLocatorSAXFunc:
  389  * @ctx:  the user data (XML parser context)
  390  * @loc: A SAX Locator
  391  *
  392  * Receive the document locator at startup, actually xmlDefaultSAXLocator.
  393  * Everything is available on the context, so this is useless in our case.
  394  */
  395 typedef void (*setDocumentLocatorSAXFunc) (void *ctx,
  396 				xmlSAXLocatorPtr loc);
  397 /**
  398  * startDocumentSAXFunc:
  399  * @ctx:  the user data (XML parser context)
  400  *
  401  * Called when the document start being processed.
  402  */
  403 typedef void (*startDocumentSAXFunc) (void *ctx);
  404 /**
  405  * endDocumentSAXFunc:
  406  * @ctx:  the user data (XML parser context)
  407  *
  408  * Called when the document end has been detected.
  409  */
  410 typedef void (*endDocumentSAXFunc) (void *ctx);
  411 /**
  412  * startElementSAXFunc:
  413  * @ctx:  the user data (XML parser context)
  414  * @name:  The element name, including namespace prefix
  415  * @atts:  An array of name/value attributes pairs, NULL terminated
  416  *
  417  * Called when an opening tag has been processed.
  418  */
  419 typedef void (*startElementSAXFunc) (void *ctx,
  420 				const xmlChar *name,
  421 				const xmlChar **atts);
  422 /**
  423  * endElementSAXFunc:
  424  * @ctx:  the user data (XML parser context)
  425  * @name:  The element name
  426  *
  427  * Called when the end of an element has been detected.
  428  */
  429 typedef void (*endElementSAXFunc) (void *ctx,
  430 				const xmlChar *name);
  431 /**
  432  * attributeSAXFunc:
  433  * @ctx:  the user data (XML parser context)
  434  * @name:  The attribute name, including namespace prefix
  435  * @value:  The attribute value
  436  *
  437  * Handle an attribute that has been read by the parser.
  438  * The default handling is to convert the attribute into an
  439  * DOM subtree and past it in a new xmlAttr element added to
  440  * the element.
  441  */
  442 typedef void (*attributeSAXFunc) (void *ctx,
  443 				const xmlChar *name,
  444 				const xmlChar *value);
  445 /**
  446  * referenceSAXFunc:
  447  * @ctx:  the user data (XML parser context)
  448  * @name:  The entity name
  449  *
  450  * Called when an entity reference is detected. 
  451  */
  452 typedef void (*referenceSAXFunc) (void *ctx,
  453 				const xmlChar *name);
  454 /**
  455  * charactersSAXFunc:
  456  * @ctx:  the user data (XML parser context)
  457  * @ch:  a xmlChar string
  458  * @len: the number of xmlChar
  459  *
  460  * Receiving some chars from the parser.
  461  */
  462 typedef void (*charactersSAXFunc) (void *ctx,
  463 				const xmlChar *ch,
  464 				int len);
  465 /**
  466  * ignorableWhitespaceSAXFunc:
  467  * @ctx:  the user data (XML parser context)
  468  * @ch:  a xmlChar string
  469  * @len: the number of xmlChar
  470  *
  471  * Receiving some ignorable whitespaces from the parser.
  472  * UNUSED: by default the DOM building will use characters.
  473  */
  474 typedef void (*ignorableWhitespaceSAXFunc) (void *ctx,
  475 				const xmlChar *ch,
  476 				int len);
  477 /**
  478  * processingInstructionSAXFunc:
  479  * @ctx:  the user data (XML parser context)
  480  * @target:  the target name
  481  * @data: the PI data's
  482  *
  483  * A processing instruction has been parsed.
  484  */
  485 typedef void (*processingInstructionSAXFunc) (void *ctx,
  486 				const xmlChar *target,
  487 				const xmlChar *data);
  488 /**
  489  * commentSAXFunc:
  490  * @ctx:  the user data (XML parser context)
  491  * @value:  the comment content
  492  *
  493  * A comment has been parsed.
  494  */
  495 typedef void (*commentSAXFunc) (void *ctx,
  496 				const xmlChar *value);
  497 /**
  498  * cdataBlockSAXFunc:
  499  * @ctx:  the user data (XML parser context)
  500  * @value:  The pcdata content
  501  * @len:  the block length
  502  *
  503  * Called when a pcdata block has been parsed.
  504  */
  505 typedef void (*cdataBlockSAXFunc) (
  506 	                        void *ctx,
  507 				const xmlChar *value,
  508 				int len);
  509 /**
  510  * warningSAXFunc:
  511  * @ctx:  an XML parser context
  512  * @msg:  the message to display/transmit
  513  * @...:  extra parameters for the message display
  514  * 
  515  * Display and format a warning messages, callback.
  516  */
  517 typedef void (*warningSAXFunc) (void *ctx,
  518 				const char *msg, ...);
  519 /**
  520  * errorSAXFunc:
  521  * @ctx:  an XML parser context
  522  * @msg:  the message to display/transmit
  523  * @...:  extra parameters for the message display
  524  * 
  525  * Display and format an error messages, callback.
  526  */
  527 typedef void (*errorSAXFunc) (void *ctx,
  528 				const char *msg, ...);
  529 /**
  530  * fatalErrorSAXFunc:
  531  * @ctx:  an XML parser context
  532  * @msg:  the message to display/transmit
  533  * @...:  extra parameters for the message display
  534  * 
  535  * Display and format fatal error messages, callback.
  536  * Note: so far fatalError() SAX callbacks are not used, error()
  537  *       get all the callbacks for errors.
  538  */
  539 typedef void (*fatalErrorSAXFunc) (void *ctx,
  540 				const char *msg, ...);
  541 /**
  542  * isStandaloneSAXFunc:
  543  * @ctx:  the user data (XML parser context)
  544  *
  545  * Is this document tagged standalone?
  546  *
  547  * Returns 1 if true
  548  */
  549 typedef int (*isStandaloneSAXFunc) (void *ctx);
  550 /**
  551  * hasInternalSubsetSAXFunc:
  552  * @ctx:  the user data (XML parser context)
  553  *
  554  * Does this document has an internal subset.
  555  *
  556  * Returns 1 if true
  557  */
  558 typedef int (*hasInternalSubsetSAXFunc) (void *ctx);
  559 /**
  560  * hasExternalSubsetSAXFunc:
  561  * @ctx:  the user data (XML parser context)
  562  *
  563  * Does this document has an external subset?
  564  *
  565  * Returns 1 if true
  566  */
  567 typedef int (*hasExternalSubsetSAXFunc) (void *ctx);
  568 
  569 struct _xmlSAXHandler {
  570     internalSubsetSAXFunc internalSubset;
  571     isStandaloneSAXFunc isStandalone;
  572     hasInternalSubsetSAXFunc hasInternalSubset;
  573     hasExternalSubsetSAXFunc hasExternalSubset;
  574     resolveEntitySAXFunc resolveEntity;
  575     getEntitySAXFunc getEntity;
  576     entityDeclSAXFunc entityDecl;
  577     notationDeclSAXFunc notationDecl;
  578     attributeDeclSAXFunc attributeDecl;
  579     elementDeclSAXFunc elementDecl;
  580     unparsedEntityDeclSAXFunc unparsedEntityDecl;
  581     setDocumentLocatorSAXFunc setDocumentLocator;
  582     startDocumentSAXFunc startDocument;
  583     endDocumentSAXFunc endDocument;
  584     startElementSAXFunc startElement;
  585     endElementSAXFunc endElement;
  586     referenceSAXFunc reference;
  587     charactersSAXFunc characters;
  588     ignorableWhitespaceSAXFunc ignorableWhitespace;
  589     processingInstructionSAXFunc processingInstruction;
  590     commentSAXFunc comment;
  591     warningSAXFunc warning;
  592     errorSAXFunc error;
  593     fatalErrorSAXFunc fatalError; /* unused error() get all the errors */
  594     getParameterEntitySAXFunc getParameterEntity;
  595     cdataBlockSAXFunc cdataBlock;
  596     externalSubsetSAXFunc externalSubset;
  597     int initialized;
  598 };
  599 
  600 /**
  601  * xmlExternalEntityLoader:
  602  * @URL: The System ID of the resource requested
  603  * @ID: The Public ID of the resource requested
  604  * @context: the XML parser context 
  605  *
  606  * External entity loaders types.
  607  *
  608  * Returns the entity input parser.
  609  */
  610 typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL,
  611 					 const char *ID,
  612 					 xmlParserCtxtPtr context);
  613 
  614 /*
  615  * Global variables: just the default SAX interface tables and XML
  616  * version infos.
  617  */
  618 #if 0
  619 LIBXML_DLL_IMPORT extern const char *xmlParserVersion;
  620 #endif
  621 
  622 /*
  623 LIBXML_DLL_IMPORT extern xmlSAXLocator xmlDefaultSAXLocator;
  624 LIBXML_DLL_IMPORT extern xmlSAXHandler xmlDefaultSAXHandler;
  625 LIBXML_DLL_IMPORT extern xmlSAXHandler htmlDefaultSAXHandler;
  626 LIBXML_DLL_IMPORT extern xmlSAXHandler docbDefaultSAXHandler;
  627  */
  628 
  629 /*
  630  * Entity substitution default behavior.
  631  */
  632 
  633 #if 0
  634 LIBXML_DLL_IMPORT extern int xmlSubstituteEntitiesDefaultValue;
  635 LIBXML_DLL_IMPORT extern int xmlGetWarningsDefaultValue;
  636 #endif
  637 
  638 #ifdef __cplusplus
  639 }
  640 #endif
  641 #include <libxml/encoding.h>
  642 #include <libxml/xmlIO.h>
  643 #include <libxml/globals.h>
  644 #ifdef __cplusplus
  645 extern "C" {
  646 #endif
  647 
  648 
  649 /*
  650  * Init/Cleanup
  651  */
  652 void		xmlInitParser		(void);
  653 void		xmlCleanupParser	(void);
  654 
  655 /*
  656  * Input functions
  657  */
  658 int		xmlParserInputRead	(xmlParserInputPtr in,
  659 					 int len);
  660 int		xmlParserInputGrow	(xmlParserInputPtr in,
  661 					 int len);
  662 
  663 /*
  664  * xmlChar handling
  665  */
  666 xmlChar *	xmlStrdup		(const xmlChar *cur);
  667 xmlChar *	xmlStrndup		(const xmlChar *cur,
  668 					 int len);
  669 xmlChar *	xmlCharStrndup		(const char *cur,
  670 					 int len);
  671 xmlChar *	xmlCharStrdup		(const char *cur);
  672 xmlChar *	xmlStrsub		(const xmlChar *str,
  673 					 int start,
  674 					 int len);
  675 const xmlChar *	xmlStrchr		(const xmlChar *str,
  676 					 xmlChar val);
  677 const xmlChar *	xmlStrstr		(const xmlChar *str,
  678 					 const xmlChar *val);
  679 const xmlChar *	xmlStrcasestr		(const xmlChar *str,
  680 					 xmlChar *val);
  681 int		xmlStrcmp		(const xmlChar *str1,
  682 					 const xmlChar *str2);
  683 int		xmlStrncmp		(const xmlChar *str1,
  684 					 const xmlChar *str2,
  685 					 int len);
  686 int		xmlStrcasecmp		(const xmlChar *str1,
  687 					 const xmlChar *str2);
  688 int		xmlStrncasecmp		(const xmlChar *str1,
  689 					 const xmlChar *str2,
  690 					 int len);
  691 int		xmlStrEqual		(const xmlChar *str1,
  692 					 const xmlChar *str2);
  693 int		xmlStrlen		(const xmlChar *str);
  694 xmlChar *	xmlStrcat		(xmlChar *cur,
  695 					 const xmlChar *add);
  696 xmlChar *	xmlStrncat		(xmlChar *cur,
  697 					 const xmlChar *add,
  698 					 int len);
  699 
  700 /*
  701  * Basic parsing Interfaces
  702  */
  703 xmlDocPtr	xmlParseDoc		(xmlChar *cur);
  704 xmlDocPtr	xmlParseMemory		(const char *buffer,
  705 					 int size);
  706 xmlDocPtr	xmlParseFile		(const char *filename);
  707 int		xmlSubstituteEntitiesDefault(int val);
  708 int		xmlKeepBlanksDefault	(int val);
  709 void		xmlStopParser		(xmlParserCtxtPtr ctxt);
  710 int		xmlPedanticParserDefault(int val);
  711 int		xmlLineNumbersDefault	(int val);
  712 
  713 /*
  714  * Recovery mode 
  715  */
  716 xmlDocPtr	xmlRecoverDoc		(xmlChar *cur);
  717 xmlDocPtr	xmlRecoverMemory	(const char *buffer,
  718 					 int size);
  719 xmlDocPtr	xmlRecoverFile		(const char *filename);
  720 
  721 /*
  722  * Less common routines and SAX interfaces
  723  */
  724 int		xmlParseDocument	(xmlParserCtxtPtr ctxt);
  725 int		xmlParseExtParsedEnt	(xmlParserCtxtPtr ctxt);
  726 xmlDocPtr	xmlSAXParseDoc		(xmlSAXHandlerPtr sax,
  727 					 xmlChar *cur,
  728 					 int recovery);
  729 int		xmlSAXUserParseFile	(xmlSAXHandlerPtr sax,
  730 					 void *user_data,
  731 					 const char *filename);
  732 int		xmlSAXUserParseMemory	(xmlSAXHandlerPtr sax,
  733 					 void *user_data,
  734 					 const char *buffer,
  735 					 int size);
  736 xmlDocPtr	xmlSAXParseMemory	(xmlSAXHandlerPtr sax,
  737 					 const char *buffer,
  738                                    	 int size,
  739 					 int recovery);
  740 xmlDocPtr	xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax,
  741 					 const char *buffer,
  742                                    	 int size,
  743 					 int recovery,
  744 					 void *data);
  745 xmlDocPtr	xmlSAXParseFile		(xmlSAXHandlerPtr sax,
  746 					 const char *filename,
  747 					 int recovery);
  748 xmlDocPtr	xmlSAXParseFileWithData	(xmlSAXHandlerPtr sax,
  749 					 const char *filename,
  750 					 int recovery,
  751 					 void *data);
  752 xmlDocPtr	xmlSAXParseEntity	(xmlSAXHandlerPtr sax,
  753 					 const char *filename);
  754 xmlDocPtr	xmlParseEntity		(const char *filename);
  755 xmlDtdPtr	xmlParseDTD		(const xmlChar *ExternalID,
  756 					 const xmlChar *SystemID);
  757 xmlDtdPtr	xmlSAXParseDTD		(xmlSAXHandlerPtr sax,
  758 					 const xmlChar *ExternalID,
  759 					 const xmlChar *SystemID);
  760 xmlDtdPtr	xmlIOParseDTD		(xmlSAXHandlerPtr sax,
  761 					 xmlParserInputBufferPtr input,
  762 					 xmlCharEncoding enc);
  763 int		xmlParseBalancedChunkMemory(xmlDocPtr doc,
  764 					 xmlSAXHandlerPtr sax,
  765 					 void *user_data,
  766 					 int depth,
  767 					 const xmlChar *string,
  768 					 xmlNodePtr *lst);
  769 int           xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,
  770                      xmlSAXHandlerPtr sax,
  771                      void *user_data,
  772                      int depth,
  773                      const xmlChar *string,
  774                      xmlNodePtr *lst,
  775                      int recover);
  776 int		xmlParseExternalEntity	(xmlDocPtr doc,
  777 					 xmlSAXHandlerPtr sax,
  778 					 void *user_data,
  779 					 int depth,
  780 					 const xmlChar *URL,
  781 					 const xmlChar *ID,
  782 					 xmlNodePtr *lst);
  783 int		xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
  784 					 const xmlChar *URL,
  785 					 const xmlChar *ID,
  786 					 xmlNodePtr *lst);
  787 
  788 /*
  789  * Parser contexts handling.
  790  */
  791 void		xmlInitParserCtxt	(xmlParserCtxtPtr ctxt);
  792 void		xmlClearParserCtxt	(xmlParserCtxtPtr ctxt);
  793 void		xmlFreeParserCtxt	(xmlParserCtxtPtr ctxt);
  794 void		xmlSetupParserForBuffer	(xmlParserCtxtPtr ctxt,
  795 					 const xmlChar* buffer,
  796 					 const char *filename);
  797 xmlParserCtxtPtr xmlCreateDocParserCtxt	(xmlChar *cur);
  798 
  799 /*
  800  * Reading/setting optional parsing features.
  801  */
  802 
  803 int		xmlGetFeaturesList	(int *len,
  804 					 const char **result);
  805 int		xmlGetFeature		(xmlParserCtxtPtr ctxt,
  806 					 const char *name,
  807 					 void *result);
  808 int		xmlSetFeature		(xmlParserCtxtPtr ctxt,
  809 					 const char *name,
  810 					 void *value);
  811 
  812 /*
  813  * Interfaces for the Push mode.
  814  */
  815 xmlParserCtxtPtr xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
  816 					 void *user_data,
  817 					 const char *chunk,
  818 					 int size,
  819 					 const char *filename);
  820 int		 xmlParseChunk		(xmlParserCtxtPtr ctxt,
  821 					 const char *chunk,
  822 					 int size,
  823 					 int terminate);
  824 
  825 /*
  826  * Special I/O mode.
  827  */
  828 
  829 xmlParserCtxtPtr xmlCreateIOParserCtxt	(xmlSAXHandlerPtr sax,
  830 					 void *user_data,
  831 					 xmlInputReadCallback   ioread,
  832 					 xmlInputCloseCallback  ioclose,
  833 					 void *ioctx,
  834 					 xmlCharEncoding enc);
  835 
  836 xmlParserInputPtr xmlNewIOInputStream	(xmlParserCtxtPtr ctxt,
  837 					 xmlParserInputBufferPtr input,
  838 					 xmlCharEncoding enc);
  839 
  840 /*
  841  * Node infos.
  842  */
  843 const xmlParserNodeInfo*
  844 		xmlParserFindNodeInfo	(const xmlParserCtxtPtr ctxt,
  845 				         const xmlNodePtr node);
  846 void		xmlInitNodeInfoSeq	(xmlParserNodeInfoSeqPtr seq);
  847 void		xmlClearNodeInfoSeq	(xmlParserNodeInfoSeqPtr seq);
  848 unsigned long xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq,
  849                                          const xmlNodePtr node);
  850 void		xmlParserAddNodeInfo	(xmlParserCtxtPtr ctxt,
  851 					 const xmlParserNodeInfoPtr info);
  852 
  853 /*
  854  * External entities handling actually implemented in xmlIO.
  855  */
  856 
  857 void		xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
  858 xmlExternalEntityLoader
  859 		xmlGetExternalEntityLoader(void);
  860 xmlParserInputPtr
  861 		xmlLoadExternalEntity	(const char *URL,
  862 					 const char *ID,
  863 					 xmlParserCtxtPtr ctxt);
  864 
  865 #ifdef __cplusplus
  866 }
  867 #endif
  868 #endif /* __XML_PARSER_H__ */
  869