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