921 lines
26 KiB
C
921 lines
26 KiB
C
/*
|
|
* tree.h : describes the structures found in an tree resulting
|
|
* from an XML parsing.
|
|
*
|
|
* See Copyright for the status of this software.
|
|
*
|
|
* daniel@veillard.com
|
|
*
|
|
*/
|
|
|
|
#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 */
|
|
};
|
|
|
|
/**
|
|
* 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 */
|
|
};
|
|
|
|
/**
|
|
* 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
|
|
} 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 */
|
|
};
|
|
|
|
/**
|
|
* 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.
|
|
* This will work only if line numbering is activated by
|
|
* calling xmlLineNumbersDefault(1) before parsing.
|
|
*/
|
|
#define XML_GET_LINE(n) \
|
|
((n)->type == XML_ELEMENT_NODE ? (int) (n)->content : 0)
|
|
|
|
/**
|
|
* 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 */
|
|
};
|
|
|
|
/**
|
|
* xmlChildrenNode:
|
|
*
|
|
* Macro for compatibility naming layer with libxml1.
|
|
*/
|
|
#ifndef xmlChildrenNode
|
|
#define xmlChildrenNode children
|
|
#endif
|
|
|
|
/**
|
|
* xmlRootNode:
|
|
*
|
|
* Macro for compatibility naming layer with libxml1.
|
|
*/
|
|
#ifndef xmlRootNode
|
|
#define xmlRootNode children
|
|
#endif
|
|
|
|
/*
|
|
* Variables.
|
|
*/
|
|
#if 0
|
|
LIBXML_DLL_IMPORT extern int oldXMLWDcompatibility;/* maintain compatibility with old WD */
|
|
LIBXML_DLL_IMPORT extern int xmlIndentTreeOutput; /* try to indent the tree dumps */
|
|
LIBXML_DLL_IMPORT extern xmlBufferAllocationScheme xmlBufferAllocScheme; /* alloc scheme to use */
|
|
LIBXML_DLL_IMPORT extern int xmlSaveNoEmptyTags; /* save empty tags as <empty></empty> */
|
|
LIBXML_DLL_IMPORT extern int xmlDefaultBufferSize; /* default buffer size */
|
|
#endif
|
|
|
|
/*
|
|
* Some helper functions
|
|
*/
|
|
int xmlValidateNCName (const xmlChar *value,
|
|
int space);
|
|
int xmlValidateQName (const xmlChar *value,
|
|
int space);
|
|
int xmlValidateName (const xmlChar *value,
|
|
int space);
|
|
int xmlValidateNMToken (const xmlChar *value,
|
|
int space);
|
|
|
|
xmlChar * xmlBuildQName (const xmlChar *ncname,
|
|
const xmlChar *prefix,
|
|
xmlChar *memory,
|
|
int len);
|
|
xmlChar * xmlSplitQName2 (const xmlChar *name,
|
|
xmlChar **prefix);
|
|
const xmlChar * xmlSplitQName3 (const xmlChar *name,
|
|
int *len);
|
|
|
|
/*
|
|
* Handling Buffers.
|
|
*/
|
|
|
|
void xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
|
|
xmlBufferAllocationScheme xmlGetBufferAllocationScheme(void);
|
|
|
|
xmlBufferPtr xmlBufferCreate (void);
|
|
xmlBufferPtr xmlBufferCreateSize (size_t size);
|
|
int xmlBufferResize (xmlBufferPtr buf,
|
|
unsigned int size);
|
|
void xmlBufferFree (xmlBufferPtr buf);
|
|
int xmlBufferDump (FILE *file,
|
|
xmlBufferPtr buf);
|
|
void xmlBufferAdd (xmlBufferPtr buf,
|
|
const xmlChar *str,
|
|
int len);
|
|
void xmlBufferAddHead (xmlBufferPtr buf,
|
|
const xmlChar *str,
|
|
int len);
|
|
void xmlBufferCat (xmlBufferPtr buf,
|
|
const xmlChar *str);
|
|
void xmlBufferCCat (xmlBufferPtr buf,
|
|
const char *str);
|
|
int xmlBufferShrink (xmlBufferPtr buf,
|
|
unsigned int len);
|
|
int xmlBufferGrow (xmlBufferPtr buf,
|
|
unsigned int len);
|
|
void xmlBufferEmpty (xmlBufferPtr buf);
|
|
const xmlChar* xmlBufferContent (const xmlBufferPtr buf);
|
|
void xmlBufferSetAllocationScheme(xmlBufferPtr buf,
|
|
xmlBufferAllocationScheme scheme);
|
|
int xmlBufferLength (const xmlBufferPtr buf);
|
|
|
|
/*
|
|
* Creating/freeing new structures.
|
|
*/
|
|
xmlDtdPtr xmlCreateIntSubset (xmlDocPtr doc,
|
|
const xmlChar *name,
|
|
const xmlChar *ExternalID,
|
|
const xmlChar *SystemID);
|
|
xmlDtdPtr xmlNewDtd (xmlDocPtr doc,
|
|
const xmlChar *name,
|
|
const xmlChar *ExternalID,
|
|
const xmlChar *SystemID);
|
|
xmlDtdPtr xmlGetIntSubset (xmlDocPtr doc);
|
|
void xmlFreeDtd (xmlDtdPtr cur);
|
|
xmlNsPtr xmlNewGlobalNs (xmlDocPtr doc,
|
|
const xmlChar *href,
|
|
const xmlChar *prefix);
|
|
xmlNsPtr xmlNewNs (xmlNodePtr node,
|
|
const xmlChar *href,
|
|
const xmlChar *prefix);
|
|
void xmlFreeNs (xmlNsPtr cur);
|
|
void xmlFreeNsList (xmlNsPtr cur);
|
|
xmlDocPtr xmlNewDoc (const xmlChar *version);
|
|
void xmlFreeDoc (xmlDocPtr cur);
|
|
xmlAttrPtr xmlNewDocProp (xmlDocPtr doc,
|
|
const xmlChar *name,
|
|
const xmlChar *value);
|
|
xmlAttrPtr xmlNewProp (xmlNodePtr node,
|
|
const xmlChar *name,
|
|
const xmlChar *value);
|
|
xmlAttrPtr xmlNewNsProp (xmlNodePtr node,
|
|
xmlNsPtr ns,
|
|
const xmlChar *name,
|
|
const xmlChar *value);
|
|
xmlAttrPtr xmlNewNsPropEatName (xmlNodePtr node,
|
|
xmlNsPtr ns,
|
|
xmlChar *name,
|
|
const xmlChar *value);
|
|
void xmlFreePropList (xmlAttrPtr cur);
|
|
void xmlFreeProp (xmlAttrPtr cur);
|
|
xmlAttrPtr xmlCopyProp (xmlNodePtr target,
|
|
xmlAttrPtr cur);
|
|
xmlAttrPtr xmlCopyPropList (xmlNodePtr target,
|
|
xmlAttrPtr cur);
|
|
xmlDtdPtr xmlCopyDtd (xmlDtdPtr dtd);
|
|
xmlDocPtr xmlCopyDoc (xmlDocPtr doc,
|
|
int recursive);
|
|
|
|
/*
|
|
* Creating new nodes.
|
|
*/
|
|
xmlNodePtr xmlNewDocNode (xmlDocPtr doc,
|
|
xmlNsPtr ns,
|
|
const xmlChar *name,
|
|
const xmlChar *content);
|
|
xmlNodePtr xmlNewDocNodeEatName (xmlDocPtr doc,
|
|
xmlNsPtr ns,
|
|
xmlChar *name,
|
|
const xmlChar *content);
|
|
xmlNodePtr xmlNewDocRawNode (xmlDocPtr doc,
|
|
xmlNsPtr ns,
|
|
const xmlChar *name,
|
|
const xmlChar *content);
|
|
xmlNodePtr xmlNewNode (xmlNsPtr ns,
|
|
const xmlChar *name);
|
|
xmlNodePtr xmlNewNodeEatName (xmlNsPtr ns,
|
|
xmlChar *name);
|
|
xmlNodePtr xmlNewChild (xmlNodePtr parent,
|
|
xmlNsPtr ns,
|
|
const xmlChar *name,
|
|
const xmlChar *content);
|
|
xmlNodePtr xmlNewTextChild (xmlNodePtr parent,
|
|
xmlNsPtr ns,
|
|
const xmlChar *name,
|
|
const xmlChar *content);
|
|
xmlNodePtr xmlNewDocText (xmlDocPtr doc,
|
|
const xmlChar *content);
|
|
xmlNodePtr xmlNewText (const xmlChar *content);
|
|
xmlNodePtr xmlNewPI (const xmlChar *name,
|
|
const xmlChar *content);
|
|
xmlNodePtr xmlNewDocTextLen (xmlDocPtr doc,
|
|
const xmlChar *content,
|
|
int len);
|
|
xmlNodePtr xmlNewTextLen (const xmlChar *content,
|
|
int len);
|
|
xmlNodePtr xmlNewDocComment (xmlDocPtr doc,
|
|
const xmlChar *content);
|
|
xmlNodePtr xmlNewComment (const xmlChar *content);
|
|
xmlNodePtr xmlNewCDataBlock (xmlDocPtr doc,
|
|
const xmlChar *content,
|
|
int len);
|
|
xmlNodePtr xmlNewCharRef (xmlDocPtr doc,
|
|
const xmlChar *name);
|
|
xmlNodePtr xmlNewReference (xmlDocPtr doc,
|
|
const xmlChar *name);
|
|
xmlNodePtr xmlCopyNode (const xmlNodePtr node,
|
|
int recursive);
|
|
xmlNodePtr xmlDocCopyNode (const xmlNodePtr node,
|
|
xmlDocPtr doc,
|
|
int recursive);
|
|
xmlNodePtr xmlCopyNodeList (const xmlNodePtr node);
|
|
xmlNodePtr xmlNewDocFragment (xmlDocPtr doc);
|
|
|
|
/*
|
|
* Navigating.
|
|
*/
|
|
long xmlGetLineNo (xmlNodePtr node);
|
|
xmlChar * xmlGetNodePath (xmlNodePtr node);
|
|
xmlNodePtr xmlDocGetRootElement (xmlDocPtr doc);
|
|
xmlNodePtr xmlGetLastChild (xmlNodePtr parent);
|
|
int xmlNodeIsText (xmlNodePtr node);
|
|
int xmlIsBlankNode (xmlNodePtr node);
|
|
|
|
/*
|
|
* Changing the structure.
|
|
*/
|
|
xmlNodePtr xmlDocSetRootElement (xmlDocPtr doc,
|
|
xmlNodePtr root);
|
|
void xmlNodeSetName (xmlNodePtr cur,
|
|
const xmlChar *name);
|
|
xmlNodePtr xmlAddChild (xmlNodePtr parent,
|
|
xmlNodePtr cur);
|
|
xmlNodePtr xmlAddChildList (xmlNodePtr parent,
|
|
xmlNodePtr cur);
|
|
xmlNodePtr xmlReplaceNode (xmlNodePtr old,
|
|
xmlNodePtr cur);
|
|
xmlNodePtr xmlAddSibling (xmlNodePtr cur,
|
|
xmlNodePtr elem);
|
|
xmlNodePtr xmlAddPrevSibling (xmlNodePtr cur,
|
|
xmlNodePtr elem);
|
|
xmlNodePtr xmlAddNextSibling (xmlNodePtr cur,
|
|
xmlNodePtr elem);
|
|
void xmlUnlinkNode (xmlNodePtr cur);
|
|
xmlNodePtr xmlTextMerge (xmlNodePtr first,
|
|
xmlNodePtr second);
|
|
int xmlTextConcat (xmlNodePtr node,
|
|
const xmlChar *content,
|
|
int len);
|
|
void xmlFreeNodeList (xmlNodePtr cur);
|
|
void xmlFreeNode (xmlNodePtr cur);
|
|
void xmlSetTreeDoc (xmlNodePtr tree,
|
|
xmlDocPtr doc);
|
|
void xmlSetListDoc (xmlNodePtr list,
|
|
xmlDocPtr doc);
|
|
|
|
/*
|
|
* Namespaces.
|
|
*/
|
|
xmlNsPtr xmlSearchNs (xmlDocPtr doc,
|
|
xmlNodePtr node,
|
|
const xmlChar *nameSpace);
|
|
xmlNsPtr xmlSearchNsByHref (xmlDocPtr doc,
|
|
xmlNodePtr node,
|
|
const xmlChar *href);
|
|
xmlNsPtr * xmlGetNsList (xmlDocPtr doc,
|
|
xmlNodePtr node);
|
|
void xmlSetNs (xmlNodePtr node,
|
|
xmlNsPtr ns);
|
|
xmlNsPtr xmlCopyNamespace (xmlNsPtr cur);
|
|
xmlNsPtr xmlCopyNamespaceList (xmlNsPtr cur);
|
|
|
|
/*
|
|
* Changing the content.
|
|
*/
|
|
xmlAttrPtr xmlSetProp (xmlNodePtr node,
|
|
const xmlChar *name,
|
|
const xmlChar *value);
|
|
xmlChar * xmlGetProp (xmlNodePtr node,
|
|
const xmlChar *name);
|
|
xmlChar * xmlGetNoNsProp (xmlNodePtr node,
|
|
const xmlChar *name);
|
|
xmlAttrPtr xmlHasProp (xmlNodePtr node,
|
|
const xmlChar *name);
|
|
xmlAttrPtr xmlHasNsProp (xmlNodePtr node,
|
|
const xmlChar *name,
|
|
const xmlChar *nameSpace);
|
|
xmlAttrPtr xmlSetNsProp (xmlNodePtr node,
|
|
xmlNsPtr ns,
|
|
const xmlChar *name,
|
|
const xmlChar *value);
|
|
xmlChar * xmlGetNsProp (xmlNodePtr node,
|
|
const xmlChar *name,
|
|
const xmlChar *nameSpace);
|
|
xmlNodePtr xmlStringGetNodeList (xmlDocPtr doc,
|
|
const xmlChar *value);
|
|
xmlNodePtr xmlStringLenGetNodeList (xmlDocPtr doc,
|
|
const xmlChar *value,
|
|
int len);
|
|
xmlChar * xmlNodeListGetString (xmlDocPtr doc,
|
|
xmlNodePtr list,
|
|
int inLine);
|
|
xmlChar * xmlNodeListGetRawString (xmlDocPtr doc,
|
|
xmlNodePtr list,
|
|
int inLine);
|
|
void xmlNodeSetContent (xmlNodePtr cur,
|
|
const xmlChar *content);
|
|
void xmlNodeSetContentLen (xmlNodePtr cur,
|
|
const xmlChar *content,
|
|
int len);
|
|
void xmlNodeAddContent (xmlNodePtr cur,
|
|
const xmlChar *content);
|
|
void xmlNodeAddContentLen (xmlNodePtr cur,
|
|
const xmlChar *content,
|
|
int len);
|
|
xmlChar * xmlNodeGetContent (xmlNodePtr cur);
|
|
xmlChar * xmlNodeGetLang (xmlNodePtr cur);
|
|
void xmlNodeSetLang (xmlNodePtr cur,
|
|
const xmlChar *lang);
|
|
int xmlNodeGetSpacePreserve (xmlNodePtr cur);
|
|
void xmlNodeSetSpacePreserve (xmlNodePtr cur,
|
|
int val);
|
|
xmlChar * xmlNodeGetBase (xmlDocPtr doc,
|
|
xmlNodePtr cur);
|
|
void xmlNodeSetBase (xmlNodePtr cur,
|
|
xmlChar *uri);
|
|
|
|
/*
|
|
* Removing content.
|
|
*/
|
|
int xmlRemoveProp (xmlAttrPtr cur);
|
|
int xmlUnsetProp (xmlNodePtr node,
|
|
const xmlChar *name);
|
|
int xmlUnsetNsProp (xmlNodePtr node,
|
|
xmlNsPtr ns,
|
|
const xmlChar *name);
|
|
|
|
/*
|
|
* Internal, don't use.
|
|
*/
|
|
void xmlBufferWriteCHAR (xmlBufferPtr buf,
|
|
const xmlChar *string);
|
|
void xmlBufferWriteChar (xmlBufferPtr buf,
|
|
const char *string);
|
|
void xmlBufferWriteQuotedString(xmlBufferPtr buf,
|
|
const xmlChar *string);
|
|
|
|
/*
|
|
* Namespace handling.
|
|
*/
|
|
int xmlReconciliateNs (xmlDocPtr doc,
|
|
xmlNodePtr tree);
|
|
|
|
/*
|
|
* Saving.
|
|
*/
|
|
void xmlDocDumpFormatMemory (xmlDocPtr cur,
|
|
xmlChar **mem,
|
|
int *size,
|
|
int format);
|
|
void xmlDocDumpMemory (xmlDocPtr cur,
|
|
xmlChar **mem,
|
|
int *size);
|
|
void xmlDocDumpMemoryEnc (xmlDocPtr out_doc,
|
|
xmlChar **doc_txt_ptr,
|
|
int * doc_txt_len,
|
|
const char *txt_encoding);
|
|
void xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
|
|
xmlChar **doc_txt_ptr,
|
|
int * doc_txt_len,
|
|
const char *txt_encoding,
|
|
int format);
|
|
int xmlDocFormatDump(FILE *f,
|
|
xmlDocPtr cur,
|
|
int format);
|
|
int xmlDocDump (FILE *f,
|
|
xmlDocPtr cur);
|
|
void xmlElemDump (FILE *f,
|
|
xmlDocPtr doc,
|
|
xmlNodePtr cur);
|
|
int xmlSaveFile (const char *filename,
|
|
xmlDocPtr cur);
|
|
int xmlSaveFormatFile (const char *filename,
|
|
xmlDocPtr cur,
|
|
int format);
|
|
int xmlNodeDump (xmlBufferPtr buf,
|
|
xmlDocPtr doc,
|
|
xmlNodePtr cur,
|
|
int level,
|
|
int format);
|
|
|
|
int xmlSaveFileTo (xmlOutputBufferPtr buf,
|
|
xmlDocPtr cur,
|
|
const char *encoding);
|
|
int xmlSaveFormatFileTo (xmlOutputBufferPtr buf,
|
|
xmlDocPtr cur,
|
|
const char *encoding,
|
|
int format);
|
|
void xmlNodeDumpOutput (xmlOutputBufferPtr buf,
|
|
xmlDocPtr doc,
|
|
xmlNodePtr cur,
|
|
int level,
|
|
int format,
|
|
const char *encoding);
|
|
|
|
int xmlSaveFormatFileEnc (const char *filename,
|
|
xmlDocPtr cur,
|
|
const char *encoding,
|
|
int format);
|
|
|
|
int xmlSaveFileEnc (const char *filename,
|
|
xmlDocPtr cur,
|
|
const char *encoding);
|
|
|
|
/*
|
|
* XHTML
|
|
*/
|
|
int xmlIsXHTML (const xmlChar *systemID,
|
|
const xmlChar *publicID);
|
|
|
|
/*
|
|
* Compression.
|
|
*/
|
|
int xmlGetDocCompressMode (xmlDocPtr doc);
|
|
void xmlSetDocCompressMode (xmlDocPtr doc,
|
|
int mode);
|
|
int xmlGetCompressMode (void);
|
|
void xmlSetCompressMode (int mode);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#ifndef __XML_PARSER_H__
|
|
#include <libxml/xmlmemory.h>
|
|
#endif
|
|
|
|
#endif /* __XML_TREE_H__ */
|
|
|