| /* |
| * Summary: interfaces for tree manipulation |
| * Description: this module describes the structures found in an tree resulting |
| * from an XML or HTML parsing, as well as the API provided for |
| * various processing on that tree |
| * |
| * Copy: See Copyright for the status of this software. |
| * |
| * Author: Daniel Veillard |
| */ |
| |
| #ifndef __XML_TREE_H__ |
| #define __XML_TREE_H__ |
| |
| #include <stdio.h> |
| #include <libxml/xmlversion.h> |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| /* |
| * Some of the basic types pointer to structures: |
| */ |
| /* xmlIO.h */ |
| typedef struct _xmlParserInputBuffer xmlParserInputBuffer; |
| typedef xmlParserInputBuffer *xmlParserInputBufferPtr; |
| |
| typedef struct _xmlOutputBuffer xmlOutputBuffer; |
| typedef xmlOutputBuffer *xmlOutputBufferPtr; |
| |
| /* parser.h */ |
| typedef struct _xmlParserInput xmlParserInput; |
| typedef xmlParserInput *xmlParserInputPtr; |
| |
| typedef struct _xmlParserCtxt xmlParserCtxt; |
| typedef xmlParserCtxt *xmlParserCtxtPtr; |
| |
| typedef struct _xmlSAXLocator xmlSAXLocator; |
| typedef xmlSAXLocator *xmlSAXLocatorPtr; |
| |
| typedef struct _xmlSAXHandler xmlSAXHandler; |
| typedef xmlSAXHandler *xmlSAXHandlerPtr; |
| |
| /* entities.h */ |
| typedef struct _xmlEntity xmlEntity; |
| typedef xmlEntity *xmlEntityPtr; |
| |
| /** |
| * BASE_BUFFER_SIZE: |
| * |
| * default buffer size 4000. |
| */ |
| #define BASE_BUFFER_SIZE 4096 |
| |
| /** |
| * XML_XML_NAMESPACE: |
| * |
| * This is the namespace for the special xml: prefix predefined in the |
| * XML Namespace specification. |
| */ |
| #define XML_XML_NAMESPACE \ |
| (const xmlChar *) "http://www.w3.org/XML/1998/namespace" |
| |
| /* |
| * The different element types carried by an XML tree. |
| * |
| * NOTE: This is synchronized with DOM Level1 values |
| * See http://www.w3.org/TR/REC-DOM-Level-1/ |
| * |
| * Actually this had diverged a bit, and now XML_DOCUMENT_TYPE_NODE should |
| * be deprecated to use an XML_DTD_NODE. |
| */ |
| typedef enum { |
| XML_ELEMENT_NODE= 1, |
| XML_ATTRIBUTE_NODE= 2, |
| XML_TEXT_NODE= 3, |
| XML_CDATA_SECTION_NODE= 4, |
| XML_ENTITY_REF_NODE= 5, |
| XML_ENTITY_NODE= 6, |
| XML_PI_NODE= 7, |
| XML_COMMENT_NODE= 8, |
| XML_DOCUMENT_NODE= 9, |
| XML_DOCUMENT_TYPE_NODE= 10, |
| XML_DOCUMENT_FRAG_NODE= 11, |
| XML_NOTATION_NODE= 12, |
| XML_HTML_DOCUMENT_NODE= 13, |
| XML_DTD_NODE= 14, |
| XML_ELEMENT_DECL= 15, |
| XML_ATTRIBUTE_DECL= 16, |
| XML_ENTITY_DECL= 17, |
| XML_NAMESPACE_DECL= 18, |
| XML_XINCLUDE_START= 19, |
| XML_XINCLUDE_END= 20 |
| #ifdef LIBXML_DOCB_ENABLED |
| ,XML_DOCB_DOCUMENT_NODE= 21 |
| #endif |
| } xmlElementType; |
| |
| /** |
| * xmlChar: |
| * |
| * This is a basic byte in an UTF-8 encoded string. |
| * It's unsigned allowing to pinpoint case where char * are assigned |
| * to xmlChar * (possibly making serialization back impossible). |
| */ |
| |
| typedef unsigned char xmlChar; |
| |
| /** |
| * BAD_CAST: |
| * |
| * Macro to cast a string to an xmlChar * when one know its safe. |
| */ |
| #define BAD_CAST (xmlChar *) |
| |
| /** |
| * xmlNotation: |
| * |
| * A DTD Notation definition. |
| */ |
| |
| typedef struct _xmlNotation xmlNotation; |
| typedef xmlNotation *xmlNotationPtr; |
| struct _xmlNotation { |
| const xmlChar *name; /* Notation name */ |
| const xmlChar *PublicID; /* Public identifier, if any */ |
| const xmlChar *SystemID; /* System identifier, if any */ |
| }; |
| |
| /** |
| * xmlAttributeType: |
| * |
| * A DTD Attribute type definition. |
| */ |
| |
| typedef enum { |
| XML_ATTRIBUTE_CDATA = 1, |
| XML_ATTRIBUTE_ID, |
| XML_ATTRIBUTE_IDREF , |
| XML_ATTRIBUTE_IDREFS, |
| XML_ATTRIBUTE_ENTITY, |
| XML_ATTRIBUTE_ENTITIES, |
| XML_ATTRIBUTE_NMTOKEN, |
| XML_ATTRIBUTE_NMTOKENS, |
| XML_ATTRIBUTE_ENUMERATION, |
| XML_ATTRIBUTE_NOTATION |
| } xmlAttributeType; |
| |
| /** |
| * xmlAttributeDefault: |
| * |
| * A DTD Attribute default definition. |
| */ |
| |
| typedef enum { |
| XML_ATTRIBUTE_NONE = 1, |
| XML_ATTRIBUTE_REQUIRED, |
| XML_ATTRIBUTE_IMPLIED, |
| XML_ATTRIBUTE_FIXED |
| } xmlAttributeDefault; |
| |
| /** |
| * xmlEnumeration: |
| * |
| * List structure used when there is an enumeration in DTDs. |
| */ |
| |
| typedef struct _xmlEnumeration xmlEnumeration; |
| typedef xmlEnumeration *xmlEnumerationPtr; |
| struct _xmlEnumeration { |
| struct _xmlEnumeration *next; /* next one */ |
| const xmlChar *name; /* Enumeration name */ |
| }; |
| |
| /** |
| * xmlAttribute: |
| * |
| * An Attribute declaration in a DTD. |
| */ |
| |
| typedef struct _xmlAttribute xmlAttribute; |
| typedef xmlAttribute *xmlAttributePtr; |
| struct _xmlAttribute { |
| void *_private; /* application data */ |
| xmlElementType type; /* XML_ATTRIBUTE_DECL, must be second ! */ |
| const xmlChar *name; /* Attribute name */ |
| struct _xmlNode *children; /* NULL */ |
| struct _xmlNode *last; /* NULL */ |
| struct _xmlDtd *parent; /* -> DTD */ |
| struct _xmlNode *next; /* next sibling link */ |
| struct _xmlNode *prev; /* previous sibling link */ |
| struct _xmlDoc *doc; /* the containing document */ |
| |
| struct _xmlAttribute *nexth; /* next in hash table */ |
| xmlAttributeType atype; /* The attribute type */ |
| xmlAttributeDefault def; /* the default */ |
| const xmlChar *defaultValue; /* or the default value */ |
| xmlEnumerationPtr tree; /* or the enumeration tree if any */ |
| const xmlChar *prefix; /* the namespace prefix if any */ |
| const xmlChar *elem; /* Element holding the attribute */ |
| }; |
| |
| /** |
| * xmlElementContentType: |
| * |
| * Possible definitions of element content types. |
| */ |
| typedef enum { |
| XML_ELEMENT_CONTENT_PCDATA = 1, |
| XML_ELEMENT_CONTENT_ELEMENT, |
| XML_ELEMENT_CONTENT_SEQ, |
| XML_ELEMENT_CONTENT_OR |
| } xmlElementContentType; |
| |
| /** |
| * xmlElementContentOccur: |
| * |
| * Possible definitions of element content occurrences. |
| */ |
| typedef enum { |
| XML_ELEMENT_CONTENT_ONCE = 1, |
| XML_ELEMENT_CONTENT_OPT, |
| XML_ELEMENT_CONTENT_MULT, |
| XML_ELEMENT_CONTENT_PLUS |
| } xmlElementContentOccur; |
| |
| /** |
| * xmlElementContent: |
| * |
| * An XML Element content as stored after parsing an element definition |
| * in a DTD. |
| */ |
| |
| typedef struct _xmlElementContent xmlElementContent; |
| typedef xmlElementContent *xmlElementContentPtr; |
| struct _xmlElementContent { |
| xmlElementContentType type; /* PCDATA, ELEMENT, SEQ or OR */ |
| xmlElementContentOccur ocur; /* ONCE, OPT, MULT or PLUS */ |
| const xmlChar *name; /* Element name */ |
| struct _xmlElementContent *c1; /* first child */ |
| struct _xmlElementContent *c2; /* second child */ |
| struct _xmlElementContent *parent; /* parent */ |
| const xmlChar *prefix; /* Namespace prefix */ |
| }; |
| |
| /** |
| * xmlElementTypeVal: |
| * |
| * The different possibilities for an element content type. |
| */ |
| |
| typedef enum { |
| XML_ELEMENT_TYPE_UNDEFINED = 0, |
| XML_ELEMENT_TYPE_EMPTY = 1, |
| XML_ELEMENT_TYPE_ANY, |
| XML_ELEMENT_TYPE_MIXED, |
| XML_ELEMENT_TYPE_ELEMENT |
| } xmlElementTypeVal; |
| |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| #include <libxml/xmlregexp.h> |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| /** |
| * xmlElement: |
| * |
| * An XML Element declaration from a DTD. |
| */ |
| |
| typedef struct _xmlElement xmlElement; |
| typedef xmlElement *xmlElementPtr; |
| struct _xmlElement { |
| void *_private; /* application data */ |
| xmlElementType type; /* XML_ELEMENT_DECL, must be second ! */ |
| const xmlChar *name; /* Element name */ |
| struct _xmlNode *children; /* NULL */ |
| struct _xmlNode *last; /* NULL */ |
| struct _xmlDtd *parent; /* -> DTD */ |
| struct _xmlNode *next; /* next sibling link */ |
| struct _xmlNode *prev; /* previous sibling link */ |
| struct _xmlDoc *doc; /* the containing document */ |
| |
| xmlElementTypeVal etype; /* The type */ |
| xmlElementContentPtr content; /* the allowed element content */ |
| xmlAttributePtr attributes; /* List of the declared attributes */ |
| const xmlChar *prefix; /* the namespace prefix if any */ |
| #ifdef LIBXML_REGEXP_ENABLED |
| xmlRegexpPtr contModel; /* the validating regexp */ |
| #else |
| void *contModel; |
| #endif |
| }; |
| |
| |
| /** |
| * XML_LOCAL_NAMESPACE: |
| * |
| * A namespace declaration node. |
| */ |
| #define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL |
| typedef xmlElementType xmlNsType; |
| |
| /** |
| * xmlNs: |
| * |
| * An XML namespace. |
| * Note that prefix == NULL is valid, it defines the default namespace |
| * within the subtree (until overridden). |
| * |
| * xmlNsType is unified with xmlElementType. |
| */ |
| |
| typedef struct _xmlNs xmlNs; |
| typedef xmlNs *xmlNsPtr; |
| struct _xmlNs { |
| struct _xmlNs *next; /* next Ns link for this node */ |
| xmlNsType type; /* global or local */ |
| const xmlChar *href; /* URL for the namespace */ |
| const xmlChar *prefix; /* prefix for the namespace */ |
| void *_private; /* application data */ |
| }; |
| |
| /** |
| * xmlDtd: |
| * |
| * An XML DTD, as defined by <!DOCTYPE ... There is actually one for |
| * the internal subset and for the external subset. |
| */ |
| typedef struct _xmlDtd xmlDtd; |
| typedef xmlDtd *xmlDtdPtr; |
| struct _xmlDtd { |
| void *_private; /* application data */ |
| xmlElementType type; /* XML_DTD_NODE, must be second ! */ |
| const xmlChar *name; /* Name of the DTD */ |
| struct _xmlNode *children; /* the value of the property link */ |
| struct _xmlNode *last; /* last child link */ |
| struct _xmlDoc *parent; /* child->parent link */ |
| struct _xmlNode *next; /* next sibling link */ |
| struct _xmlNode *prev; /* previous sibling link */ |
| struct _xmlDoc *doc; /* the containing document */ |
| |
| /* End of common part */ |
| void *notations; /* Hash table for notations if any */ |
| void *elements; /* Hash table for elements if any */ |
| void *attributes; /* Hash table for attributes if any */ |
| void *entities; /* Hash table for entities if any */ |
| const xmlChar *ExternalID; /* External identifier for PUBLIC DTD */ |
| const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC DTD */ |
| void *pentities; /* Hash table for param entities if any */ |
| }; |
| |
| /** |
| * xmlAttr: |
| * |
| * An attribute on an XML node. |
| */ |
| typedef struct _xmlAttr xmlAttr; |
| typedef xmlAttr *xmlAttrPtr; |
| struct _xmlAttr { |
| void *_private; /* application data */ |
| xmlElementType type; /* XML_ATTRIBUTE_NODE, must be second ! */ |
| const xmlChar *name; /* the name of the property */ |
| struct _xmlNode *children; /* the value of the property */ |
| struct _xmlNode *last; /* NULL */ |
| struct _xmlNode *parent; /* child->parent link */ |
| struct _xmlAttr *next; /* next sibling link */ |
| struct _xmlAttr *prev; /* previous sibling link */ |
| struct _xmlDoc *doc; /* the containing document */ |
| xmlNs *ns; /* pointer to the associated namespace */ |
| xmlAttributeType atype; /* the attribute type if validating */ |
| void *psvi; /* for type/PSVI informations */ |
| }; |
| |
| /** |
| * xmlID: |
| * |
| * An XML ID instance. |
| */ |
| |
| typedef struct _xmlID xmlID; |
| typedef xmlID *xmlIDPtr; |
| struct _xmlID { |
| struct _xmlID *next; /* next ID */ |
| const xmlChar *value; /* The ID name */ |
| xmlAttrPtr attr; /* The attribute holding it */ |
| const xmlChar *name; /* The attribute if attr is not available */ |
| int lineno; /* The line number if attr is not available */ |
| struct _xmlDoc *doc; /* The document holding the ID */ |
| }; |
| |
| /** |
| * xmlRef: |
| * |
| * An XML IDREF instance. |
| */ |
| |
| typedef struct _xmlRef xmlRef; |
| typedef xmlRef *xmlRefPtr; |
| struct _xmlRef { |
| struct _xmlRef *next; /* next Ref */ |
| const xmlChar *value; /* The Ref name */ |
| xmlAttrPtr attr; /* The attribute holding it */ |
| const xmlChar *name; /* The attribute if attr is not available */ |
| int lineno; /* The line number if attr is not available */ |
| }; |
| |
| /** |
| * xmlBufferAllocationScheme: |
| * |
| * A buffer allocation scheme can be defined to either match exactly the |
| * need or double it's allocated size each time it is found too small. |
| */ |
| |
| typedef enum { |
| XML_BUFFER_ALLOC_DOUBLEIT, |
| XML_BUFFER_ALLOC_EXACT, |
| XML_BUFFER_ALLOC_IMMUTABLE |
| } xmlBufferAllocationScheme; |
| |
| /** |
| * xmlBuffer: |
| * |
| * A buffer structure. |
| */ |
| typedef struct _xmlBuffer xmlBuffer; |
| typedef xmlBuffer *xmlBufferPtr; |
| struct _xmlBuffer { |
| xmlChar *content; /* The buffer content UTF8 */ |
| unsigned int use; /* The buffer size used */ |
| unsigned int size; /* The buffer size */ |
| xmlBufferAllocationScheme alloc; /* The realloc method */ |
| }; |
| |
| /** |
| * xmlNode: |
| * |
| * A node in an XML tree. |
| */ |
| typedef struct _xmlNode xmlNode; |
| typedef xmlNode *xmlNodePtr; |
| struct _xmlNode { |
| void *_private; /* application data */ |
| xmlElementType type; /* type number, must be second ! */ |
| const xmlChar *name; /* the name of the node, or the entity */ |
| struct _xmlNode *children; /* parent->childs link */ |
| struct _xmlNode *last; /* last child link */ |
| struct _xmlNode *parent; /* child->parent link */ |
| struct _xmlNode *next; /* next sibling link */ |
| struct _xmlNode *prev; /* previous sibling link */ |
| struct _xmlDoc *doc; /* the containing document */ |
| |
| /* End of common part */ |
| xmlNs *ns; /* pointer to the associated namespace */ |
| xmlChar *content; /* the content */ |
| struct _xmlAttr *properties;/* properties list */ |
| xmlNs *nsDef; /* namespace definitions on this node */ |
| void *psvi; /* for type/PSVI informations */ |
| unsigned short line; /* line number */ |
| unsigned short extra; /* extra data for XPath/XSLT */ |
| }; |
| |
| /** |
| * XML_GET_CONTENT: |
| * |
| * Macro to extract the content pointer of a node. |
| */ |
| #define XML_GET_CONTENT(n) \ |
| ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content) |
| |
| /** |
| * XML_GET_LINE: |
| * |
| * Macro to extract the line number of an element node. |
| */ |
| #define XML_GET_LINE(n) \ |
| (xmlGetLineNo(n)) |
| |
| |
| /** |
| * xmlDoc: |
| * |
| * An XML document. |
| */ |
| typedef struct _xmlDoc xmlDoc; |
| typedef xmlDoc *xmlDocPtr; |
| struct _xmlDoc { |
| void *_private; /* application data */ |
| xmlElementType type; /* XML_DOCUMENT_NODE, must be second ! */ |
| char *name; /* name/filename/URI of the document */ |
| struct _xmlNode *children; /* the document tree */ |
| struct _xmlNode *last; /* last child link */ |
| struct _xmlNode *parent; /* child->parent link */ |
| struct _xmlNode *next; /* next sibling link */ |
| struct _xmlNode *prev; /* previous sibling link */ |
| struct _xmlDoc *doc; /* autoreference to itself */ |
| |
| /* End of common part */ |
| int compression;/* level of zlib compression */ |
| int standalone; /* standalone document (no external refs) */ |
| struct _xmlDtd *intSubset; /* the document internal subset */ |
| struct _xmlDtd *extSubset; /* the document external subset */ |
| struct _xmlNs *oldNs; /* Global namespace, the old way */ |
| const xmlChar *version; /* the XML version string */ |
| const xmlChar *encoding; /* external initial encoding, if any */ |
| void *ids; /* Hash table for ID attributes if any */ |
| void *refs; /* Hash table for IDREFs attributes if any */ |
| const xmlChar *URL; /* The URI for that document */ |
| int charset; /* encoding of the in-memory content |
| actually an xmlCharEncoding */ |
| struct _xmlDict *dict; /* dict used to allocate names or NULL */ |
| void *psvi; /* for type/PSVI informations */ |
| }; |
| |
| /** |
| * xmlChildrenNode: |
| * |
| * Macro for compatibility naming layer with libxml1. Maps |
| * to "children." |
| */ |
| #ifndef xmlChildrenNode |
| #define xmlChildrenNode children |
| #endif |
| |
| /** |
| * xmlRootNode: |
| * |
| * Macro for compatibility naming layer with libxml1. Maps |
| * to "children". |
| */ |
| #ifndef xmlRootNode |
| #define xmlRootNode children |
| #endif |
| |
| /* |
| * Variables. |
| */ |
| |
| /* |
| * Some helper functions |
| */ |
| XMLPUBFUN int XMLCALL |
| xmlValidateNCName (const xmlChar *value, |
| int space); |
| XMLPUBFUN int XMLCALL |
| xmlValidateQName (const xmlChar *value, |
| int space); |
| XMLPUBFUN int XMLCALL |
| xmlValidateName (const xmlChar *value, |
| int space); |
| XMLPUBFUN int XMLCALL |
| xmlValidateNMToken (const xmlChar *value, |
| int space); |
| |
| XMLPUBFUN xmlChar * XMLCALL |
| xmlBuildQName (const xmlChar *ncname, |
| const xmlChar *prefix, |
| xmlChar *memory, |
| int len); |
| XMLPUBFUN xmlChar * XMLCALL |
| xmlSplitQName2 (const xmlChar *name, |
| xmlChar **prefix); |
| XMLPUBFUN const xmlChar * XMLCALL |
| xmlSplitQName3 (const xmlChar *name, |
| int *len); |
| |
| /* |
| * Handling Buffers. |
| */ |
| |
| XMLPUBFUN void XMLCALL |
| xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme); |
| XMLPUBFUN xmlBufferAllocationScheme XMLCALL |
| xmlGetBufferAllocationScheme(void); |
| |
| XMLPUBFUN xmlBufferPtr XMLCALL |
| xmlBufferCreate (void); |
| XMLPUBFUN xmlBufferPtr XMLCALL |
| xmlBufferCreateSize (size_t size); |
| XMLPUBFUN xmlBufferPtr XMLCALL |
| xmlBufferCreateStatic (void *mem, |
| size_t size); |
| XMLPUBFUN int XMLCALL |
| xmlBufferResize (xmlBufferPtr buf, |
| unsigned int size); |
| XMLPUBFUN void XMLCALL |
| xmlBufferFree (xmlBufferPtr buf); |
| XMLPUBFUN int XMLCALL |
| xmlBufferDump (FILE *file, |
| xmlBufferPtr buf); |
| XMLPUBFUN void XMLCALL |
| xmlBufferAdd (xmlBufferPtr buf, |
| const xmlChar *str, |
| int len); |
| XMLPUBFUN void XMLCALL |
| xmlBufferAddHead (xmlBufferPtr buf, |
| const xmlChar *str, |
| int len); |
| XMLPUBFUN void XMLCALL |
| xmlBufferCat (xmlBufferPtr buf, |
| const xmlChar *str); |
| XMLPUBFUN void XMLCALL |
| xmlBufferCCat (xmlBufferPtr buf, |
| const char *str); |
| XMLPUBFUN int XMLCALL |
| xmlBufferShrink (xmlBufferPtr buf, |
| unsigned int len); |
| XMLPUBFUN int XMLCALL |
| xmlBufferGrow (xmlBufferPtr buf, |
| unsigned int len); |
| XMLPUBFUN void XMLCALL |
| xmlBufferEmpty (xmlBufferPtr buf); |
| XMLPUBFUN const xmlChar* XMLCALL |
| xmlBufferContent (const xmlBufferPtr buf); |
| XMLPUBFUN void XMLCALL |
| xmlBufferSetAllocationScheme(xmlBufferPtr buf, |
| xmlBufferAllocationScheme scheme); |
| XMLPUBFUN int XMLCALL |
| xmlBufferLength (const xmlBufferPtr buf); |
| |
| /* |
| * Creating/freeing new structures. |
| */ |
| XMLPUBFUN xmlDtdPtr XMLCALL |
| xmlCreateIntSubset (xmlDocPtr doc, |
| const xmlChar *name, |
| const xmlChar *ExternalID, |
| const xmlChar *SystemID); |
| XMLPUBFUN xmlDtdPtr XMLCALL |
| xmlNewDtd (xmlDocPtr doc, |
| const xmlChar *name, |
| const xmlChar *ExternalID, |
| const xmlChar *SystemID); |
| XMLPUBFUN xmlDtdPtr XMLCALL |
| xmlGetIntSubset (xmlDocPtr doc); |
| XMLPUBFUN void XMLCALL |
| xmlFreeDtd (xmlDtdPtr cur); |
| XMLPUBFUN xmlNsPtr XMLCALL |
| xmlNewGlobalNs (xmlDocPtr doc, |
| const xmlChar *href, |
| const xmlChar *prefix); |
| XMLPUBFUN xmlNsPtr XMLCALL |
| xmlNewNs (xmlNodePtr node, |
| const xmlChar *href, |
| const xmlChar *prefix); |
| XMLPUBFUN void XMLCALL |
| xmlFreeNs (xmlNsPtr cur); |
| XMLPUBFUN void XMLCALL |
| xmlFreeNsList (xmlNsPtr cur); |
| XMLPUBFUN xmlDocPtr XMLCALL |
| xmlNewDoc (const xmlChar *version); |
| XMLPUBFUN void XMLCALL |
| xmlFreeDoc (xmlDocPtr cur); |
| XMLPUBFUN xmlAttrPtr XMLCALL |
| xmlNewDocProp (xmlDocPtr doc, |
| const xmlChar *name, |
| const xmlChar *value); |
| XMLPUBFUN xmlAttrPtr XMLCALL |
| xmlNewProp (xmlNodePtr node, |
| const xmlChar *name, |
| const xmlChar *value); |
| XMLPUBFUN xmlAttrPtr XMLCALL |
| xmlNewNsProp (xmlNodePtr node, |
| xmlNsPtr ns, |
| const xmlChar *name, |
| const xmlChar *value); |
| XMLPUBFUN xmlAttrPtr XMLCALL |
| xmlNewNsPropEatName (xmlNodePtr node, |
| xmlNsPtr ns, |
| xmlChar *name, |
| const xmlChar *value); |
| XMLPUBFUN void XMLCALL |
| xmlFreePropList (xmlAttrPtr cur); |
| XMLPUBFUN void XMLCALL |
| xmlFreeProp (xmlAttrPtr cur); |
| XMLPUBFUN xmlAttrPtr XMLCALL |
| xmlCopyProp (xmlNodePtr target, |
| xmlAttrPtr cur); |
| XMLPUBFUN xmlAttrPtr XMLCALL |
| xmlCopyPropList (xmlNodePtr target, |
| xmlAttrPtr cur); |
| #ifdef LIBXML_TREE_ENABLED |
| XMLPUBFUN xmlDtdPtr XMLCALL |
| xmlCopyDtd (xmlDtdPtr dtd); |
| XMLPUBFUN xmlDocPtr XMLCALL |
| xmlCopyDoc (xmlDocPtr doc, |
| int recursive); |
| #endif /* LIBXML_TREE_ENABLED */ |
| |
| /* |
| * Creating new nodes. |
| */ |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewDocNode (xmlDocPtr doc, |
| xmlNsPtr ns, |
| const xmlChar *name, |
| const xmlChar *content); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewDocNodeEatName (xmlDocPtr doc, |
| xmlNsPtr ns, |
| xmlChar *name, |
| const xmlChar *content); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewDocRawNode (xmlDocPtr doc, |
| xmlNsPtr ns, |
| const xmlChar *name, |
| const xmlChar *content); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewNode (xmlNsPtr ns, |
| const xmlChar *name); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewNodeEatName (xmlNsPtr ns, |
| xmlChar *name); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewChild (xmlNodePtr parent, |
| xmlNsPtr ns, |
| const xmlChar *name, |
| const xmlChar *content); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewTextChild (xmlNodePtr parent, |
| xmlNsPtr ns, |
| const xmlChar *name, |
| const xmlChar *content); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewDocText (xmlDocPtr doc, |
| const xmlChar *content); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewText (const xmlChar *content); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewPI (const xmlChar *name, |
| const xmlChar *content); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewDocTextLen (xmlDocPtr doc, |
| const xmlChar *content, |
| int len); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewTextLen (const xmlChar *content, |
| int len); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewDocComment (xmlDocPtr doc, |
| const xmlChar *content); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewComment (const xmlChar *content); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewCDataBlock (xmlDocPtr doc, |
| const xmlChar *content, |
| int len); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewCharRef (xmlDocPtr doc, |
| const xmlChar *name); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewReference (xmlDocPtr doc, |
| const xmlChar *name); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlCopyNode (const xmlNodePtr node, |
| int recursive); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlDocCopyNode (const xmlNodePtr node, |
| xmlDocPtr doc, |
| int recursive); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlCopyNodeList (const xmlNodePtr node); |
| #ifdef LIBXML_TREE_ENABLED |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlNewDocFragment (xmlDocPtr doc); |
| #endif /* LIBXML_TREE_ENABLED */ |
| |
| /* |
| * Navigating. |
| */ |
| XMLPUBFUN long XMLCALL |
| xmlGetLineNo (xmlNodePtr node); |
| #ifdef LIBXML_TREE_ENABLED |
| XMLPUBFUN xmlChar * XMLCALL |
| xmlGetNodePath (xmlNodePtr node); |
| #endif /* LIBXML_TREE_ENABLED */ |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlDocGetRootElement (xmlDocPtr doc); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlGetLastChild (xmlNodePtr parent); |
| XMLPUBFUN int XMLCALL |
| xmlNodeIsText (xmlNodePtr node); |
| XMLPUBFUN int XMLCALL |
| xmlIsBlankNode (xmlNodePtr node); |
| |
| #ifdef LIBXML_TREE_ENABLED |
| /* |
| * Changing the structure. |
| */ |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlDocSetRootElement (xmlDocPtr doc, |
| xmlNodePtr root); |
| XMLPUBFUN void XMLCALL |
| xmlNodeSetName (xmlNodePtr cur, |
| const xmlChar *name); |
| #endif /* LIBXML_TREE_ENABLED */ |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlAddChild (xmlNodePtr parent, |
| xmlNodePtr cur); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlAddChildList (xmlNodePtr parent, |
| xmlNodePtr cur); |
| #ifdef LIBXML_TREE_ENABLED |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlReplaceNode (xmlNodePtr old, |
| xmlNodePtr cur); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlAddPrevSibling (xmlNodePtr cur, |
| xmlNodePtr elem); |
| #endif /* LIBXML_TREE_ENABLED */ |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlAddSibling (xmlNodePtr cur, |
| xmlNodePtr elem); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlAddNextSibling (xmlNodePtr cur, |
| xmlNodePtr elem); |
| XMLPUBFUN void XMLCALL |
| xmlUnlinkNode (xmlNodePtr cur); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlTextMerge (xmlNodePtr first, |
| xmlNodePtr second); |
| XMLPUBFUN int XMLCALL |
| xmlTextConcat (xmlNodePtr node, |
| const xmlChar *content, |
| int len); |
| XMLPUBFUN void XMLCALL |
| xmlFreeNodeList (xmlNodePtr cur); |
| XMLPUBFUN void XMLCALL |
| xmlFreeNode (xmlNodePtr cur); |
| XMLPUBFUN void XMLCALL |
| xmlSetTreeDoc (xmlNodePtr tree, |
| xmlDocPtr doc); |
| XMLPUBFUN void XMLCALL |
| xmlSetListDoc (xmlNodePtr list, |
| xmlDocPtr doc); |
| /* |
| * Namespaces. |
| */ |
| XMLPUBFUN xmlNsPtr XMLCALL |
| xmlSearchNs (xmlDocPtr doc, |
| xmlNodePtr node, |
| const xmlChar *nameSpace); |
| XMLPUBFUN xmlNsPtr XMLCALL |
| xmlSearchNsByHref (xmlDocPtr doc, |
| xmlNodePtr node, |
| const xmlChar *href); |
| #ifdef LIBXML_TREE_ENABLED |
| XMLPUBFUN xmlNsPtr * XMLCALL |
| xmlGetNsList (xmlDocPtr doc, |
| xmlNodePtr node); |
| #endif /* LIBXML_TREE_ENABLED */ |
| |
| XMLPUBFUN void XMLCALL |
| xmlSetNs (xmlNodePtr node, |
| xmlNsPtr ns); |
| XMLPUBFUN xmlNsPtr XMLCALL |
| xmlCopyNamespace (xmlNsPtr cur); |
| XMLPUBFUN xmlNsPtr XMLCALL |
| xmlCopyNamespaceList (xmlNsPtr cur); |
| |
| /* |
| * Changing the content. |
| */ |
| #ifdef LIBXML_TREE_ENABLED |
| XMLPUBFUN xmlAttrPtr XMLCALL |
| xmlSetProp (xmlNodePtr node, |
| const xmlChar *name, |
| const xmlChar *value); |
| #endif /* LIBXML_TREE_ENABLED */ |
| XMLPUBFUN xmlChar * XMLCALL |
| xmlGetNoNsProp (xmlNodePtr node, |
| const xmlChar *name); |
| XMLPUBFUN xmlChar * XMLCALL |
| xmlGetProp (xmlNodePtr node, |
| const xmlChar *name); |
| XMLPUBFUN xmlAttrPtr XMLCALL |
| xmlHasProp (xmlNodePtr node, |
| const xmlChar *name); |
| XMLPUBFUN xmlAttrPtr XMLCALL |
| xmlHasNsProp (xmlNodePtr node, |
| const xmlChar *name, |
| const xmlChar *nameSpace); |
| #ifdef LIBXML_TREE_ENABLED |
| XMLPUBFUN xmlAttrPtr XMLCALL |
| xmlSetNsProp (xmlNodePtr node, |
| xmlNsPtr ns, |
| const xmlChar *name, |
| const xmlChar *value); |
| #endif /* LIBXML_TREE_ENABLED */ |
| XMLPUBFUN xmlChar * XMLCALL |
| xmlGetNsProp (xmlNodePtr node, |
| const xmlChar *name, |
| const xmlChar *nameSpace); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlStringGetNodeList (xmlDocPtr doc, |
| const xmlChar *value); |
| XMLPUBFUN xmlNodePtr XMLCALL |
| xmlStringLenGetNodeList (xmlDocPtr doc, |
| const xmlChar *value, |
| int len); |
| XMLPUBFUN xmlChar * XMLCALL |
| xmlNodeListGetString (xmlDocPtr doc, |
| xmlNodePtr list, |
| int inLine); |
| #ifdef LIBXML_TREE_ENABLED |
| XMLPUBFUN xmlChar * XMLCALL |
| xmlNodeListGetRawString (xmlDocPtr doc, |
| xmlNodePtr list, |
| int inLine); |
| #endif /* LIBXML_TREE_ENABLED */ |
| XMLPUBFUN void XMLCALL |
| xmlNodeSetContent (xmlNodePtr cur, |
| const xmlChar *content); |
| #ifdef LIBXML_TREE_ENABLED |
| XMLPUBFUN void XMLCALL |
| xmlNodeSetContentLen (xmlNodePtr cur, |
| const xmlChar *content, |
| int len); |
| #endif /* LIBXML_TREE_ENABLED */ |
| XMLPUBFUN void XMLCALL |
| xmlNodeAddContent (xmlNodePtr cur, |
| const xmlChar *content); |
| XMLPUBFUN void XMLCALL |
| xmlNodeAddContentLen (xmlNodePtr cur, |
| const xmlChar *content, |
| int len); |
| XMLPUBFUN xmlChar * XMLCALL |
| xmlNodeGetContent (xmlNodePtr cur); |
| XMLPUBFUN int XMLCALL |
| xmlNodeBufGetContent (xmlBufferPtr buffer, |
| xmlNodePtr cur); |
| XMLPUBFUN xmlChar * XMLCALL |
| xmlNodeGetLang (xmlNodePtr cur); |
| XMLPUBFUN int XMLCALL |
| xmlNodeGetSpacePreserve (xmlNodePtr cur); |
| #ifdef LIBXML_TREE_ENABLED |
| XMLPUBFUN void XMLCALL |
| xmlNodeSetLang (xmlNodePtr cur, |
| const xmlChar *lang); |
| XMLPUBFUN void XMLCALL |
| xmlNodeSetSpacePreserve (xmlNodePtr cur, |
| int val); |
| #endif /* LIBXML_TREE_ENABLED */ |
| XMLPUBFUN xmlChar * XMLCALL |
| xmlNodeGetBase (xmlDocPtr doc, |
| xmlNodePtr cur); |
| #ifdef LIBXML_TREE_ENABLED |
| XMLPUBFUN void XMLCALL |
| xmlNodeSetBase (xmlNodePtr cur, |
| const xmlChar *uri); |
| |
| /* |
| * Removing content. |
| */ |
| XMLPUBFUN int XMLCALL |
| xmlRemoveProp (xmlAttrPtr cur); |
| XMLPUBFUN int XMLCALL |
| xmlUnsetProp (xmlNodePtr node, |
| const xmlChar *name); |
| XMLPUBFUN int XMLCALL |
| xmlUnsetNsProp (xmlNodePtr node, |
| xmlNsPtr ns, |
| const xmlChar *name); |
| #endif /* LIBXML_TREE_ENABLED */ |
| |
| /* |
| * Internal, don't use. |
| */ |
| XMLPUBFUN void XMLCALL |
| xmlBufferWriteCHAR (xmlBufferPtr buf, |
| const xmlChar *string); |
| XMLPUBFUN void XMLCALL |
| xmlBufferWriteChar (xmlBufferPtr buf, |
| const char *string); |
| XMLPUBFUN void XMLCALL |
| xmlBufferWriteQuotedString(xmlBufferPtr buf, |
| const xmlChar *string); |
| |
| /* |
| * Namespace handling. |
| */ |
| XMLPUBFUN int XMLCALL |
| xmlReconciliateNs (xmlDocPtr doc, |
| xmlNodePtr tree); |
| |
| #ifdef LIBXML_OUTPUT_ENABLED |
| /* |
| * Saving. |
| */ |
| XMLPUBFUN void XMLCALL |
| xmlDocDumpFormatMemory (xmlDocPtr cur, |
| xmlChar **mem, |
| int *size, |
| int format); |
| XMLPUBFUN void XMLCALL |
| xmlDocDumpMemory (xmlDocPtr cur, |
| xmlChar **mem, |
| int *size); |
| XMLPUBFUN void XMLCALL |
| xmlDocDumpMemoryEnc (xmlDocPtr out_doc, |
| xmlChar **doc_txt_ptr, |
| int * doc_txt_len, |
| const char *txt_encoding); |
| XMLPUBFUN void XMLCALL |
| xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, |
| xmlChar **doc_txt_ptr, |
| int * doc_txt_len, |
| const char *txt_encoding, |
| int format); |
| XMLPUBFUN int XMLCALL |
| xmlDocFormatDump (FILE *f, |
| xmlDocPtr cur, |
| int format); |
| XMLPUBFUN int XMLCALL |
| xmlDocDump (FILE *f, |
| xmlDocPtr cur); |
| XMLPUBFUN void XMLCALL |
| xmlElemDump (FILE *f, |
| xmlDocPtr doc, |
| xmlNodePtr cur); |
| XMLPUBFUN int XMLCALL |
| xmlSaveFile (const char *filename, |
| xmlDocPtr cur); |
| XMLPUBFUN int XMLCALL |
| xmlSaveFormatFile (const char *filename, |
| xmlDocPtr cur, |
| int format); |
| XMLPUBFUN int XMLCALL |
| xmlNodeDump (xmlBufferPtr buf, |
| xmlDocPtr doc, |
| xmlNodePtr cur, |
| int level, |
| int format); |
| |
| XMLPUBFUN int XMLCALL |
| xmlSaveFileTo (xmlOutputBufferPtr buf, |
| xmlDocPtr cur, |
| const char *encoding); |
| XMLPUBFUN int XMLCALL |
| xmlSaveFormatFileTo (xmlOutputBufferPtr buf, |
| xmlDocPtr cur, |
| const char *encoding, |
| int format); |
| XMLPUBFUN void XMLCALL |
| xmlNodeDumpOutput (xmlOutputBufferPtr buf, |
| xmlDocPtr doc, |
| xmlNodePtr cur, |
| int level, |
| int format, |
| const char *encoding); |
| |
| XMLPUBFUN int XMLCALL |
| xmlSaveFormatFileEnc (const char *filename, |
| xmlDocPtr cur, |
| const char *encoding, |
| int format); |
| |
| XMLPUBFUN int XMLCALL |
| xmlSaveFileEnc (const char *filename, |
| xmlDocPtr cur, |
| const char *encoding); |
| |
| #endif /* LIBXML_OUTPUT_ENABLED */ |
| /* |
| * XHTML |
| */ |
| XMLPUBFUN int XMLCALL |
| xmlIsXHTML (const xmlChar *systemID, |
| const xmlChar *publicID); |
| |
| /* |
| * Compression. |
| */ |
| XMLPUBFUN int XMLCALL |
| xmlGetDocCompressMode (xmlDocPtr doc); |
| XMLPUBFUN void XMLCALL |
| xmlSetDocCompressMode (xmlDocPtr doc, |
| int mode); |
| XMLPUBFUN int XMLCALL |
| xmlGetCompressMode (void); |
| XMLPUBFUN void XMLCALL |
| xmlSetCompressMode (int mode); |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| #ifndef __XML_PARSER_H__ |
| #include <libxml/xmlmemory.h> |
| #endif |
| |
| #endif /* __XML_TREE_H__ */ |
| |