![]() | ![]() | ![]() | Gnome XML Library Reference Manual | ![]() |
---|
void xmlCheckVersion (int version); #define LIBXML_VERSION_NUMBER #define LIBXML_TEST_VERSION enum xmlElementType; typedef xmlChar; #define CHAR #define BAD_CAST struct xmlNotation; typedef xmlNotationPtr; enum xmlAttributeType; enum xmlAttributeDefault; struct xmlEnumeration; typedef xmlEnumerationPtr; struct xmlAttribute; typedef xmlAttributePtr; enum xmlElementContentType; enum xmlElementContentOccur; struct xmlElementContent; typedef xmlElementContentPtr; enum xmlElementTypeVal; struct xmlElement; typedef xmlElementPtr; enum xmlNsType; struct xmlNs; typedef xmlNsPtr; struct xmlDtd; typedef xmlDtdPtr; struct xmlAttr; typedef xmlAttrPtr; struct xmlID; typedef xmlIDPtr; struct xmlRef; typedef xmlRefPtr; enum xmlBufferAllocationScheme; struct xmlBuffer; typedef xmlBufferPtr; struct xmlNode; typedef xmlNodePtr; struct xmlDoc; typedef xmlDocPtr; #define xmlChildrenNode #define xmlRootNode extern xmlNsPtr baseDTD; extern int oldXMLWDcompatibility; extern int xmlIndentTreeOutput; extern xmlBufferAllocationScheme xmlBufferAllocScheme; extern int xmlSaveNoEmptyTags; xmlBufferPtr xmlBufferCreate (void); xmlBufferPtr xmlBufferCreateSize (size_t size); void xmlBufferFree (xmlBufferPtr buf); int xmlBufferDump (FILE *file, xmlBufferPtr buf); void xmlBufferAdd (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, int len); void xmlBufferEmpty (xmlBufferPtr buf); const xmlChar* xmlBufferContent (const xmlBufferPtr buf); int xmlBufferUse (const xmlBufferPtr buf); void xmlBufferSetAllocationScheme (xmlBufferPtr buf, xmlBufferAllocationScheme scheme); int xmlBufferLength (const xmlBufferPtr buf); 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); 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); 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); 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); xmlNodePtr xmlNewDocNode (xmlDocPtr doc, xmlNsPtr ns, const 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 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 xmlNewReference (xmlDocPtr doc, const xmlChar *name); xmlNodePtr xmlCopyNode (xmlNodePtr node, int recursive); xmlNodePtr xmlCopyNodeList (xmlNodePtr node); xmlNodePtr xmlNewDocFragment (xmlDocPtr doc); xmlNodePtr xmlDocGetRootElement (xmlDocPtr doc); xmlNodePtr xmlGetLastChild (xmlNodePtr parent); int xmlNodeIsText (xmlNodePtr node); int xmlIsBlankNode (xmlNodePtr node); xmlNodePtr xmlDocSetRootElement (xmlDocPtr doc, xmlNodePtr root); void xmlNodeSetName (xmlNodePtr cur, const xmlChar *name); xmlNodePtr xmlAddChild (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); void xmlTextConcat (xmlNodePtr node, const xmlChar *content, int len); void xmlFreeNodeList (xmlNodePtr cur); void xmlFreeNode (xmlNodePtr cur); 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); xmlAttrPtr xmlSetProp (xmlNodePtr node, const xmlChar *name, const xmlChar *value); xmlChar* xmlGetProp (xmlNodePtr node, const xmlChar *name); 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); 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); xmlChar* xmlNodeGetBase (xmlDocPtr doc, xmlNodePtr cur); int xmlRemoveProp (xmlAttrPtr cur); int xmlRemoveNode (xmlNodePtr node); void xmlBufferWriteCHAR (xmlBufferPtr buf, const xmlChar *string); void xmlBufferWriteChar (xmlBufferPtr buf, const char *string); void xmlBufferWriteQuotedString (xmlBufferPtr buf, const xmlChar *string); void xmlDocDumpMemory (xmlDocPtr cur, xmlChar **mem, int *size); void xmlDocDump (FILE *f, xmlDocPtr cur); void xmlElemDump (FILE *f, xmlDocPtr cur, xmlNodePtr elem); int xmlSaveFile (const char *filename, xmlDocPtr cur); int xmlGetDocCompressMode (xmlDocPtr doc); void xmlSetDocCompressMode (xmlDocPtr doc, int mode); int xmlGetCompressMode (void); void xmlSetCompressMode (int mode);
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 } xmlElementType;
struct xmlNotation { const xmlChar *name; /* Notation name */ const xmlChar *PublicID; /* Public identifier, if any */ const xmlChar *SystemID; /* System identifier, if any */ };
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;
typedef enum { XML_ATTRIBUTE_NONE = 1, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED, XML_ATTRIBUTE_FIXED } xmlAttributeDefault;
struct xmlEnumeration { struct _xmlEnumeration *next; /* next one */ const xmlChar *name; /* Enumeration name */ };
struct xmlAttribute { const xmlChar *elem; /* Element holding the attribute */ const xmlChar *name; /* Attribute name */ struct _xmlAttribute *next; /* list of attributes of an element */ xmlAttributeType type; /* The 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 */ };
typedef enum { XML_ELEMENT_CONTENT_PCDATA = 1, XML_ELEMENT_CONTENT_ELEMENT, XML_ELEMENT_CONTENT_SEQ, XML_ELEMENT_CONTENT_OR } xmlElementContentType;
typedef enum { XML_ELEMENT_CONTENT_ONCE = 1, XML_ELEMENT_CONTENT_OPT, XML_ELEMENT_CONTENT_MULT, XML_ELEMENT_CONTENT_PLUS } xmlElementContentOccur;
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 */ };
typedef enum { XML_ELEMENT_TYPE_EMPTY = 1, XML_ELEMENT_TYPE_ANY, XML_ELEMENT_TYPE_MIXED, XML_ELEMENT_TYPE_ELEMENT } xmlElementTypeVal;
struct xmlElement { const xmlChar *name; /* Element name */ xmlElementTypeVal type; /* The type */ xmlElementContentPtr content; /* the allowed element content */ xmlAttributePtr attributes; /* List of the declared attributes */ };
typedef enum { XML_GLOBAL_NAMESPACE = 1, /* old style global namespace */ XML_LOCAL_NAMESPACE /* new style local scoping */ } xmlNsType;
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 */ };
struct xmlDtd { const xmlChar *name; /* Name of the DTD */ const xmlChar *ExternalID; /* External identifier for PUBLIC DTD */ const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC DTD */ 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 */ /* struct xmlDtd *next; * next link for this document */ };
struct xmlAttr { #ifndef XML_WITHOUT_CORBA void *_private; /* for Corba, must be first ! */ void *vepv; /* for Corba, must be next ! */ #endif xmlElementType type; /* XML_ATTRIBUTE_NODE, must be third ! */ struct _xmlNode *node; /* attr->node link */ struct _xmlAttr *next; /* attribute list link */ const xmlChar *name; /* the name of the property */ struct _xmlNode *val; /* the value of the property */ xmlNs *ns; /* pointer to the associated namespace */ };
struct xmlID { struct _xmlID *next; /* next ID */ const xmlChar *value; /* The ID name */ xmlAttrPtr attr; /* The attribut holding it */ };
struct xmlRef { struct _xmlRef *next; /* next Ref */ const xmlChar *value; /* The Ref name */ xmlAttrPtr attr; /* The attribut holding it */ };
typedef enum { XML_BUFFER_ALLOC_DOUBLEIT, XML_BUFFER_ALLOC_EXACT } xmlBufferAllocationScheme;
Sets the allocation scheme for this buffer
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 */ };
struct xmlNode { #ifndef XML_WITHOUT_CORBA void *_private; /* for Corba, must be first ! */ void *vepv; /* for Corba, must be next ! */ #endif xmlElementType type; /* type number in the DTD, must be third ! */ struct _xmlDoc *doc; /* the containing document */ struct _xmlNode *parent; /* child->parent link */ struct _xmlNode *next; /* next sibling link */ struct _xmlNode *prev; /* previous sibling link */ struct _xmlNode *childs; /* parent->childs link */ struct _xmlNode *last; /* last child link */ struct _xmlAttr *properties;/* properties list */ const xmlChar *name; /* the name of the node, or the entity */ xmlNs *ns; /* pointer to the associated namespace */ xmlNs *nsDef; /* namespace definitions on this node */ #ifndef XML_USE_BUFFER_CONTENT xmlChar *content; /* the content */ #else xmlBufferPtr content; /* the content in a buffer */ #endif };
struct xmlDoc { #ifndef XML_WITHOUT_CORBA void *_private; /* for Corba, must be first ! */ void *vepv; /* for Corba, must be next ! */ #endif xmlElementType type; /* XML_DOCUMENT_NODE, must be second ! */ char *name; /* name/filename/URI of the document */ const xmlChar *version; /* the XML version string */ const xmlChar *encoding; /* encoding, if any */ 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 */ struct _xmlNode *root; /* the document tree */ void *ids; /* Hash table for ID attributes if any */ void *refs; /* Hash table for IDREFs attributes if any */ };
extern xmlBufferAllocationScheme xmlBufferAllocScheme; /* alloc scheme to use */
xmlBufferPtr xmlBufferCreate (void);
routine to create an XML buffer.
Returns : | the new structure. |
xmlBufferPtr xmlBufferCreateSize (size_t size);
routine to create an XML buffer.
size : | initial size of buffer |
Returns : | the new structure. |
int xmlBufferDump (FILE *file, xmlBufferPtr buf);
Dumps an XML buffer to a FILE *.
file : | the file output |
buf : | the buffer to dump |
Returns : | the number of xmlChar written |
void xmlBufferAdd (xmlBufferPtr buf, const xmlChar *str, int len);
Add a string range to an XML buffer. if len == -1, the lenght of str is recomputed.
buf : | the buffer to dump |
str : | the xmlChar string |
len : | the number of xmlChar to add |
void xmlBufferCat (xmlBufferPtr buf, const xmlChar *str);
Append a zero terminated string to an XML buffer.
buf : | the buffer to dump |
str : | the xmlChar string |
void xmlBufferCCat (xmlBufferPtr buf, const char *str);
Append a zero terminated C string to an XML buffer.
buf : | the buffer to dump |
str : | the C char string |
int xmlBufferShrink (xmlBufferPtr buf, int len);
Remove the beginning of an XML buffer.
buf : | the buffer to dump |
len : | the number of xmlChar to remove |
Returns : | the number of xmlChar removed, or -1 in case of failure. |
const xmlChar* xmlBufferContent (const xmlBufferPtr buf);
buf : | the buffer to resize |
Returns : | the internal content |
void xmlBufferSetAllocationScheme (xmlBufferPtr buf, xmlBufferAllocationScheme scheme);
buf : | |
scheme : |
|
int xmlBufferLength (const xmlBufferPtr buf);
buf : | the buffer |
Returns : | the length of data in the internal content |
xmlDtdPtr xmlCreateIntSubset (xmlDocPtr doc, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID);
Create the internal subset of a document
doc : | the document pointer |
name : | the DTD name |
ExternalID : | the external ID |
SystemID : | the system ID |
Returns : | a pointer to the new DTD structure |
xmlDtdPtr xmlNewDtd (xmlDocPtr doc, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID);
Creation of a new DTD.
doc : | the document pointer |
name : | the DTD name |
ExternalID : | the external ID |
SystemID : | the system ID |
Returns : | a pointer to the new DTD structure |
void xmlFreeDtd (xmlDtdPtr cur);
Free a DTD structure.
cur : | the DTD structure to free up |
xmlNsPtr xmlNewGlobalNs (xmlDocPtr doc, const xmlChar *href, const xmlChar *prefix);
Creation of a Namespace, the old way using PI and without scoping DEPRECATED !!! It now create a namespace on the root element of the document if found.
doc : | the document carrying the namespace |
href : | the URI associated |
prefix : | the prefix for the namespace |
Returns : | NULL this functionnality had been removed |
xmlNsPtr xmlNewNs (xmlNodePtr node, const xmlChar *href, const xmlChar *prefix);
Creation of a new Namespace. This function will refuse to create a namespace with a similar prefix than an existing one present on this node.
node : | the element carrying the namespace |
href : | the URI associated |
prefix : | the prefix for the namespace |
Returns : | returns a new namespace pointer or NULL |
void xmlFreeNs (xmlNsPtr cur);
Free up the structures associated to a namespace
cur : | the namespace pointer |
xmlDocPtr xmlNewDoc (const xmlChar *version);
version : | xmlChar string giving the version of XML "1.0" |
Returns : | a new document |
void xmlFreeDoc (xmlDocPtr cur);
Free up all the structures used by a document, tree included.
cur : | pointer to the document @: |
xmlAttrPtr xmlNewDocProp (xmlDocPtr doc, const xmlChar *name, const xmlChar *value);
Create a new property carried by a document.
doc : | the document |
name : | the name of the attribute |
value : | the value of the attribute |
Returns : | a pointer to the attribute |
xmlAttrPtr xmlNewProp (xmlNodePtr node, const xmlChar *name, const xmlChar *value);
Create a new property carried by a node.
node : | the holding node |
name : | the name of the attribute |
value : | the value of the attribute |
Returns : | a pointer to the attribute |
xmlAttrPtr xmlNewNsProp (xmlNodePtr node, xmlNsPtr ns, const xmlChar *name, const xmlChar *value);
Create a new property tagged with a namespace and carried by a node.
node : | the holding node |
ns : | the namespace |
name : | the name of the attribute |
value : | the value of the attribute |
Returns : | a pointer to the attribute |
void xmlFreePropList (xmlAttrPtr cur);
Free a property and all its siblings, all the childs are freed too.
cur : | the first property in the list |
void xmlFreeProp (xmlAttrPtr cur);
Free one attribute, all the content is freed too
cur : | an attribute |
xmlAttrPtr xmlCopyProp (xmlNodePtr target, xmlAttrPtr cur);
Do a copy of the attribute.
target : | the element where the attribute will be grafted |
cur : | the attribute |
Returns : | a new xmlAttrPtr, or NULL in case of error. |
xmlAttrPtr xmlCopyPropList (xmlNodePtr target, xmlAttrPtr cur);
Do a copy of an attribute list.
target : | the element where the attributes will be grafted |
cur : | the first attribute |
Returns : | a new xmlAttrPtr, or NULL in case of error. |
xmlDtdPtr xmlCopyDtd (xmlDtdPtr dtd);
Do a copy of the dtd.
dtd : | the dtd |
Returns : | a new xmlDtdPtr, or NULL in case of error. |
xmlDocPtr xmlCopyDoc (xmlDocPtr doc, int recursive);
Do a copy of the document info. If recursive, the content tree will be copied too as well as Dtd, namespaces and entities.
doc : | the document |
recursive : | if 1 do a recursive copy. |
Returns : | a new xmlDocPtr, or NULL in case of error. |
xmlNodePtr xmlNewDocNode (xmlDocPtr doc, xmlNsPtr ns, const xmlChar *name, const xmlChar *content);
Creation of a new node element within a document. ns and content are optionnal (NULL). NOTE: content is supposed to be a piece of XML CDATA, so it allow entities references, but XML special chars need to be escaped first by using xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you don't need entities support.
doc : | the document |
ns : | namespace if any |
name : | the node name |
content : | the XML text content if any |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlNewDocRawNode (xmlDocPtr doc, xmlNsPtr ns, const xmlChar *name, const xmlChar *content);
Creation of a new node element within a document. ns and content are optionnal (NULL).
doc : | the document |
ns : | namespace if any |
name : | the node name |
content : | the text content if any |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlNewNode (xmlNsPtr ns, const xmlChar *name);
Creation of a new node element. ns and content are optionnal (NULL). If content is non NULL, a child list containing the TEXTs and ENTITY_REFs node will be created.
ns : | namespace if any |
name : | the node name |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlNewChild (xmlNodePtr parent, xmlNsPtr ns, const xmlChar *name, const xmlChar *content);
Creation of a new child element, added at the end of parent childs list. ns and content parameters are optionnal (NULL). If content is non NULL, a child list containing the TEXTs and ENTITY_REFs node will be created. NOTE: content is supposed to be a piece of XML CDATA, so it allow entities references, but XML special chars need to be escaped first by using xmlEncodeEntitiesReentrant(). Use xmlNewTextChild() if entities support is not needed.
parent : | the parent node |
ns : | a namespace if any |
name : | the name of the child |
content : | the XML content of the child if any. |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlNewTextChild (xmlNodePtr parent, xmlNsPtr ns, const xmlChar *name, const xmlChar *content);
Creation of a new child element, added at the end of parent childs list. ns and content parameters are optionnal (NULL). If content is non NULL, a child TEXT node will be created containing the string content.
parent : | the parent node |
ns : | a namespace if any |
name : | the name of the child |
content : | the text content of the child if any. |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlNewDocText (xmlDocPtr doc, const xmlChar *content);
Creation of a new text node within a document.
doc : | the document |
content : | the text content |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlNewText (const xmlChar *content);
Creation of a new text node.
content : | the text content |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlNewPI (const xmlChar *name, const xmlChar *content);
Creation of a processing instruction element.
name : | the processing instruction name |
content : | the PI content |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlNewDocTextLen (xmlDocPtr doc, const xmlChar *content, int len);
Creation of a new text node with an extra content lenght parameter. The text node pertain to a given document.
doc : | the document |
content : | the text content |
len : | the text len. |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlNewTextLen (const xmlChar *content, int len);
Creation of a new text node with an extra parameter for the content's lenght
content : | the text content |
len : | the text len. |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlNewDocComment (xmlDocPtr doc, const xmlChar *content);
Creation of a new node containing a commentwithin a document.
doc : | the document |
content : | the comment content |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlNewComment (const xmlChar *content);
Creation of a new node containing a comment.
content : | the comment content |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlNewCDataBlock (xmlDocPtr doc, const xmlChar *content, int len);
Creation of a new node containing a CData block.
doc : | the document |
content : | the CData block content content |
len : | the length of the block |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlNewReference (xmlDocPtr doc, const xmlChar *name);
Creation of a new reference node.
doc : | the document |
name : | the reference name, or the reference string with & and ; |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlCopyNode (xmlNodePtr node, int recursive);
Do a copy of the node.
node : | the node |
recursive : | if 1 do a recursive copy. |
Returns : | a new xmlNodePtr, or NULL in case of error. |
xmlNodePtr xmlCopyNodeList (xmlNodePtr node);
Do a recursive copy of the node list.
node : | the first node in the list. |
Returns : | a new xmlNodePtr, or NULL in case of error. |
xmlNodePtr xmlNewDocFragment (xmlDocPtr doc);
Creation of a new Fragment node.
doc : | the document owning the fragment |
Returns : | a pointer to the new node object. |
xmlNodePtr xmlDocGetRootElement (xmlDocPtr doc);
Get the root element of the document (doc->root is a list containing possibly comments, PIs, etc ...).
doc : | the document |
Returns : | the xmlNodePtr for the root or NULL |
xmlNodePtr xmlGetLastChild (xmlNodePtr parent);
Search the last child of a node.
parent : | the parent node |
Returns : | the last child or NULL if none. |
int xmlNodeIsText (xmlNodePtr node);
Is this node a Text node ?
node : | the node |
Returns : | 1 yes, 0 no |
int xmlIsBlankNode (xmlNodePtr node);
Is this node a Text node ?
node : | the node |
Returns : | 1 yes, 0 no |
xmlNodePtr xmlDocSetRootElement (xmlDocPtr doc, xmlNodePtr root);
Set the root element of the document (doc->root is a list containing possibly comments, PIs, etc ...).
doc : | the document |
root : | the new document root element |
Returns : | the old root element if any was found |
void xmlNodeSetName (xmlNodePtr cur, const xmlChar *name);
Searches the language of a node, i.e. the values of the xml:lang attribute or the one carried by the nearest ancestor.
cur : | the node being changed |
name : | the new tag name |
xmlNodePtr xmlAddChild (xmlNodePtr parent, xmlNodePtr cur);
Add a new child element, to parent, at the end of the child list.
parent : | the parent node |
cur : | the child node |
Returns : | the child or NULL in case of error. |
xmlNodePtr xmlReplaceNode (xmlNodePtr old, xmlNodePtr cur);
Unlink the old node from it's current context, prune the new one at the same place. If cur was already inserted in a document it is first unlinked from its existing context.
old : | the old node |
cur : | the node |
Returns : | the old node |
xmlNodePtr xmlAddSibling (xmlNodePtr cur, xmlNodePtr elem);
Add a new element elem to the list of siblings of cur If the new element was already inserted in a document it is first unlinked from its existing context.
cur : | the child node |
elem : | the new node |
Returns : | the new element or NULL in case of error. |
xmlNodePtr xmlAddPrevSibling (xmlNodePtr cur, xmlNodePtr elem);
Add a new element elem as the previous siblings of cur If the new element was already inserted in a document it is first unlinked from its existing context.
cur : | the child node |
elem : | the new node |
Returns : | the new element or NULL in case of error. |
xmlNodePtr xmlAddNextSibling (xmlNodePtr cur, xmlNodePtr elem);
Add a new element elem as the next siblings of cur If the new element was already inserted in a document it is first unlinked from its existing context.
cur : | the child node |
elem : | the new node |
Returns : | the new element or NULL in case of error. |
void xmlUnlinkNode (xmlNodePtr cur);
Unlink a node from it's current context, the node is not freed
cur : | the node |
xmlNodePtr xmlTextMerge (xmlNodePtr first, xmlNodePtr second);
Merge two text nodes into one
first : | the first text node |
second : | the second text node being merged |
Returns : | the first text node augmented |
void xmlTextConcat (xmlNodePtr node, const xmlChar *content, int len);
Concat the given string at the end of the existing node content
node : | the node |
content : | the content |
len : | content lenght |
void xmlFreeNodeList (xmlNodePtr cur);
Free a node and all its siblings, this is a recursive behaviour, all the childs are freed too.
cur : | the first node in the list |
void xmlFreeNode (xmlNodePtr cur);
Free a node, this is a recursive behaviour, all the childs are freed too.
cur : | the node |
xmlNsPtr xmlSearchNs (xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace);
Search a Ns registered under a given name space for a document. recurse on the parents until it finds the defined namespace or return NULL otherwise. nameSpace can be NULL, this is a search for the default namespace.
doc : | the document |
node : | the current node |
nameSpace : | the namespace string |
Returns : | the namespace pointer or NULL. |
xmlNsPtr xmlSearchNsByHref (xmlDocPtr doc, xmlNodePtr node, const xmlChar *href);
Search a Ns aliasing a given URI. Recurse on the parents until it finds the defined namespace or return NULL otherwise.
doc : | the document |
node : | the current node |
href : | the namespace value |
Returns : | the namespace pointer or NULL. |
xmlNsPtr* xmlGetNsList (xmlDocPtr doc, xmlNodePtr node);
Search all the namespace applying to a given element.
doc : | the document |
node : | the current node |
Returns : | an NULL terminated array of all the xmlNsPtr found that need to be freed by the caller or NULL if no namespace if defined |
void xmlSetNs (xmlNodePtr node, xmlNsPtr ns);
Associate a namespace to a node, a posteriori.
node : | a node in the document |
ns : | a namespace pointer |
xmlNsPtr xmlCopyNamespace (xmlNsPtr cur);
Do a copy of the namespace.
cur : | the namespace |
Returns : | a new xmlNsPtr, or NULL in case of error. |
xmlNsPtr xmlCopyNamespaceList (xmlNsPtr cur);
Do a copy of an namespace list.
cur : | the first namespace |
Returns : | a new xmlNsPtr, or NULL in case of error. |
xmlAttrPtr xmlSetProp (xmlNodePtr node, const xmlChar *name, const xmlChar *value);
Set (or reset) an attribute carried by a node.
node : | the node |
name : | the attribute name |
value : | the attribute value |
Returns : | the attribute pointer. |
xmlChar* xmlGetProp (xmlNodePtr node, const xmlChar *name);
Search and get the value of an attribute associated to a node
This does the entity substitution.
This function looks in DTD attribute declaration for
node : | the node |
name : | the attribute name |
Returns : | the attribute value or NULL if not found. It's up to the caller to free the memory. |
xmlChar* xmlGetNsProp (xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace);
Search and get the value of an attribute associated to a node
This attribute has to be anchored in the namespace specified.
This does the entity substitution.
This function looks in DTD attribute declaration for
node : | the node |
name : | the attribute name |
nameSpace : | the URI of the namespace |
Returns : | the attribute value or NULL if not found. It's up to the caller to free the memory. |
xmlNodePtr xmlStringGetNodeList (xmlDocPtr doc, const xmlChar *value);
Parse the value string and build the node list associated. Should produce a flat tree with only TEXTs and ENTITY_REFs.
doc : | the document |
value : | the value of the attribute |
Returns : | a pointer to the first child |
xmlNodePtr xmlStringLenGetNodeList (xmlDocPtr doc, const xmlChar *value, int len);
Parse the value string and build the node list associated. Should produce a flat tree with only TEXTs and ENTITY_REFs.
doc : | the document |
value : | the value of the text |
len : | the length of the string value |
Returns : | a pointer to the first child |
xmlChar* xmlNodeListGetString (xmlDocPtr doc, xmlNodePtr list, int inLine);
Returns the string equivalent to the text contained in the Node list made of TEXTs and ENTITY_REFs
doc : | the document |
list : | a Node list |
inLine : | should we replace entity contents or show their external form |
Returns : | a pointer to the string copy, the calller must free it. |
void xmlNodeSetContent (xmlNodePtr cur, const xmlChar *content);
Replace the content of a node.
cur : | the node being modified |
content : | the new value of the content |
void xmlNodeSetContentLen (xmlNodePtr cur, const xmlChar *content, int len);
Replace the content of a node.
cur : | the node being modified |
content : | the new value of the content |
len : | the size of content |
void xmlNodeAddContent (xmlNodePtr cur, const xmlChar *content);
Append the extra substring to the node content.
cur : | the node being modified |
content : | extra content |
void xmlNodeAddContentLen (xmlNodePtr cur, const xmlChar *content, int len);
Append the extra substring to the node content.
cur : | the node being modified |
content : | extra content |
len : | the size of content |
xmlChar* xmlNodeGetContent (xmlNodePtr cur);
Read the value of a node, this can be either the text carried directly by this node if it's a TEXT node or the aggregate string of the values carried by this node child's (TEXT and ENTITY_REF). Entity references are substitued.
cur : | the node being read |
Returns : | a new xmlChar * or NULL if no content is available. It's up to the caller to free the memory. |
xmlChar* xmlNodeGetLang (xmlNodePtr cur);
Searches the language of a node, i.e. the values of the xml:lang attribute or the one carried by the nearest ancestor.
cur : | the node being checked |
Returns : | a pointer to the lang value, or NULL if not found It's up to the caller to free the memory. |
void xmlNodeSetLang (xmlNodePtr cur, const xmlChar *lang);
Set the language of a node, i.e. the values of the xml:lang attribute.
cur : | the node being changed |
lang : | the langage description |
xmlChar* xmlNodeGetBase (xmlDocPtr doc, xmlNodePtr cur);
Searches for the BASE URL. The code should work on both XML and HTML document even if base mechanisms are completely different.
doc : | the document the node pertains to |
cur : | the node being checked |
Returns : | a pointer to the base URL, or NULL if not found It's up to the caller to free the memory. |
int xmlRemoveProp (xmlAttrPtr cur);
Unlink and free one attribute, all the content is freed too Note this doesn't work for namespace definition attributes
cur : | an attribute |
Returns : | 0 if success and -1 in case of error. |
void xmlBufferWriteCHAR (xmlBufferPtr buf, const xmlChar *string);
routine which manage and grows an output buffer. This one add xmlChars at the end of the buffer.
buf : | the XML buffer |
string : | the string to add |
void xmlBufferWriteChar (xmlBufferPtr buf, const char *string);
routine which manage and grows an output buffer. This one add C chars at the end of the array.
buf : | the XML buffer output |
string : | the string to add |
void xmlBufferWriteQuotedString (xmlBufferPtr buf, const xmlChar *string);
routine which manage and grows an output buffer. This one writes a quoted or double quoted xmlChar string, checking first if it holds quote or double-quotes internally
buf : | the XML buffer output |
string : | the string to add |
void xmlDocDumpMemory (xmlDocPtr cur, xmlChar **mem, int *size);
Dump an XML document in memory and return the xmlChar * and it's size. It's up to the caller to free the memory.
cur : | the document |
mem : | OUT: the memory pointer |
size : | OUT: the memory lenght |
void xmlDocDump (FILE *f, xmlDocPtr cur);
Dump an XML document to an open FILE.
f : | the FILE* |
cur : | the document |
void xmlElemDump (FILE *f, xmlDocPtr cur, xmlNodePtr elem);
Dump an XML/HTML node, recursive behaviour,children are printed too.
f : | |
cur : | the current node |
elem : |
|
int xmlSaveFile (const char *filename, xmlDocPtr cur);
Dump an XML document to a file. Will use compression if compiled in and enabled. If filename is "-" the stdout file is used.
filename : | the filename |
cur : | the document |
Returns : | the number of file written or -1 in case of failure. |
int xmlGetDocCompressMode (xmlDocPtr doc);
get the compression ratio for a document, ZLIB based
doc : | the document |
Returns : | 0 (uncompressed) to 9 (max compression) |
void xmlSetDocCompressMode (xmlDocPtr doc, int mode);
set the compression ratio for a document, ZLIB based Correct values: 0 (uncompressed) to 9 (max compression)
doc : | the document |
mode : | the compression ratio |
int xmlGetCompressMode (void);
get the default compression mode used, ZLIB based.
Returns : | 0 (uncompressed) to 9 (max compression) |
void xmlSetCompressMode (int mode);
set the default compression mode used, ZLIB based Correct values: 0 (uncompressed) to 9 (max compression)
mode : | the compression ratio |
<<< SAX | entities >>> |