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
25extern "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 */
52typedef void (* xmlParserInputDeallocate)(xmlChar *str);
53
54struct _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 */
86typedef struct _xmlParserNodeInfo xmlParserNodeInfo;
87typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;
88
89struct _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
98typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq;
99typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;
100struct _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 */
112typedef 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 */
163typedef 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 */
184struct _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 */
307struct _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 */
336typedef 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 */
348typedef 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 */
361typedef 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 */
374typedef 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 */
385typedef 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 */
398typedef 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 */
413typedef 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 */
429typedef 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 */
445typedef 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 */
459typedef 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 */
472typedef 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 */
480typedef 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 */
487typedef 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 */
496typedef 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 */
506typedef 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 */
519typedef 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 */
529typedef 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 */
539typedef 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 */
551typedef 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 */
562typedef 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 */
572typedef 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 */
582typedef 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 */
594typedef 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 */
604typedef 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 */
616typedef 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 */
626typedef 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 */
635typedef 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 */
645typedef 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
678typedef 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
699typedef void (*endElementNsSAX2Func)   (void *ctx,
700					const xmlChar *localname,
701					const xmlChar *prefix,
702					const xmlChar *URI);
703
704
705struct _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 */
744typedef struct _xmlSAXHandlerV1 xmlSAXHandlerV1;
745typedef xmlSAXHandlerV1 *xmlSAXHandlerV1Ptr;
746struct _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 */
788typedef 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
801extern "C" {
802#endif
803
804
805/*
806 * Init/Cleanup
807 */
808XMLPUBFUN void XMLCALL
809		xmlInitParser		(void);
810XMLPUBFUN void XMLCALL
811		xmlCleanupParser	(void);
812
813/*
814 * Input functions
815 */
816XMLPUBFUN int XMLCALL
817		xmlParserInputRead	(xmlParserInputPtr in,
818					 int len);
819XMLPUBFUN int XMLCALL
820		xmlParserInputGrow	(xmlParserInputPtr in,
821					 int len);
822
823/*
824 * Basic parsing Interfaces
825 */
826#ifdef LIBXML_SAX1_ENABLED
827XMLPUBFUN xmlDocPtr XMLCALL
828		xmlParseDoc		(const xmlChar *cur);
829XMLPUBFUN xmlDocPtr XMLCALL
830		xmlParseFile		(const char *filename);
831XMLPUBFUN xmlDocPtr XMLCALL
832		xmlParseMemory		(const char *buffer,
833					 int size);
834#endif /* LIBXML_SAX1_ENABLED */
835XMLPUBFUN int XMLCALL
836		xmlSubstituteEntitiesDefault(int val);
837XMLPUBFUN int XMLCALL
838		xmlKeepBlanksDefault	(int val);
839XMLPUBFUN void XMLCALL
840		xmlStopParser		(xmlParserCtxtPtr ctxt);
841XMLPUBFUN int XMLCALL
842		xmlPedanticParserDefault(int val);
843XMLPUBFUN int XMLCALL
844		xmlLineNumbersDefault	(int val);
845
846#ifdef LIBXML_SAX1_ENABLED
847/*
848 * Recovery mode
849 */
850XMLPUBFUN xmlDocPtr XMLCALL
851		xmlRecoverDoc		(xmlChar *cur);
852XMLPUBFUN xmlDocPtr XMLCALL
853		xmlRecoverMemory	(const char *buffer,
854					 int size);
855XMLPUBFUN xmlDocPtr XMLCALL
856		xmlRecoverFile		(const char *filename);
857#endif /* LIBXML_SAX1_ENABLED */
858
859/*
860 * Less common routines and SAX interfaces
861 */
862XMLPUBFUN int XMLCALL
863		xmlParseDocument	(xmlParserCtxtPtr ctxt);
864XMLPUBFUN int XMLCALL
865		xmlParseExtParsedEnt	(xmlParserCtxtPtr ctxt);
866#ifdef LIBXML_SAX1_ENABLED
867XMLPUBFUN int XMLCALL
868		xmlSAXUserParseFile	(xmlSAXHandlerPtr sax,
869					 void *user_data,
870					 const char *filename);
871XMLPUBFUN int XMLCALL
872		xmlSAXUserParseMemory	(xmlSAXHandlerPtr sax,
873					 void *user_data,
874					 const char *buffer,
875					 int size);
876XMLPUBFUN xmlDocPtr XMLCALL
877		xmlSAXParseDoc		(xmlSAXHandlerPtr sax,
878					 const xmlChar *cur,
879					 int recovery);
880XMLPUBFUN xmlDocPtr XMLCALL
881		xmlSAXParseMemory	(xmlSAXHandlerPtr sax,
882					 const char *buffer,
883                                   	 int size,
884					 int recovery);
885XMLPUBFUN xmlDocPtr XMLCALL
886		xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax,
887					 const char *buffer,
888                                   	 int size,
889					 int recovery,
890					 void *data);
891XMLPUBFUN xmlDocPtr XMLCALL
892		xmlSAXParseFile		(xmlSAXHandlerPtr sax,
893					 const char *filename,
894					 int recovery);
895XMLPUBFUN xmlDocPtr XMLCALL
896		xmlSAXParseFileWithData	(xmlSAXHandlerPtr sax,
897					 const char *filename,
898					 int recovery,
899					 void *data);
900XMLPUBFUN xmlDocPtr XMLCALL
901		xmlSAXParseEntity	(xmlSAXHandlerPtr sax,
902					 const char *filename);
903XMLPUBFUN xmlDocPtr XMLCALL
904		xmlParseEntity		(const char *filename);
905#endif /* LIBXML_SAX1_ENABLED */
906
907#ifdef LIBXML_VALID_ENABLED
908XMLPUBFUN xmlDtdPtr XMLCALL
909		xmlSAXParseDTD		(xmlSAXHandlerPtr sax,
910					 const xmlChar *ExternalID,
911					 const xmlChar *SystemID);
912XMLPUBFUN xmlDtdPtr XMLCALL
913		xmlParseDTD		(const xmlChar *ExternalID,
914					 const xmlChar *SystemID);
915XMLPUBFUN xmlDtdPtr XMLCALL
916		xmlIOParseDTD		(xmlSAXHandlerPtr sax,
917					 xmlParserInputBufferPtr input,
918					 xmlCharEncoding enc);
919#endif /* LIBXML_VALID_ENABLE */
920#ifdef LIBXML_SAX1_ENABLED
921XMLPUBFUN 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 */
929XMLPUBFUN xmlParserErrors XMLCALL
930		xmlParseInNodeContext	(xmlNodePtr node,
931					 const char *data,
932					 int datalen,
933					 int options,
934					 xmlNodePtr *lst);
935#ifdef LIBXML_SAX1_ENABLED
936XMLPUBFUN 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);
944XMLPUBFUN 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 */
953XMLPUBFUN int XMLCALL
954		xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
955					 const xmlChar *URL,
956					 const xmlChar *ID,
957					 xmlNodePtr *lst);
958
959/*
960 * Parser contexts handling.
961 */
962XMLPUBFUN xmlParserCtxtPtr XMLCALL
963		xmlNewParserCtxt	(void);
964XMLPUBFUN int XMLCALL
965		xmlInitParserCtxt	(xmlParserCtxtPtr ctxt);
966XMLPUBFUN void XMLCALL
967		xmlClearParserCtxt	(xmlParserCtxtPtr ctxt);
968XMLPUBFUN void XMLCALL
969		xmlFreeParserCtxt	(xmlParserCtxtPtr ctxt);
970#ifdef LIBXML_SAX1_ENABLED
971XMLPUBFUN void XMLCALL
972		xmlSetupParserForBuffer	(xmlParserCtxtPtr ctxt,
973					 const xmlChar* buffer,
974					 const char *filename);
975#endif /* LIBXML_SAX1_ENABLED */
976XMLPUBFUN xmlParserCtxtPtr XMLCALL
977		xmlCreateDocParserCtxt	(const xmlChar *cur);
978
979#ifdef LIBXML_LEGACY_ENABLED
980/*
981 * Reading/setting optional parsing features.
982 */
983XMLPUBFUN int XMLCALL
984		xmlGetFeaturesList	(int *len,
985					 const char **result);
986XMLPUBFUN int XMLCALL
987		xmlGetFeature		(xmlParserCtxtPtr ctxt,
988					 const char *name,
989					 void *result);
990XMLPUBFUN 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 */
1000XMLPUBFUN xmlParserCtxtPtr XMLCALL
1001		xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
1002					 void *user_data,
1003					 const char *chunk,
1004					 int size,
1005					 const char *filename);
1006XMLPUBFUN 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
1017XMLPUBFUN xmlParserCtxtPtr XMLCALL
1018		xmlCreateIOParserCtxt	(xmlSAXHandlerPtr sax,
1019					 void *user_data,
1020					 xmlInputReadCallback   ioread,
1021					 xmlInputCloseCallback  ioclose,
1022					 void *ioctx,
1023					 xmlCharEncoding enc);
1024
1025XMLPUBFUN xmlParserInputPtr XMLCALL
1026		xmlNewIOInputStream	(xmlParserCtxtPtr ctxt,
1027					 xmlParserInputBufferPtr input,
1028					 xmlCharEncoding enc);
1029
1030/*
1031 * Node infos.
1032 */
1033XMLPUBFUN const xmlParserNodeInfo* XMLCALL
1034		xmlParserFindNodeInfo	(const xmlParserCtxtPtr ctxt,
1035				         const xmlNodePtr node);
1036XMLPUBFUN void XMLCALL
1037		xmlInitNodeInfoSeq	(xmlParserNodeInfoSeqPtr seq);
1038XMLPUBFUN void XMLCALL
1039		xmlClearNodeInfoSeq	(xmlParserNodeInfoSeqPtr seq);
1040XMLPUBFUN unsigned long XMLCALL
1041		xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq,
1042                                         const xmlNodePtr node);
1043XMLPUBFUN void XMLCALL
1044		xmlParserAddNodeInfo	(xmlParserCtxtPtr ctxt,
1045					 const xmlParserNodeInfoPtr info);
1046
1047/*
1048 * External entities handling actually implemented in xmlIO.
1049 */
1050
1051XMLPUBFUN void XMLCALL
1052		xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
1053XMLPUBFUN xmlExternalEntityLoader XMLCALL
1054		xmlGetExternalEntityLoader(void);
1055XMLPUBFUN 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 */
1063XMLPUBFUN 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 */
1075typedef 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
1095XMLPUBFUN void XMLCALL
1096		xmlCtxtReset		(xmlParserCtxtPtr ctxt);
1097XMLPUBFUN int XMLCALL
1098		xmlCtxtResetPush	(xmlParserCtxtPtr ctxt,
1099					 const char *chunk,
1100					 int size,
1101					 const char *filename,
1102					 const char *encoding);
1103XMLPUBFUN int XMLCALL
1104		xmlCtxtUseOptions	(xmlParserCtxtPtr ctxt,
1105					 int options);
1106XMLPUBFUN xmlDocPtr XMLCALL
1107		xmlReadDoc		(const xmlChar *cur,
1108					 const char *URL,
1109					 const char *encoding,
1110					 int options);
1111XMLPUBFUN xmlDocPtr XMLCALL
1112		xmlReadFile		(const char *URL,
1113					 const char *encoding,
1114					 int options);
1115XMLPUBFUN xmlDocPtr XMLCALL
1116		xmlReadMemory		(const char *buffer,
1117					 int size,
1118					 const char *URL,
1119					 const char *encoding,
1120					 int options);
1121XMLPUBFUN xmlDocPtr XMLCALL
1122		xmlReadFd		(int fd,
1123					 const char *URL,
1124					 const char *encoding,
1125					 int options);
1126XMLPUBFUN xmlDocPtr XMLCALL
1127		xmlReadIO		(xmlInputReadCallback ioread,
1128					 xmlInputCloseCallback ioclose,
1129					 void *ioctx,
1130					 const char *URL,
1131					 const char *encoding,
1132					 int options);
1133XMLPUBFUN xmlDocPtr XMLCALL
1134		xmlCtxtReadDoc		(xmlParserCtxtPtr ctxt,
1135					 const xmlChar *cur,
1136					 const char *URL,
1137					 const char *encoding,
1138					 int options);
1139XMLPUBFUN xmlDocPtr XMLCALL
1140		xmlCtxtReadFile		(xmlParserCtxtPtr ctxt,
1141					 const char *filename,
1142					 const char *encoding,
1143					 int options);
1144XMLPUBFUN xmlDocPtr XMLCALL
1145		xmlCtxtReadMemory		(xmlParserCtxtPtr ctxt,
1146					 const char *buffer,
1147					 int size,
1148					 const char *URL,
1149					 const char *encoding,
1150					 int options);
1151XMLPUBFUN xmlDocPtr XMLCALL
1152		xmlCtxtReadFd		(xmlParserCtxtPtr ctxt,
1153					 int fd,
1154					 const char *URL,
1155					 const char *encoding,
1156					 int options);
1157XMLPUBFUN 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 */
1176typedef 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
1210XMLPUBFUN int XMLCALL
1211		xmlHasFeature		(xmlFeature feature);
1212
1213#ifdef __cplusplus
1214}
1215#endif
1216#endif /* __XML_PARSER_H__ */
1217
1218