Mercurial > repos > shellac > guppy_basecaller

comparison env/lib/python3.7/site-packages/lxml/includes/libxml/parser.h @ 0:26e78fe6e8c4 draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
"planemo upload commit c699937486c35866861690329de38ec1a5d9f783"
author shellac
date Sat, 02 May 2020 07:14:21 -0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:26e78fe6e8c4
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 Namespace okay */
287 int options; /* Extra options */
288
289 /*
290 * Those fields are needed only for streaming 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 substitution */
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 existence 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__ */