parser.h@ 78251

Last change on this file since 78251 was 65950, checked in by vboxsync, 8 years ago
libxml 2.9.4: fix export
Property svn:eol-style set to `native`
File size: 38.8 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.9.4/include/libxml/parser.h@ 78251

Download in other formats: