Annotation of embedaddon/libxml2/include/libxml/parser.h, revision 1.1
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 */
! 311: };
! 312:
! 313: /**
! 314: * xmlSAXLocator:
! 315: *
! 316: * A SAX Locator.
! 317: */
! 318: struct _xmlSAXLocator {
! 319: const xmlChar *(*getPublicId)(void *ctx);
! 320: const xmlChar *(*getSystemId)(void *ctx);
! 321: int (*getLineNumber)(void *ctx);
! 322: int (*getColumnNumber)(void *ctx);
! 323: };
! 324:
! 325: /**
! 326: * xmlSAXHandler:
! 327: *
! 328: * A SAX handler is bunch of callbacks called by the parser when processing
! 329: * of the input generate data or structure informations.
! 330: */
! 331:
! 332: /**
! 333: * resolveEntitySAXFunc:
! 334: * @ctx: the user data (XML parser context)
! 335: * @publicId: The public ID of the entity
! 336: * @systemId: The system ID of the entity
! 337: *
! 338: * Callback:
! 339: * The entity loader, to control the loading of external entities,
! 340: * the application can either:
! 341: * - override this resolveEntity() callback in the SAX block
! 342: * - or better use the xmlSetExternalEntityLoader() function to
! 343: * set up it's own entity resolution routine
! 344: *
! 345: * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
! 346: */
! 347: typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx,
! 348: const xmlChar *publicId,
! 349: const xmlChar *systemId);
! 350: /**
! 351: * internalSubsetSAXFunc:
! 352: * @ctx: the user data (XML parser context)
! 353: * @name: the root element name
! 354: * @ExternalID: the external ID
! 355: * @SystemID: the SYSTEM ID (e.g. filename or URL)
! 356: *
! 357: * Callback on internal subset declaration.
! 358: */
! 359: typedef void (*internalSubsetSAXFunc) (void *ctx,
! 360: const xmlChar *name,
! 361: const xmlChar *ExternalID,
! 362: const xmlChar *SystemID);
! 363: /**
! 364: * externalSubsetSAXFunc:
! 365: * @ctx: the user data (XML parser context)
! 366: * @name: the root element name
! 367: * @ExternalID: the external ID
! 368: * @SystemID: the SYSTEM ID (e.g. filename or URL)
! 369: *
! 370: * Callback on external subset declaration.
! 371: */
! 372: typedef void (*externalSubsetSAXFunc) (void *ctx,
! 373: const xmlChar *name,
! 374: const xmlChar *ExternalID,
! 375: const xmlChar *SystemID);
! 376: /**
! 377: * getEntitySAXFunc:
! 378: * @ctx: the user data (XML parser context)
! 379: * @name: The entity name
! 380: *
! 381: * Get an entity by name.
! 382: *
! 383: * Returns the xmlEntityPtr if found.
! 384: */
! 385: typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx,
! 386: const xmlChar *name);
! 387: /**
! 388: * getParameterEntitySAXFunc:
! 389: * @ctx: the user data (XML parser context)
! 390: * @name: The entity name
! 391: *
! 392: * Get a parameter entity by name.
! 393: *
! 394: * Returns the xmlEntityPtr if found.
! 395: */
! 396: typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx,
! 397: const xmlChar *name);
! 398: /**
! 399: * entityDeclSAXFunc:
! 400: * @ctx: the user data (XML parser context)
! 401: * @name: the entity name
! 402: * @type: the entity type
! 403: * @publicId: The public ID of the entity
! 404: * @systemId: The system ID of the entity
! 405: * @content: the entity value (without processing).
! 406: *
! 407: * An entity definition has been parsed.
! 408: */
! 409: typedef void (*entityDeclSAXFunc) (void *ctx,
! 410: const xmlChar *name,
! 411: int type,
! 412: const xmlChar *publicId,
! 413: const xmlChar *systemId,
! 414: xmlChar *content);
! 415: /**
! 416: * notationDeclSAXFunc:
! 417: * @ctx: the user data (XML parser context)
! 418: * @name: The name of the notation
! 419: * @publicId: The public ID of the entity
! 420: * @systemId: The system ID of the entity
! 421: *
! 422: * What to do when a notation declaration has been parsed.
! 423: */
! 424: typedef void (*notationDeclSAXFunc)(void *ctx,
! 425: const xmlChar *name,
! 426: const xmlChar *publicId,
! 427: const xmlChar *systemId);
! 428: /**
! 429: * attributeDeclSAXFunc:
! 430: * @ctx: the user data (XML parser context)
! 431: * @elem: the name of the element
! 432: * @fullname: the attribute name
! 433: * @type: the attribute type
! 434: * @def: the type of default value
! 435: * @defaultValue: the attribute default value
! 436: * @tree: the tree of enumerated value set
! 437: *
! 438: * An attribute definition has been parsed.
! 439: */
! 440: typedef void (*attributeDeclSAXFunc)(void *ctx,
! 441: const xmlChar *elem,
! 442: const xmlChar *fullname,
! 443: int type,
! 444: int def,
! 445: const xmlChar *defaultValue,
! 446: xmlEnumerationPtr tree);
! 447: /**
! 448: * elementDeclSAXFunc:
! 449: * @ctx: the user data (XML parser context)
! 450: * @name: the element name
! 451: * @type: the element type
! 452: * @content: the element value tree
! 453: *
! 454: * An element definition has been parsed.
! 455: */
! 456: typedef void (*elementDeclSAXFunc)(void *ctx,
! 457: const xmlChar *name,
! 458: int type,
! 459: xmlElementContentPtr content);
! 460: /**
! 461: * unparsedEntityDeclSAXFunc:
! 462: * @ctx: the user data (XML parser context)
! 463: * @name: The name of the entity
! 464: * @publicId: The public ID of the entity
! 465: * @systemId: The system ID of the entity
! 466: * @notationName: the name of the notation
! 467: *
! 468: * What to do when an unparsed entity declaration is parsed.
! 469: */
! 470: typedef void (*unparsedEntityDeclSAXFunc)(void *ctx,
! 471: const xmlChar *name,
! 472: const xmlChar *publicId,
! 473: const xmlChar *systemId,
! 474: const xmlChar *notationName);
! 475: /**
! 476: * setDocumentLocatorSAXFunc:
! 477: * @ctx: the user data (XML parser context)
! 478: * @loc: A SAX Locator
! 479: *
! 480: * Receive the document locator at startup, actually xmlDefaultSAXLocator.
! 481: * Everything is available on the context, so this is useless in our case.
! 482: */
! 483: typedef void (*setDocumentLocatorSAXFunc) (void *ctx,
! 484: xmlSAXLocatorPtr loc);
! 485: /**
! 486: * startDocumentSAXFunc:
! 487: * @ctx: the user data (XML parser context)
! 488: *
! 489: * Called when the document start being processed.
! 490: */
! 491: typedef void (*startDocumentSAXFunc) (void *ctx);
! 492: /**
! 493: * endDocumentSAXFunc:
! 494: * @ctx: the user data (XML parser context)
! 495: *
! 496: * Called when the document end has been detected.
! 497: */
! 498: typedef void (*endDocumentSAXFunc) (void *ctx);
! 499: /**
! 500: * startElementSAXFunc:
! 501: * @ctx: the user data (XML parser context)
! 502: * @name: The element name, including namespace prefix
! 503: * @atts: An array of name/value attributes pairs, NULL terminated
! 504: *
! 505: * Called when an opening tag has been processed.
! 506: */
! 507: typedef void (*startElementSAXFunc) (void *ctx,
! 508: const xmlChar *name,
! 509: const xmlChar **atts);
! 510: /**
! 511: * endElementSAXFunc:
! 512: * @ctx: the user data (XML parser context)
! 513: * @name: The element name
! 514: *
! 515: * Called when the end of an element has been detected.
! 516: */
! 517: typedef void (*endElementSAXFunc) (void *ctx,
! 518: const xmlChar *name);
! 519: /**
! 520: * attributeSAXFunc:
! 521: * @ctx: the user data (XML parser context)
! 522: * @name: The attribute name, including namespace prefix
! 523: * @value: The attribute value
! 524: *
! 525: * Handle an attribute that has been read by the parser.
! 526: * The default handling is to convert the attribute into an
! 527: * DOM subtree and past it in a new xmlAttr element added to
! 528: * the element.
! 529: */
! 530: typedef void (*attributeSAXFunc) (void *ctx,
! 531: const xmlChar *name,
! 532: const xmlChar *value);
! 533: /**
! 534: * referenceSAXFunc:
! 535: * @ctx: the user data (XML parser context)
! 536: * @name: The entity name
! 537: *
! 538: * Called when an entity reference is detected.
! 539: */
! 540: typedef void (*referenceSAXFunc) (void *ctx,
! 541: const xmlChar *name);
! 542: /**
! 543: * charactersSAXFunc:
! 544: * @ctx: the user data (XML parser context)
! 545: * @ch: a xmlChar string
! 546: * @len: the number of xmlChar
! 547: *
! 548: * Receiving some chars from the parser.
! 549: */
! 550: typedef void (*charactersSAXFunc) (void *ctx,
! 551: const xmlChar *ch,
! 552: int len);
! 553: /**
! 554: * ignorableWhitespaceSAXFunc:
! 555: * @ctx: the user data (XML parser context)
! 556: * @ch: a xmlChar string
! 557: * @len: the number of xmlChar
! 558: *
! 559: * Receiving some ignorable whitespaces from the parser.
! 560: * UNUSED: by default the DOM building will use characters.
! 561: */
! 562: typedef void (*ignorableWhitespaceSAXFunc) (void *ctx,
! 563: const xmlChar *ch,
! 564: int len);
! 565: /**
! 566: * processingInstructionSAXFunc:
! 567: * @ctx: the user data (XML parser context)
! 568: * @target: the target name
! 569: * @data: the PI data's
! 570: *
! 571: * A processing instruction has been parsed.
! 572: */
! 573: typedef void (*processingInstructionSAXFunc) (void *ctx,
! 574: const xmlChar *target,
! 575: const xmlChar *data);
! 576: /**
! 577: * commentSAXFunc:
! 578: * @ctx: the user data (XML parser context)
! 579: * @value: the comment content
! 580: *
! 581: * A comment has been parsed.
! 582: */
! 583: typedef void (*commentSAXFunc) (void *ctx,
! 584: const xmlChar *value);
! 585: /**
! 586: * cdataBlockSAXFunc:
! 587: * @ctx: the user data (XML parser context)
! 588: * @value: The pcdata content
! 589: * @len: the block length
! 590: *
! 591: * Called when a pcdata block has been parsed.
! 592: */
! 593: typedef void (*cdataBlockSAXFunc) (
! 594: void *ctx,
! 595: const xmlChar *value,
! 596: int len);
! 597: /**
! 598: * warningSAXFunc:
! 599: * @ctx: an XML parser context
! 600: * @msg: the message to display/transmit
! 601: * @...: extra parameters for the message display
! 602: *
! 603: * Display and format a warning messages, callback.
! 604: */
! 605: typedef void (XMLCDECL *warningSAXFunc) (void *ctx,
! 606: const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
! 607: /**
! 608: * errorSAXFunc:
! 609: * @ctx: an XML parser context
! 610: * @msg: the message to display/transmit
! 611: * @...: extra parameters for the message display
! 612: *
! 613: * Display and format an error messages, callback.
! 614: */
! 615: typedef void (XMLCDECL *errorSAXFunc) (void *ctx,
! 616: const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
! 617: /**
! 618: * fatalErrorSAXFunc:
! 619: * @ctx: an XML parser context
! 620: * @msg: the message to display/transmit
! 621: * @...: extra parameters for the message display
! 622: *
! 623: * Display and format fatal error messages, callback.
! 624: * Note: so far fatalError() SAX callbacks are not used, error()
! 625: * get all the callbacks for errors.
! 626: */
! 627: typedef void (XMLCDECL *fatalErrorSAXFunc) (void *ctx,
! 628: const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
! 629: /**
! 630: * isStandaloneSAXFunc:
! 631: * @ctx: the user data (XML parser context)
! 632: *
! 633: * Is this document tagged standalone?
! 634: *
! 635: * Returns 1 if true
! 636: */
! 637: typedef int (*isStandaloneSAXFunc) (void *ctx);
! 638: /**
! 639: * hasInternalSubsetSAXFunc:
! 640: * @ctx: the user data (XML parser context)
! 641: *
! 642: * Does this document has an internal subset.
! 643: *
! 644: * Returns 1 if true
! 645: */
! 646: typedef int (*hasInternalSubsetSAXFunc) (void *ctx);
! 647:
! 648: /**
! 649: * hasExternalSubsetSAXFunc:
! 650: * @ctx: the user data (XML parser context)
! 651: *
! 652: * Does this document has an external subset?
! 653: *
! 654: * Returns 1 if true
! 655: */
! 656: typedef int (*hasExternalSubsetSAXFunc) (void *ctx);
! 657:
! 658: /************************************************************************
! 659: * *
! 660: * The SAX version 2 API extensions *
! 661: * *
! 662: ************************************************************************/
! 663: /**
! 664: * XML_SAX2_MAGIC:
! 665: *
! 666: * Special constant found in SAX2 blocks initialized fields
! 667: */
! 668: #define XML_SAX2_MAGIC 0xDEEDBEAF
! 669:
! 670: /**
! 671: * startElementNsSAX2Func:
! 672: * @ctx: the user data (XML parser context)
! 673: * @localname: the local name of the element
! 674: * @prefix: the element namespace prefix if available
! 675: * @URI: the element namespace name if available
! 676: * @nb_namespaces: number of namespace definitions on that node
! 677: * @namespaces: pointer to the array of prefix/URI pairs namespace definitions
! 678: * @nb_attributes: the number of attributes on that node
! 679: * @nb_defaulted: the number of defaulted attributes. The defaulted
! 680: * ones are at the end of the array
! 681: * @attributes: pointer to the array of (localname/prefix/URI/value/end)
! 682: * attribute values.
! 683: *
! 684: * SAX2 callback when an element start has been detected by the parser.
! 685: * It provides the namespace informations for the element, as well as
! 686: * the new namespace declarations on the element.
! 687: */
! 688:
! 689: typedef void (*startElementNsSAX2Func) (void *ctx,
! 690: const xmlChar *localname,
! 691: const xmlChar *prefix,
! 692: const xmlChar *URI,
! 693: int nb_namespaces,
! 694: const xmlChar **namespaces,
! 695: int nb_attributes,
! 696: int nb_defaulted,
! 697: const xmlChar **attributes);
! 698:
! 699: /**
! 700: * endElementNsSAX2Func:
! 701: * @ctx: the user data (XML parser context)
! 702: * @localname: the local name of the element
! 703: * @prefix: the element namespace prefix if available
! 704: * @URI: the element namespace name if available
! 705: *
! 706: * SAX2 callback when an element end has been detected by the parser.
! 707: * It provides the namespace informations for the element.
! 708: */
! 709:
! 710: typedef void (*endElementNsSAX2Func) (void *ctx,
! 711: const xmlChar *localname,
! 712: const xmlChar *prefix,
! 713: const xmlChar *URI);
! 714:
! 715:
! 716: struct _xmlSAXHandler {
! 717: internalSubsetSAXFunc internalSubset;
! 718: isStandaloneSAXFunc isStandalone;
! 719: hasInternalSubsetSAXFunc hasInternalSubset;
! 720: hasExternalSubsetSAXFunc hasExternalSubset;
! 721: resolveEntitySAXFunc resolveEntity;
! 722: getEntitySAXFunc getEntity;
! 723: entityDeclSAXFunc entityDecl;
! 724: notationDeclSAXFunc notationDecl;
! 725: attributeDeclSAXFunc attributeDecl;
! 726: elementDeclSAXFunc elementDecl;
! 727: unparsedEntityDeclSAXFunc unparsedEntityDecl;
! 728: setDocumentLocatorSAXFunc setDocumentLocator;
! 729: startDocumentSAXFunc startDocument;
! 730: endDocumentSAXFunc endDocument;
! 731: startElementSAXFunc startElement;
! 732: endElementSAXFunc endElement;
! 733: referenceSAXFunc reference;
! 734: charactersSAXFunc characters;
! 735: ignorableWhitespaceSAXFunc ignorableWhitespace;
! 736: processingInstructionSAXFunc processingInstruction;
! 737: commentSAXFunc comment;
! 738: warningSAXFunc warning;
! 739: errorSAXFunc error;
! 740: fatalErrorSAXFunc fatalError; /* unused error() get all the errors */
! 741: getParameterEntitySAXFunc getParameterEntity;
! 742: cdataBlockSAXFunc cdataBlock;
! 743: externalSubsetSAXFunc externalSubset;
! 744: unsigned int initialized;
! 745: /* The following fields are extensions available only on version 2 */
! 746: void *_private;
! 747: startElementNsSAX2Func startElementNs;
! 748: endElementNsSAX2Func endElementNs;
! 749: xmlStructuredErrorFunc serror;
! 750: };
! 751:
! 752: /*
! 753: * SAX Version 1
! 754: */
! 755: typedef struct _xmlSAXHandlerV1 xmlSAXHandlerV1;
! 756: typedef xmlSAXHandlerV1 *xmlSAXHandlerV1Ptr;
! 757: struct _xmlSAXHandlerV1 {
! 758: internalSubsetSAXFunc internalSubset;
! 759: isStandaloneSAXFunc isStandalone;
! 760: hasInternalSubsetSAXFunc hasInternalSubset;
! 761: hasExternalSubsetSAXFunc hasExternalSubset;
! 762: resolveEntitySAXFunc resolveEntity;
! 763: getEntitySAXFunc getEntity;
! 764: entityDeclSAXFunc entityDecl;
! 765: notationDeclSAXFunc notationDecl;
! 766: attributeDeclSAXFunc attributeDecl;
! 767: elementDeclSAXFunc elementDecl;
! 768: unparsedEntityDeclSAXFunc unparsedEntityDecl;
! 769: setDocumentLocatorSAXFunc setDocumentLocator;
! 770: startDocumentSAXFunc startDocument;
! 771: endDocumentSAXFunc endDocument;
! 772: startElementSAXFunc startElement;
! 773: endElementSAXFunc endElement;
! 774: referenceSAXFunc reference;
! 775: charactersSAXFunc characters;
! 776: ignorableWhitespaceSAXFunc ignorableWhitespace;
! 777: processingInstructionSAXFunc processingInstruction;
! 778: commentSAXFunc comment;
! 779: warningSAXFunc warning;
! 780: errorSAXFunc error;
! 781: fatalErrorSAXFunc fatalError; /* unused error() get all the errors */
! 782: getParameterEntitySAXFunc getParameterEntity;
! 783: cdataBlockSAXFunc cdataBlock;
! 784: externalSubsetSAXFunc externalSubset;
! 785: unsigned int initialized;
! 786: };
! 787:
! 788:
! 789: /**
! 790: * xmlExternalEntityLoader:
! 791: * @URL: The System ID of the resource requested
! 792: * @ID: The Public ID of the resource requested
! 793: * @context: the XML parser context
! 794: *
! 795: * External entity loaders types.
! 796: *
! 797: * Returns the entity input parser.
! 798: */
! 799: typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL,
! 800: const char *ID,
! 801: xmlParserCtxtPtr context);
! 802:
! 803: #ifdef __cplusplus
! 804: }
! 805: #endif
! 806:
! 807: #include <libxml/encoding.h>
! 808: #include <libxml/xmlIO.h>
! 809: #include <libxml/globals.h>
! 810:
! 811: #ifdef __cplusplus
! 812: extern "C" {
! 813: #endif
! 814:
! 815:
! 816: /*
! 817: * Init/Cleanup
! 818: */
! 819: XMLPUBFUN void XMLCALL
! 820: xmlInitParser (void);
! 821: XMLPUBFUN void XMLCALL
! 822: xmlCleanupParser (void);
! 823:
! 824: /*
! 825: * Input functions
! 826: */
! 827: XMLPUBFUN int XMLCALL
! 828: xmlParserInputRead (xmlParserInputPtr in,
! 829: int len);
! 830: XMLPUBFUN int XMLCALL
! 831: xmlParserInputGrow (xmlParserInputPtr in,
! 832: int len);
! 833:
! 834: /*
! 835: * Basic parsing Interfaces
! 836: */
! 837: #ifdef LIBXML_SAX1_ENABLED
! 838: XMLPUBFUN xmlDocPtr XMLCALL
! 839: xmlParseDoc (const xmlChar *cur);
! 840: XMLPUBFUN xmlDocPtr XMLCALL
! 841: xmlParseFile (const char *filename);
! 842: XMLPUBFUN xmlDocPtr XMLCALL
! 843: xmlParseMemory (const char *buffer,
! 844: int size);
! 845: #endif /* LIBXML_SAX1_ENABLED */
! 846: XMLPUBFUN int XMLCALL
! 847: xmlSubstituteEntitiesDefault(int val);
! 848: XMLPUBFUN int XMLCALL
! 849: xmlKeepBlanksDefault (int val);
! 850: XMLPUBFUN void XMLCALL
! 851: xmlStopParser (xmlParserCtxtPtr ctxt);
! 852: XMLPUBFUN int XMLCALL
! 853: xmlPedanticParserDefault(int val);
! 854: XMLPUBFUN int XMLCALL
! 855: xmlLineNumbersDefault (int val);
! 856:
! 857: #ifdef LIBXML_SAX1_ENABLED
! 858: /*
! 859: * Recovery mode
! 860: */
! 861: XMLPUBFUN xmlDocPtr XMLCALL
! 862: xmlRecoverDoc (const xmlChar *cur);
! 863: XMLPUBFUN xmlDocPtr XMLCALL
! 864: xmlRecoverMemory (const char *buffer,
! 865: int size);
! 866: XMLPUBFUN xmlDocPtr XMLCALL
! 867: xmlRecoverFile (const char *filename);
! 868: #endif /* LIBXML_SAX1_ENABLED */
! 869:
! 870: /*
! 871: * Less common routines and SAX interfaces
! 872: */
! 873: XMLPUBFUN int XMLCALL
! 874: xmlParseDocument (xmlParserCtxtPtr ctxt);
! 875: XMLPUBFUN int XMLCALL
! 876: xmlParseExtParsedEnt (xmlParserCtxtPtr ctxt);
! 877: #ifdef LIBXML_SAX1_ENABLED
! 878: XMLPUBFUN int XMLCALL
! 879: xmlSAXUserParseFile (xmlSAXHandlerPtr sax,
! 880: void *user_data,
! 881: const char *filename);
! 882: XMLPUBFUN int XMLCALL
! 883: xmlSAXUserParseMemory (xmlSAXHandlerPtr sax,
! 884: void *user_data,
! 885: const char *buffer,
! 886: int size);
! 887: XMLPUBFUN xmlDocPtr XMLCALL
! 888: xmlSAXParseDoc (xmlSAXHandlerPtr sax,
! 889: const xmlChar *cur,
! 890: int recovery);
! 891: XMLPUBFUN xmlDocPtr XMLCALL
! 892: xmlSAXParseMemory (xmlSAXHandlerPtr sax,
! 893: const char *buffer,
! 894: int size,
! 895: int recovery);
! 896: XMLPUBFUN xmlDocPtr XMLCALL
! 897: xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax,
! 898: const char *buffer,
! 899: int size,
! 900: int recovery,
! 901: void *data);
! 902: XMLPUBFUN xmlDocPtr XMLCALL
! 903: xmlSAXParseFile (xmlSAXHandlerPtr sax,
! 904: const char *filename,
! 905: int recovery);
! 906: XMLPUBFUN xmlDocPtr XMLCALL
! 907: xmlSAXParseFileWithData (xmlSAXHandlerPtr sax,
! 908: const char *filename,
! 909: int recovery,
! 910: void *data);
! 911: XMLPUBFUN xmlDocPtr XMLCALL
! 912: xmlSAXParseEntity (xmlSAXHandlerPtr sax,
! 913: const char *filename);
! 914: XMLPUBFUN xmlDocPtr XMLCALL
! 915: xmlParseEntity (const char *filename);
! 916: #endif /* LIBXML_SAX1_ENABLED */
! 917:
! 918: #ifdef LIBXML_VALID_ENABLED
! 919: XMLPUBFUN xmlDtdPtr XMLCALL
! 920: xmlSAXParseDTD (xmlSAXHandlerPtr sax,
! 921: const xmlChar *ExternalID,
! 922: const xmlChar *SystemID);
! 923: XMLPUBFUN xmlDtdPtr XMLCALL
! 924: xmlParseDTD (const xmlChar *ExternalID,
! 925: const xmlChar *SystemID);
! 926: XMLPUBFUN xmlDtdPtr XMLCALL
! 927: xmlIOParseDTD (xmlSAXHandlerPtr sax,
! 928: xmlParserInputBufferPtr input,
! 929: xmlCharEncoding enc);
! 930: #endif /* LIBXML_VALID_ENABLE */
! 931: #ifdef LIBXML_SAX1_ENABLED
! 932: XMLPUBFUN int XMLCALL
! 933: xmlParseBalancedChunkMemory(xmlDocPtr doc,
! 934: xmlSAXHandlerPtr sax,
! 935: void *user_data,
! 936: int depth,
! 937: const xmlChar *string,
! 938: xmlNodePtr *lst);
! 939: #endif /* LIBXML_SAX1_ENABLED */
! 940: XMLPUBFUN xmlParserErrors XMLCALL
! 941: xmlParseInNodeContext (xmlNodePtr node,
! 942: const char *data,
! 943: int datalen,
! 944: int options,
! 945: xmlNodePtr *lst);
! 946: #ifdef LIBXML_SAX1_ENABLED
! 947: XMLPUBFUN int XMLCALL
! 948: xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,
! 949: xmlSAXHandlerPtr sax,
! 950: void *user_data,
! 951: int depth,
! 952: const xmlChar *string,
! 953: xmlNodePtr *lst,
! 954: int recover);
! 955: XMLPUBFUN int XMLCALL
! 956: xmlParseExternalEntity (xmlDocPtr doc,
! 957: xmlSAXHandlerPtr sax,
! 958: void *user_data,
! 959: int depth,
! 960: const xmlChar *URL,
! 961: const xmlChar *ID,
! 962: xmlNodePtr *lst);
! 963: #endif /* LIBXML_SAX1_ENABLED */
! 964: XMLPUBFUN int XMLCALL
! 965: xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
! 966: const xmlChar *URL,
! 967: const xmlChar *ID,
! 968: xmlNodePtr *lst);
! 969:
! 970: /*
! 971: * Parser contexts handling.
! 972: */
! 973: XMLPUBFUN xmlParserCtxtPtr XMLCALL
! 974: xmlNewParserCtxt (void);
! 975: XMLPUBFUN int XMLCALL
! 976: xmlInitParserCtxt (xmlParserCtxtPtr ctxt);
! 977: XMLPUBFUN void XMLCALL
! 978: xmlClearParserCtxt (xmlParserCtxtPtr ctxt);
! 979: XMLPUBFUN void XMLCALL
! 980: xmlFreeParserCtxt (xmlParserCtxtPtr ctxt);
! 981: #ifdef LIBXML_SAX1_ENABLED
! 982: XMLPUBFUN void XMLCALL
! 983: xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt,
! 984: const xmlChar* buffer,
! 985: const char *filename);
! 986: #endif /* LIBXML_SAX1_ENABLED */
! 987: XMLPUBFUN xmlParserCtxtPtr XMLCALL
! 988: xmlCreateDocParserCtxt (const xmlChar *cur);
! 989:
! 990: #ifdef LIBXML_LEGACY_ENABLED
! 991: /*
! 992: * Reading/setting optional parsing features.
! 993: */
! 994: XMLPUBFUN int XMLCALL
! 995: xmlGetFeaturesList (int *len,
! 996: const char **result);
! 997: XMLPUBFUN int XMLCALL
! 998: xmlGetFeature (xmlParserCtxtPtr ctxt,
! 999: const char *name,
! 1000: void *result);
! 1001: XMLPUBFUN int XMLCALL
! 1002: xmlSetFeature (xmlParserCtxtPtr ctxt,
! 1003: const char *name,
! 1004: void *value);
! 1005: #endif /* LIBXML_LEGACY_ENABLED */
! 1006:
! 1007: #ifdef LIBXML_PUSH_ENABLED
! 1008: /*
! 1009: * Interfaces for the Push mode.
! 1010: */
! 1011: XMLPUBFUN xmlParserCtxtPtr XMLCALL
! 1012: xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
! 1013: void *user_data,
! 1014: const char *chunk,
! 1015: int size,
! 1016: const char *filename);
! 1017: XMLPUBFUN int XMLCALL
! 1018: xmlParseChunk (xmlParserCtxtPtr ctxt,
! 1019: const char *chunk,
! 1020: int size,
! 1021: int terminate);
! 1022: #endif /* LIBXML_PUSH_ENABLED */
! 1023:
! 1024: /*
! 1025: * Special I/O mode.
! 1026: */
! 1027:
! 1028: XMLPUBFUN xmlParserCtxtPtr XMLCALL
! 1029: xmlCreateIOParserCtxt (xmlSAXHandlerPtr sax,
! 1030: void *user_data,
! 1031: xmlInputReadCallback ioread,
! 1032: xmlInputCloseCallback ioclose,
! 1033: void *ioctx,
! 1034: xmlCharEncoding enc);
! 1035:
! 1036: XMLPUBFUN xmlParserInputPtr XMLCALL
! 1037: xmlNewIOInputStream (xmlParserCtxtPtr ctxt,
! 1038: xmlParserInputBufferPtr input,
! 1039: xmlCharEncoding enc);
! 1040:
! 1041: /*
! 1042: * Node infos.
! 1043: */
! 1044: XMLPUBFUN const xmlParserNodeInfo* XMLCALL
! 1045: xmlParserFindNodeInfo (const xmlParserCtxtPtr ctxt,
! 1046: const xmlNodePtr node);
! 1047: XMLPUBFUN void XMLCALL
! 1048: xmlInitNodeInfoSeq (xmlParserNodeInfoSeqPtr seq);
! 1049: XMLPUBFUN void XMLCALL
! 1050: xmlClearNodeInfoSeq (xmlParserNodeInfoSeqPtr seq);
! 1051: XMLPUBFUN unsigned long XMLCALL
! 1052: xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq,
! 1053: const xmlNodePtr node);
! 1054: XMLPUBFUN void XMLCALL
! 1055: xmlParserAddNodeInfo (xmlParserCtxtPtr ctxt,
! 1056: const xmlParserNodeInfoPtr info);
! 1057:
! 1058: /*
! 1059: * External entities handling actually implemented in xmlIO.
! 1060: */
! 1061:
! 1062: XMLPUBFUN void XMLCALL
! 1063: xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
! 1064: XMLPUBFUN xmlExternalEntityLoader XMLCALL
! 1065: xmlGetExternalEntityLoader(void);
! 1066: XMLPUBFUN xmlParserInputPtr XMLCALL
! 1067: xmlLoadExternalEntity (const char *URL,
! 1068: const char *ID,
! 1069: xmlParserCtxtPtr ctxt);
! 1070:
! 1071: /*
! 1072: * Index lookup, actually implemented in the encoding module
! 1073: */
! 1074: XMLPUBFUN long XMLCALL
! 1075: xmlByteConsumed (xmlParserCtxtPtr ctxt);
! 1076:
! 1077: /*
! 1078: * New set of simpler/more flexible APIs
! 1079: */
! 1080: /**
! 1081: * xmlParserOption:
! 1082: *
! 1083: * This is the set of XML parser options that can be passed down
! 1084: * to the xmlReadDoc() and similar calls.
! 1085: */
! 1086: typedef enum {
! 1087: XML_PARSE_RECOVER = 1<<0, /* recover on errors */
! 1088: XML_PARSE_NOENT = 1<<1, /* substitute entities */
! 1089: XML_PARSE_DTDLOAD = 1<<2, /* load the external subset */
! 1090: XML_PARSE_DTDATTR = 1<<3, /* default DTD attributes */
! 1091: XML_PARSE_DTDVALID = 1<<4, /* validate with the DTD */
! 1092: XML_PARSE_NOERROR = 1<<5, /* suppress error reports */
! 1093: XML_PARSE_NOWARNING = 1<<6, /* suppress warning reports */
! 1094: XML_PARSE_PEDANTIC = 1<<7, /* pedantic error reporting */
! 1095: XML_PARSE_NOBLANKS = 1<<8, /* remove blank nodes */
! 1096: XML_PARSE_SAX1 = 1<<9, /* use the SAX1 interface internally */
! 1097: XML_PARSE_XINCLUDE = 1<<10,/* Implement XInclude substitition */
! 1098: XML_PARSE_NONET = 1<<11,/* Forbid network access */
! 1099: XML_PARSE_NODICT = 1<<12,/* Do not reuse the context dictionnary */
! 1100: XML_PARSE_NSCLEAN = 1<<13,/* remove redundant namespaces declarations */
! 1101: XML_PARSE_NOCDATA = 1<<14,/* merge CDATA as text nodes */
! 1102: XML_PARSE_NOXINCNODE= 1<<15,/* do not generate XINCLUDE START/END nodes */
! 1103: XML_PARSE_COMPACT = 1<<16,/* compact small text nodes; no modification of
! 1104: the tree allowed afterwards (will possibly
! 1105: crash if you try to modify the tree) */
! 1106: XML_PARSE_OLD10 = 1<<17,/* parse using XML-1.0 before update 5 */
! 1107: XML_PARSE_NOBASEFIX = 1<<18,/* do not fixup XINCLUDE xml:base uris */
! 1108: XML_PARSE_HUGE = 1<<19, /* relax any hardcoded limit from the parser */
! 1109: XML_PARSE_OLDSAX = 1<<20 /* parse using SAX2 interface from before 2.7.0 */
! 1110: } xmlParserOption;
! 1111:
! 1112: XMLPUBFUN void XMLCALL
! 1113: xmlCtxtReset (xmlParserCtxtPtr ctxt);
! 1114: XMLPUBFUN int XMLCALL
! 1115: xmlCtxtResetPush (xmlParserCtxtPtr ctxt,
! 1116: const char *chunk,
! 1117: int size,
! 1118: const char *filename,
! 1119: const char *encoding);
! 1120: XMLPUBFUN int XMLCALL
! 1121: xmlCtxtUseOptions (xmlParserCtxtPtr ctxt,
! 1122: int options);
! 1123: XMLPUBFUN xmlDocPtr XMLCALL
! 1124: xmlReadDoc (const xmlChar *cur,
! 1125: const char *URL,
! 1126: const char *encoding,
! 1127: int options);
! 1128: XMLPUBFUN xmlDocPtr XMLCALL
! 1129: xmlReadFile (const char *URL,
! 1130: const char *encoding,
! 1131: int options);
! 1132: XMLPUBFUN xmlDocPtr XMLCALL
! 1133: xmlReadMemory (const char *buffer,
! 1134: int size,
! 1135: const char *URL,
! 1136: const char *encoding,
! 1137: int options);
! 1138: XMLPUBFUN xmlDocPtr XMLCALL
! 1139: xmlReadFd (int fd,
! 1140: const char *URL,
! 1141: const char *encoding,
! 1142: int options);
! 1143: XMLPUBFUN xmlDocPtr XMLCALL
! 1144: xmlReadIO (xmlInputReadCallback ioread,
! 1145: xmlInputCloseCallback ioclose,
! 1146: void *ioctx,
! 1147: const char *URL,
! 1148: const char *encoding,
! 1149: int options);
! 1150: XMLPUBFUN xmlDocPtr XMLCALL
! 1151: xmlCtxtReadDoc (xmlParserCtxtPtr ctxt,
! 1152: const xmlChar *cur,
! 1153: const char *URL,
! 1154: const char *encoding,
! 1155: int options);
! 1156: XMLPUBFUN xmlDocPtr XMLCALL
! 1157: xmlCtxtReadFile (xmlParserCtxtPtr ctxt,
! 1158: const char *filename,
! 1159: const char *encoding,
! 1160: int options);
! 1161: XMLPUBFUN xmlDocPtr XMLCALL
! 1162: xmlCtxtReadMemory (xmlParserCtxtPtr ctxt,
! 1163: const char *buffer,
! 1164: int size,
! 1165: const char *URL,
! 1166: const char *encoding,
! 1167: int options);
! 1168: XMLPUBFUN xmlDocPtr XMLCALL
! 1169: xmlCtxtReadFd (xmlParserCtxtPtr ctxt,
! 1170: int fd,
! 1171: const char *URL,
! 1172: const char *encoding,
! 1173: int options);
! 1174: XMLPUBFUN xmlDocPtr XMLCALL
! 1175: xmlCtxtReadIO (xmlParserCtxtPtr ctxt,
! 1176: xmlInputReadCallback ioread,
! 1177: xmlInputCloseCallback ioclose,
! 1178: void *ioctx,
! 1179: const char *URL,
! 1180: const char *encoding,
! 1181: int options);
! 1182:
! 1183: /*
! 1184: * Library wide options
! 1185: */
! 1186: /**
! 1187: * xmlFeature:
! 1188: *
! 1189: * Used to examine the existance of features that can be enabled
! 1190: * or disabled at compile-time.
! 1191: * They used to be called XML_FEATURE_xxx but this clashed with Expat
! 1192: */
! 1193: typedef enum {
! 1194: XML_WITH_THREAD = 1,
! 1195: XML_WITH_TREE = 2,
! 1196: XML_WITH_OUTPUT = 3,
! 1197: XML_WITH_PUSH = 4,
! 1198: XML_WITH_READER = 5,
! 1199: XML_WITH_PATTERN = 6,
! 1200: XML_WITH_WRITER = 7,
! 1201: XML_WITH_SAX1 = 8,
! 1202: XML_WITH_FTP = 9,
! 1203: XML_WITH_HTTP = 10,
! 1204: XML_WITH_VALID = 11,
! 1205: XML_WITH_HTML = 12,
! 1206: XML_WITH_LEGACY = 13,
! 1207: XML_WITH_C14N = 14,
! 1208: XML_WITH_CATALOG = 15,
! 1209: XML_WITH_XPATH = 16,
! 1210: XML_WITH_XPTR = 17,
! 1211: XML_WITH_XINCLUDE = 18,
! 1212: XML_WITH_ICONV = 19,
! 1213: XML_WITH_ISO8859X = 20,
! 1214: XML_WITH_UNICODE = 21,
! 1215: XML_WITH_REGEXP = 22,
! 1216: XML_WITH_AUTOMATA = 23,
! 1217: XML_WITH_EXPR = 24,
! 1218: XML_WITH_SCHEMAS = 25,
! 1219: XML_WITH_SCHEMATRON = 26,
! 1220: XML_WITH_MODULES = 27,
! 1221: XML_WITH_DEBUG = 28,
! 1222: XML_WITH_DEBUG_MEM = 29,
! 1223: XML_WITH_DEBUG_RUN = 30,
! 1224: XML_WITH_ZLIB = 31,
! 1225: XML_WITH_ICU = 32,
! 1226: XML_WITH_NONE = 99999 /* just to be sure of allocation size */
! 1227: } xmlFeature;
! 1228:
! 1229: XMLPUBFUN int XMLCALL
! 1230: xmlHasFeature (xmlFeature feature);
! 1231:
! 1232: #ifdef __cplusplus
! 1233: }
! 1234: #endif
! 1235: #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