Sindbad~EG File Manager
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>tree: interfaces for tree manipulation</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-threads.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-uri.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">tree</span></h2>
<p>tree - interfaces for tree manipulation</p>
<p>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 </p>
<p>Author(s): Daniel Veillard </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">#define <a href="#BASE_BUFFER_SIZE">BASE_BUFFER_SIZE</a>;
#define <a href="#LIBXML2_NEW_BUFFER">LIBXML2_NEW_BUFFER</a>;
#define <a href="#XML_GET_CONTENT">XML_GET_CONTENT</a>;
#define <a href="#XML_GET_LINE">XML_GET_LINE</a>;
#define <a href="#XML_LOCAL_NAMESPACE">XML_LOCAL_NAMESPACE</a>;
#define <a href="#XML_XML_ID">XML_XML_ID</a>;
#define <a href="#XML_XML_NAMESPACE">XML_XML_NAMESPACE</a>;
#define <a href="#xmlChildrenNode">xmlChildrenNode</a>;
#define <a href="#xmlRootNode">xmlRootNode</a>;
typedef struct _xmlAttr <a href="#xmlAttr">xmlAttr</a>;
typedef <a href="libxml2-tree.html#xmlAttr">xmlAttr</a> * <a href="#xmlAttrPtr">xmlAttrPtr</a>;
typedef struct _xmlAttribute <a href="#xmlAttribute">xmlAttribute</a>;
typedef enum <a href="#xmlAttributeDefault">xmlAttributeDefault</a>;
typedef <a href="libxml2-tree.html#xmlAttribute">xmlAttribute</a> * <a href="#xmlAttributePtr">xmlAttributePtr</a>;
typedef enum <a href="#xmlAttributeType">xmlAttributeType</a>;
typedef struct _xmlBuf <a href="#xmlBuf">xmlBuf</a>;
typedef <a href="libxml2-tree.html#xmlBuf">xmlBuf</a> * <a href="#xmlBufPtr">xmlBufPtr</a>;
typedef struct _xmlBuffer <a href="#xmlBuffer">xmlBuffer</a>;
typedef enum <a href="#xmlBufferAllocationScheme">xmlBufferAllocationScheme</a>;
typedef <a href="libxml2-tree.html#xmlBuffer">xmlBuffer</a> * <a href="#xmlBufferPtr">xmlBufferPtr</a>;
typedef struct _xmlDOMWrapCtxt <a href="#xmlDOMWrapCtxt">xmlDOMWrapCtxt</a>;
typedef <a href="libxml2-tree.html#xmlDOMWrapCtxt">xmlDOMWrapCtxt</a> * <a href="#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a>;
typedef struct _xmlDoc <a href="#xmlDoc">xmlDoc</a>;
typedef enum <a href="#xmlDocProperties">xmlDocProperties</a>;
typedef <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * <a href="#xmlDocPtr">xmlDocPtr</a>;
typedef struct _xmlDtd <a href="#xmlDtd">xmlDtd</a>;
typedef <a href="libxml2-tree.html#xmlDtd">xmlDtd</a> * <a href="#xmlDtdPtr">xmlDtdPtr</a>;
typedef struct _xmlElement <a href="#xmlElement">xmlElement</a>;
typedef struct _xmlElementContent <a href="#xmlElementContent">xmlElementContent</a>;
typedef enum <a href="#xmlElementContentOccur">xmlElementContentOccur</a>;
typedef <a href="libxml2-tree.html#xmlElementContent">xmlElementContent</a> * <a href="#xmlElementContentPtr">xmlElementContentPtr</a>;
typedef enum <a href="#xmlElementContentType">xmlElementContentType</a>;
typedef <a href="libxml2-tree.html#xmlElement">xmlElement</a> * <a href="#xmlElementPtr">xmlElementPtr</a>;
typedef enum <a href="#xmlElementType">xmlElementType</a>;
typedef enum <a href="#xmlElementTypeVal">xmlElementTypeVal</a>;
typedef struct _xmlEntity <a href="#xmlEntity">xmlEntity</a>;
typedef <a href="libxml2-tree.html#xmlEntity">xmlEntity</a> * <a href="#xmlEntityPtr">xmlEntityPtr</a>;
typedef struct _xmlEnumeration <a href="#xmlEnumeration">xmlEnumeration</a>;
typedef <a href="libxml2-tree.html#xmlEnumeration">xmlEnumeration</a> * <a href="#xmlEnumerationPtr">xmlEnumerationPtr</a>;
typedef struct _xmlID <a href="#xmlID">xmlID</a>;
typedef <a href="libxml2-tree.html#xmlID">xmlID</a> * <a href="#xmlIDPtr">xmlIDPtr</a>;
typedef struct _xmlNode <a href="#xmlNode">xmlNode</a>;
typedef <a href="libxml2-tree.html#xmlNode">xmlNode</a> * <a href="#xmlNodePtr">xmlNodePtr</a>;
typedef struct _xmlNotation <a href="#xmlNotation">xmlNotation</a>;
typedef <a href="libxml2-tree.html#xmlNotation">xmlNotation</a> * <a href="#xmlNotationPtr">xmlNotationPtr</a>;
typedef struct _xmlNs <a href="#xmlNs">xmlNs</a>;
typedef <a href="libxml2-tree.html#xmlNs">xmlNs</a> * <a href="#xmlNsPtr">xmlNsPtr</a>;
typedef <a href="libxml2-tree.html#xmlElementType">xmlElementType</a> <a href="#xmlNsType">xmlNsType</a>;
typedef struct _xmlOutputBuffer <a href="#xmlOutputBuffer">xmlOutputBuffer</a>;
typedef <a href="libxml2-tree.html#xmlOutputBuffer">xmlOutputBuffer</a> * <a href="#xmlOutputBufferPtr">xmlOutputBufferPtr</a>;
typedef struct _xmlParserCtxt <a href="#xmlParserCtxt">xmlParserCtxt</a>;
typedef <a href="libxml2-tree.html#xmlParserCtxt">xmlParserCtxt</a> * <a href="#xmlParserCtxtPtr">xmlParserCtxtPtr</a>;
typedef struct _xmlParserInput <a href="#xmlParserInput">xmlParserInput</a>;
typedef struct _xmlParserInputBuffer <a href="#xmlParserInputBuffer">xmlParserInputBuffer</a>;
typedef <a href="libxml2-tree.html#xmlParserInputBuffer">xmlParserInputBuffer</a> * <a href="#xmlParserInputBufferPtr">xmlParserInputBufferPtr</a>;
typedef <a href="libxml2-tree.html#xmlParserInput">xmlParserInput</a> * <a href="#xmlParserInputPtr">xmlParserInputPtr</a>;
typedef struct _xmlRef <a href="#xmlRef">xmlRef</a>;
typedef <a href="libxml2-tree.html#xmlRef">xmlRef</a> * <a href="#xmlRefPtr">xmlRefPtr</a>;
typedef struct _xmlSAXHandler <a href="#xmlSAXHandler">xmlSAXHandler</a>;
typedef <a href="libxml2-tree.html#xmlSAXHandler">xmlSAXHandler</a> * <a href="#xmlSAXHandlerPtr">xmlSAXHandlerPtr</a>;
typedef struct _xmlSAXLocator <a href="#xmlSAXLocator">xmlSAXLocator</a>;
typedef <a href="libxml2-tree.html#xmlSAXLocator">xmlSAXLocator</a> * <a href="#xmlSAXLocatorPtr">xmlSAXLocatorPtr</a>;
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlAddChild">xmlAddChild</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlAddChildList">xmlAddChildList</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlAddNextSibling">xmlAddNextSibling</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> prev, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlAddPrevSibling">xmlAddPrevSibling</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> next, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlAddSibling">xmlAddSibling</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
void <a href="#xmlAttrSerializeTxtContent">xmlAttrSerializeTxtContent</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> attr, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * string);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlBufContent">xmlBufContent</a> (const <a href="libxml2-tree.html#xmlBuf">xmlBuf</a> * buf);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlBufEnd">xmlBufEnd</a> (<a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> buf);
int <a href="#xmlBufGetNodeContent">xmlBufGetNodeContent</a> (<a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> buf, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur);
size_t <a href="#xmlBufNodeDump">xmlBufNodeDump</a> (<a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> buf, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> int level, <br> int format);
size_t <a href="#xmlBufShrink">xmlBufShrink</a> (<a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> buf, <br> size_t len);
size_t <a href="#xmlBufUse">xmlBufUse</a> (const <a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> buf);
int <a href="#xmlBufferAdd">xmlBufferAdd</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str, <br> int len);
int <a href="#xmlBufferAddHead">xmlBufferAddHead</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str, <br> int len);
int <a href="#xmlBufferCCat">xmlBufferCCat</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const char * str);
int <a href="#xmlBufferCat">xmlBufferCat</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str);
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlBufferContent">xmlBufferContent</a> (const <a href="libxml2-tree.html#xmlBuffer">xmlBuffer</a> * buf);
<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> <a href="#xmlBufferCreate">xmlBufferCreate</a> (void);
<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> <a href="#xmlBufferCreateSize">xmlBufferCreateSize</a> (size_t size);
<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> <a href="#xmlBufferCreateStatic">xmlBufferCreateStatic</a> (void * mem, <br> size_t size);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlBufferDetach">xmlBufferDetach</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf);
int <a href="#xmlBufferDump">xmlBufferDump</a> (FILE * file, <br> <a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf);
void <a href="#xmlBufferEmpty">xmlBufferEmpty</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf);
void <a href="#xmlBufferFree">xmlBufferFree</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf);
int <a href="#xmlBufferGrow">xmlBufferGrow</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> unsigned int len);
int <a href="#xmlBufferLength">xmlBufferLength</a> (const <a href="libxml2-tree.html#xmlBuffer">xmlBuffer</a> * buf);
int <a href="#xmlBufferResize">xmlBufferResize</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> unsigned int size);
void <a href="#xmlBufferSetAllocationScheme">xmlBufferSetAllocationScheme</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> <a href="libxml2-tree.html#xmlBufferAllocationScheme">xmlBufferAllocationScheme</a> scheme);
int <a href="#xmlBufferShrink">xmlBufferShrink</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> unsigned int len);
void <a href="#xmlBufferWriteCHAR">xmlBufferWriteCHAR</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * string);
void <a href="#xmlBufferWriteChar">xmlBufferWriteChar</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const char * string);
void <a href="#xmlBufferWriteQuotedString">xmlBufferWriteQuotedString</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * string);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlBuildQName">xmlBuildQName</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ncname, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * memory, <br> int len);
unsigned long <a href="#xmlChildElementCount">xmlChildElementCount</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent);
<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> <a href="#xmlCopyDoc">xmlCopyDoc</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> int recursive);
<a href="libxml2-tree.html#xmlDtdPtr">xmlDtdPtr</a> <a href="#xmlCopyDtd">xmlCopyDtd</a> (<a href="libxml2-tree.html#xmlDtdPtr">xmlDtdPtr</a> dtd);
<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> <a href="#xmlCopyNamespace">xmlCopyNamespace</a> (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> cur);
<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> <a href="#xmlCopyNamespaceList">xmlCopyNamespaceList</a> (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlCopyNode">xmlCopyNode</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> int extended);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlCopyNodeList">xmlCopyNodeList</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node);
<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> <a href="#xmlCopyProp">xmlCopyProp</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> target, <br> <a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> cur);
<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> <a href="#xmlCopyPropList">xmlCopyPropList</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> target, <br> <a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> cur);
<a href="libxml2-tree.html#xmlDtdPtr">xmlDtdPtr</a> <a href="#xmlCreateIntSubset">xmlCreateIntSubset</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ExternalID, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * SystemID);
typedef <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> <a href="#xmlDOMWrapAcquireNsFunction">xmlDOMWrapAcquireNsFunction</a> (<a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * nsName, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * nsPrefix);
int <a href="#xmlDOMWrapAdoptNode">xmlDOMWrapAdoptNode</a> (<a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> sourceDoc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> destDoc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> destParent, <br> int options);
int <a href="#xmlDOMWrapCloneNode">xmlDOMWrapCloneNode</a> (<a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> sourceDoc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> * resNode, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> destDoc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> destParent, <br> int deep, <br> int options);
void <a href="#xmlDOMWrapFreeCtxt">xmlDOMWrapFreeCtxt</a> (<a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> ctxt);
<a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> <a href="#xmlDOMWrapNewCtxt">xmlDOMWrapNewCtxt</a> (void);
int <a href="#xmlDOMWrapReconcileNamespaces">xmlDOMWrapReconcileNamespaces</a> (<a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> elem, <br> int options);
int <a href="#xmlDOMWrapRemoveNode">xmlDOMWrapRemoveNode</a> (<a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> int options);
<a href="libxml2-tree.html#xmlDeregisterNodeFunc">xmlDeregisterNodeFunc</a> <a href="#xmlDeregisterNodeDefault">xmlDeregisterNodeDefault</a> (<a href="libxml2-tree.html#xmlDeregisterNodeFunc">xmlDeregisterNodeFunc</a> func);
typedef void <a href="#xmlDeregisterNodeFunc">xmlDeregisterNodeFunc</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlDocCopyNode">xmlDocCopyNode</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> int extended);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlDocCopyNodeList">xmlDocCopyNodeList</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node);
int <a href="#xmlDocDump">xmlDocDump</a> (FILE * f, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur);
void <a href="#xmlDocDumpFormatMemory">xmlDocDumpFormatMemory</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** mem, <br> int * size, <br> int format);
void <a href="#xmlDocDumpFormatMemoryEnc">xmlDocDumpFormatMemoryEnc</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> out_doc, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** doc_txt_ptr, <br> int * doc_txt_len, <br> const char * txt_encoding, <br> int format);
void <a href="#xmlDocDumpMemory">xmlDocDumpMemory</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** mem, <br> int * size);
void <a href="#xmlDocDumpMemoryEnc">xmlDocDumpMemoryEnc</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> out_doc, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** doc_txt_ptr, <br> int * doc_txt_len, <br> const char * txt_encoding);
int <a href="#xmlDocFormatDump">xmlDocFormatDump</a> (FILE * f, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> int format);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlDocGetRootElement">xmlDocGetRootElement</a> (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlDocSetRootElement">xmlDocSetRootElement</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> root);
void <a href="#xmlElemDump">xmlElemDump</a> (FILE * f, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlFirstElementChild">xmlFirstElementChild</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent);
void <a href="#xmlFreeDoc">xmlFreeDoc</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur);
void <a href="#xmlFreeDtd">xmlFreeDtd</a> (<a href="libxml2-tree.html#xmlDtdPtr">xmlDtdPtr</a> cur);
void <a href="#xmlFreeNode">xmlFreeNode</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
void <a href="#xmlFreeNodeList">xmlFreeNodeList</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
void <a href="#xmlFreeNs">xmlFreeNs</a> (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> cur);
void <a href="#xmlFreeNsList">xmlFreeNsList</a> (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> cur);
void <a href="#xmlFreeProp">xmlFreeProp</a> (<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> cur);
void <a href="#xmlFreePropList">xmlFreePropList</a> (<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> cur);
<a href="libxml2-tree.html#xmlBufferAllocationScheme">xmlBufferAllocationScheme</a> <a href="#xmlGetBufferAllocationScheme">xmlGetBufferAllocationScheme</a> (void);
int <a href="#xmlGetCompressMode">xmlGetCompressMode</a> (void);
int <a href="#xmlGetDocCompressMode">xmlGetDocCompressMode</a> (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc);
<a href="libxml2-tree.html#xmlDtdPtr">xmlDtdPtr</a> <a href="#xmlGetIntSubset">xmlGetIntSubset</a> (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlGetLastChild">xmlGetLastChild</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * parent);
long <a href="#xmlGetLineNo">xmlGetLineNo</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlGetNoNsProp">xmlGetNoNsProp</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlGetNodePath">xmlGetNodePath</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node);
<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> * <a href="#xmlGetNsList">xmlGetNsList</a> (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node);
int <a href="#xmlGetNsListSafe">xmlGetNsListSafe</a> (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ** out);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlGetNsProp">xmlGetNsProp</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * nameSpace);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlGetProp">xmlGetProp</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> <a href="#xmlHasNsProp">xmlHasNsProp</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * nameSpace);
<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> <a href="#xmlHasProp">xmlHasProp</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
int <a href="#xmlIsBlankNode">xmlIsBlankNode</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node);
int <a href="#xmlIsXHTML">xmlIsXHTML</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * systemID, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * publicID);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlLastElementChild">xmlLastElementChild</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewCDataBlock">xmlNewCDataBlock</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content, <br> int len);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewCharRef">xmlNewCharRef</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewChild">xmlNewChild</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewComment">xmlNewComment</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content);
<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> <a href="#xmlNewDoc">xmlNewDoc</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * version);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewDocComment">xmlNewDocComment</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewDocFragment">xmlNewDocFragment</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewDocNode">xmlNewDocNode</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewDocNodeEatName">xmlNewDocNodeEatName</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewDocPI">xmlNewDocPI</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content);
<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> <a href="#xmlNewDocProp">xmlNewDocProp</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewDocRawNode">xmlNewDocRawNode</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewDocText">xmlNewDocText</a> (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewDocTextLen">xmlNewDocTextLen</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content, <br> int len);
<a href="libxml2-tree.html#xmlDtdPtr">xmlDtdPtr</a> <a href="#xmlNewDtd">xmlNewDtd</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ExternalID, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * SystemID);
<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> <a href="#xmlNewGlobalNs">xmlNewGlobalNs</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * href, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewNode">xmlNewNode</a> (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewNodeEatName">xmlNewNodeEatName</a> (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> <a href="#xmlNewNs">xmlNewNs</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * href, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix);
<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> <a href="#xmlNewNsProp">xmlNewNsProp</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value);
<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> <a href="#xmlNewNsPropEatName">xmlNewNsPropEatName</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewPI">xmlNewPI</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content);
<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> <a href="#xmlNewProp">xmlNewProp</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewReference">xmlNewReference</a> (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewText">xmlNewText</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewTextChild">xmlNewTextChild</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNewTextLen">xmlNewTextLen</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content, <br> int len);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlNextElementSibling">xmlNextElementSibling</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node);
int <a href="#xmlNodeAddContent">xmlNodeAddContent</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content);
int <a href="#xmlNodeAddContentLen">xmlNodeAddContentLen</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content, <br> int len);
int <a href="#xmlNodeBufGetContent">xmlNodeBufGetContent</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buffer, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur);
int <a href="#xmlNodeDump">xmlNodeDump</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> int level, <br> int format);
void <a href="#xmlNodeDumpOutput">xmlNodeDumpOutput</a> (<a href="libxml2-tree.html#xmlOutputBufferPtr">xmlOutputBufferPtr</a> buf, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> int level, <br> int format, <br> const char * encoding);
int <a href="#xmlNodeGetAttrValue">xmlNodeGetAttrValue</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * nsUri, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** out);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlNodeGetBase">xmlNodeGetBase</a> (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur);
int <a href="#xmlNodeGetBaseSafe">xmlNodeGetBaseSafe</a> (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** baseOut);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlNodeGetContent">xmlNodeGetContent</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlNodeGetLang">xmlNodeGetLang</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur);
int <a href="#xmlNodeGetSpacePreserve">xmlNodeGetSpacePreserve</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur);
int <a href="#xmlNodeIsText">xmlNodeIsText</a> (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlNodeListGetRawString">xmlNodeListGetRawString</a> (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * list, <br> int inLine);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlNodeListGetString">xmlNodeListGetString</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * list, <br> int inLine);
int <a href="#xmlNodeSetBase">xmlNodeSetBase</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * uri);
int <a href="#xmlNodeSetContent">xmlNodeSetContent</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content);
int <a href="#xmlNodeSetContentLen">xmlNodeSetContentLen</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content, <br> int len);
int <a href="#xmlNodeSetLang">xmlNodeSetLang</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * lang);
void <a href="#xmlNodeSetName">xmlNodeSetName</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
int <a href="#xmlNodeSetSpacePreserve">xmlNodeSetSpacePreserve</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> int val);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlPreviousElementSibling">xmlPreviousElementSibling</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node);
int <a href="#xmlReconciliateNs">xmlReconciliateNs</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> tree);
<a href="libxml2-tree.html#xmlRegisterNodeFunc">xmlRegisterNodeFunc</a> <a href="#xmlRegisterNodeDefault">xmlRegisterNodeDefault</a> (<a href="libxml2-tree.html#xmlRegisterNodeFunc">xmlRegisterNodeFunc</a> func);
typedef void <a href="#xmlRegisterNodeFunc">xmlRegisterNodeFunc</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node);
int <a href="#xmlRemoveProp">xmlRemoveProp</a> (<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlReplaceNode">xmlReplaceNode</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> old, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
int <a href="#xmlSaveFile">xmlSaveFile</a> (const char * filename, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur);
int <a href="#xmlSaveFileEnc">xmlSaveFileEnc</a> (const char * filename, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> const char * encoding);
int <a href="#xmlSaveFileTo">xmlSaveFileTo</a> (<a href="libxml2-tree.html#xmlOutputBufferPtr">xmlOutputBufferPtr</a> buf, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> const char * encoding);
int <a href="#xmlSaveFormatFile">xmlSaveFormatFile</a> (const char * filename, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> int format);
int <a href="#xmlSaveFormatFileEnc">xmlSaveFormatFileEnc</a> (const char * filename, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> const char * encoding, <br> int format);
int <a href="#xmlSaveFormatFileTo">xmlSaveFormatFileTo</a> (<a href="libxml2-tree.html#xmlOutputBufferPtr">xmlOutputBufferPtr</a> buf, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> const char * encoding, <br> int format);
<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> <a href="#xmlSearchNs">xmlSearchNs</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * nameSpace);
<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> <a href="#xmlSearchNsByHref">xmlSearchNsByHref</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * href);
void <a href="#xmlSetBufferAllocationScheme">xmlSetBufferAllocationScheme</a> (<a href="libxml2-tree.html#xmlBufferAllocationScheme">xmlBufferAllocationScheme</a> scheme);
void <a href="#xmlSetCompressMode">xmlSetCompressMode</a> (int mode);
void <a href="#xmlSetDocCompressMode">xmlSetDocCompressMode</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> int mode);
int <a href="#xmlSetListDoc">xmlSetListDoc</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> list, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc);
void <a href="#xmlSetNs">xmlSetNs</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns);
<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> <a href="#xmlSetNsProp">xmlSetNsProp</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value);
<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> <a href="#xmlSetProp">xmlSetProp</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value);
int <a href="#xmlSetTreeDoc">xmlSetTreeDoc</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> tree, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlSplitQName2">xmlSplitQName2</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** prefix);
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlSplitQName3">xmlSplitQName3</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> int * len);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlStringGetNodeList">xmlStringGetNodeList</a> (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlStringLenGetNodeList">xmlStringLenGetNodeList</a> (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> int len);
int <a href="#xmlTextConcat">xmlTextConcat</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content, <br> int len);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlTextMerge">xmlTextMerge</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> first, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> second);
<a href="libxml2-tree.html#xmlBufferAllocationScheme">xmlBufferAllocationScheme</a> <a href="#xmlThrDefBufferAllocScheme">xmlThrDefBufferAllocScheme</a> (<a href="libxml2-tree.html#xmlBufferAllocationScheme">xmlBufferAllocationScheme</a> v);
int <a href="#xmlThrDefDefaultBufferSize">xmlThrDefDefaultBufferSize</a> (int v);
<a href="libxml2-tree.html#xmlDeregisterNodeFunc">xmlDeregisterNodeFunc</a> <a href="#xmlThrDefDeregisterNodeDefault">xmlThrDefDeregisterNodeDefault</a> (<a href="libxml2-tree.html#xmlDeregisterNodeFunc">xmlDeregisterNodeFunc</a> func);
<a href="libxml2-tree.html#xmlRegisterNodeFunc">xmlRegisterNodeFunc</a> <a href="#xmlThrDefRegisterNodeDefault">xmlThrDefRegisterNodeDefault</a> (<a href="libxml2-tree.html#xmlRegisterNodeFunc">xmlRegisterNodeFunc</a> func);
void <a href="#xmlUnlinkNode">xmlUnlinkNode</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
int <a href="#xmlUnsetNsProp">xmlUnsetNsProp</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
int <a href="#xmlUnsetProp">xmlUnsetProp</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
int <a href="#xmlValidateNCName">xmlValidateNCName</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> int space);
int <a href="#xmlValidateNMToken">xmlValidateNMToken</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> int space);
int <a href="#xmlValidateName">xmlValidateName</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> int space);
int <a href="#xmlValidateQName">xmlValidateQName</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> int space);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="BASE_BUFFER_SIZE">Macro </a>BASE_BUFFER_SIZE</h3>
<pre class="programlisting">#define <a href="#BASE_BUFFER_SIZE">BASE_BUFFER_SIZE</a>;
</pre>
<p>default buffer size 4000.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="LIBXML2_NEW_BUFFER">Macro </a>LIBXML2_NEW_BUFFER</h3>
<pre class="programlisting">#define <a href="#LIBXML2_NEW_BUFFER">LIBXML2_NEW_BUFFER</a>;
</pre>
<p>Macro used to express that the API use the new buffers for <a href="libxml2-tree.html#xmlParserInputBuffer">xmlParserInputBuffer</a> and <a href="libxml2-tree.html#xmlOutputBuffer">xmlOutputBuffer</a>. The change was introduced in 2.9.0.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_GET_CONTENT">Macro </a>XML_GET_CONTENT</h3>
<pre class="programlisting">#define <a href="#XML_GET_CONTENT">XML_GET_CONTENT</a>;
</pre>
<p>Macro to extract the content pointer of a node.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_GET_LINE">Macro </a>XML_GET_LINE</h3>
<pre class="programlisting">#define <a href="#XML_GET_LINE">XML_GET_LINE</a>;
</pre>
<p>Macro to extract the line number of an element node.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_LOCAL_NAMESPACE">Macro </a>XML_LOCAL_NAMESPACE</h3>
<pre class="programlisting">#define <a href="#XML_LOCAL_NAMESPACE">XML_LOCAL_NAMESPACE</a>;
</pre>
<p>A namespace declaration node.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_XML_ID">Macro </a>XML_XML_ID</h3>
<pre class="programlisting">#define <a href="#XML_XML_ID">XML_XML_ID</a>;
</pre>
<p>This is the name for the special xml:id <a href="libxml2-SAX.html#attribute">attribute</a></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_XML_NAMESPACE">Macro </a>XML_XML_NAMESPACE</h3>
<pre class="programlisting">#define <a href="#XML_XML_NAMESPACE">XML_XML_NAMESPACE</a>;
</pre>
<p>This is the namespace for the special xml: prefix predefined in the XML Namespace specification.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlChildrenNode">Macro </a>xmlChildrenNode</h3>
<pre class="programlisting">#define <a href="#xmlChildrenNode">xmlChildrenNode</a>;
</pre>
<p>Macro for compatibility naming layer with libxml1. Maps to "children."</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlRootNode">Macro </a>xmlRootNode</h3>
<pre class="programlisting">#define <a href="#xmlRootNode">xmlRootNode</a>;
</pre>
<p>Macro for compatibility naming layer with libxml1. Maps to "children".</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAttr">Structure </a>xmlAttr</h3>
<pre class="programlisting">struct _xmlAttr {
void * _private : application data
<a href="libxml2-tree.html#xmlElementType">xmlElementType</a> type : XML_ATTRIBUTE_NODE, must be second !
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * 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
<a href="libxml2-tree.html#xmlNs">xmlNs</a> * ns : pointer to the associated namespace
<a href="libxml2-tree.html#xmlAttributeType">xmlAttributeType</a> atype : the <a href="libxml2-SAX.html#attribute">attribute</a> type if validating
void * psvi : for type/PSVI information
struct _xmlID * id : the ID struct
} xmlAttr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAttrPtr">Typedef </a>xmlAttrPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlAttr">xmlAttr</a> * xmlAttrPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAttribute">Structure </a>xmlAttribute</h3>
<pre class="programlisting">struct _xmlAttribute {
void * _private : application data
<a href="libxml2-tree.html#xmlElementType">xmlElementType</a> type : XML_ATTRIBUTE_DECL, must be second !
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * 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
<a href="libxml2-tree.html#xmlAttributeType">xmlAttributeType</a> atype : The <a href="libxml2-SAX.html#attribute">attribute</a> type
<a href="libxml2-tree.html#xmlAttributeDefault">xmlAttributeDefault</a> def : the default
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * defaultValue : or the default value
<a href="libxml2-tree.html#xmlEnumerationPtr">xmlEnumerationPtr</a> tree : or the enumeration tree if any
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix : the namespace prefix if any
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * elem : Element holding the <a href="libxml2-SAX.html#attribute">attribute</a>
} xmlAttribute;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAttributeDefault">Enum </a>xmlAttributeDefault</h3>
<pre class="programlisting">enum <a href="#xmlAttributeDefault">xmlAttributeDefault</a> {
<a name="XML_ATTRIBUTE_NONE">XML_ATTRIBUTE_NONE</a> = 1
<a name="XML_ATTRIBUTE_REQUIRED">XML_ATTRIBUTE_REQUIRED</a> = 2
<a name="XML_ATTRIBUTE_IMPLIED">XML_ATTRIBUTE_IMPLIED</a> = 3
<a name="XML_ATTRIBUTE_FIXED">XML_ATTRIBUTE_FIXED</a> = 4
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAttributePtr">Typedef </a>xmlAttributePtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlAttribute">xmlAttribute</a> * xmlAttributePtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAttributeType">Enum </a>xmlAttributeType</h3>
<pre class="programlisting">enum <a href="#xmlAttributeType">xmlAttributeType</a> {
<a name="XML_ATTRIBUTE_CDATA">XML_ATTRIBUTE_CDATA</a> = 1
<a name="XML_ATTRIBUTE_ID">XML_ATTRIBUTE_ID</a> = 2
<a name="XML_ATTRIBUTE_IDREF">XML_ATTRIBUTE_IDREF</a> = 3
<a name="XML_ATTRIBUTE_IDREFS">XML_ATTRIBUTE_IDREFS</a> = 4
<a name="XML_ATTRIBUTE_ENTITY">XML_ATTRIBUTE_ENTITY</a> = 5
<a name="XML_ATTRIBUTE_ENTITIES">XML_ATTRIBUTE_ENTITIES</a> = 6
<a name="XML_ATTRIBUTE_NMTOKEN">XML_ATTRIBUTE_NMTOKEN</a> = 7
<a name="XML_ATTRIBUTE_NMTOKENS">XML_ATTRIBUTE_NMTOKENS</a> = 8
<a name="XML_ATTRIBUTE_ENUMERATION">XML_ATTRIBUTE_ENUMERATION</a> = 9
<a name="XML_ATTRIBUTE_NOTATION">XML_ATTRIBUTE_NOTATION</a> = 10
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBuf">Structure </a>xmlBuf</h3>
<pre class="programlisting">struct _xmlBuf {
The content of this structure is not made public by the API.
} xmlBuf;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufPtr">Typedef </a>xmlBufPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlBuf">xmlBuf</a> * xmlBufPtr;
</pre>
<p>A pointer to a buffer structure, the actual structure internals are not public</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBuffer">Structure </a>xmlBuffer</h3>
<pre class="programlisting">struct _xmlBuffer {
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content : The buffer content UTF8
unsigned int use : The buffer size used
unsigned int size : The buffer size
<a href="libxml2-tree.html#xmlBufferAllocationScheme">xmlBufferAllocationScheme</a> alloc : The realloc method
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * contentIO : in IO mode we may have a different base
} xmlBuffer;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferAllocationScheme">Enum </a>xmlBufferAllocationScheme</h3>
<pre class="programlisting">enum <a href="#xmlBufferAllocationScheme">xmlBufferAllocationScheme</a> {
<a name="XML_BUFFER_ALLOC_DOUBLEIT">XML_BUFFER_ALLOC_DOUBLEIT</a> = 1 /* double each time one need to grow */
<a name="XML_BUFFER_ALLOC_EXACT">XML_BUFFER_ALLOC_EXACT</a> = 2 /* grow only to the minimal size */
<a name="XML_BUFFER_ALLOC_IMMUTABLE">XML_BUFFER_ALLOC_IMMUTABLE</a> = 3 /* immutable buffer, deprecated */
<a name="XML_BUFFER_ALLOC_IO">XML_BUFFER_ALLOC_IO</a> = 4 /* special allocation scheme used for I/O */
<a name="XML_BUFFER_ALLOC_HYBRID">XML_BUFFER_ALLOC_HYBRID</a> = 5 /* exact up to a threshold, and doubleit thereafter */
<a name="XML_BUFFER_ALLOC_BOUNDED">XML_BUFFER_ALLOC_BOUNDED</a> = 6 /* limit the upper size of the buffer */
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferPtr">Typedef </a>xmlBufferPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlBuffer">xmlBuffer</a> * xmlBufferPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDOMWrapCtxt">Structure </a>xmlDOMWrapCtxt</h3>
<pre class="programlisting">struct _xmlDOMWrapCtxt {
void * _private : * The type of this context, just in case we need specialized * context
int type : * Internal namespace map used for various operations. *
void * namespaceMap : * Use this one to acquire an <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> intended for node->ns. * (Note t
<a href="libxml2-tree.html#xmlDOMWrapAcquireNsFunction">xmlDOMWrapAcquireNsFunction</a> getNsForNodeFunc
} xmlDOMWrapCtxt;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDOMWrapCtxtPtr">Typedef </a>xmlDOMWrapCtxtPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlDOMWrapCtxt">xmlDOMWrapCtxt</a> * xmlDOMWrapCtxtPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDoc">Structure </a>xmlDoc</h3>
<pre class="programlisting">struct _xmlDoc {
void * _private : application data
<a href="libxml2-tree.html#xmlElementType">xmlElementType</a> 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) 1 if standalone="yes" 0 if sta
struct _xmlDtd * intSubset : the document internal subset
struct _xmlDtd * extSubset : the document external subset
struct _xmlNs * oldNs : Global namespace, the old way
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * version : the XML version string
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * encoding : actual encoding, if any
void * ids : Hash table for ID attributes if any
void * refs : Hash table for IDREFs attributes if any
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * URL : The URI for that document
int charset : unused
struct _xmlDict * dict : dict used to allocate names or NULL
void * psvi : for type/PSVI information
int parseFlags : set of <a href="libxml2-parser.html#xmlParserOption">xmlParserOption</a> used to parse the document
int properties : set of <a href="libxml2-tree.html#xmlDocProperties">xmlDocProperties</a> for this document set at the end of parsing
} xmlDoc;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDocProperties">Enum </a>xmlDocProperties</h3>
<pre class="programlisting">enum <a href="#xmlDocProperties">xmlDocProperties</a> {
<a name="XML_DOC_WELLFORMED">XML_DOC_WELLFORMED</a> = 1 /* document is XML well formed */
<a name="XML_DOC_NSVALID">XML_DOC_NSVALID</a> = 2 /* document is Namespace valid */
<a name="XML_DOC_OLD10">XML_DOC_OLD10</a> = 4 /* parsed with old XML-1.0 parser */
<a name="XML_DOC_DTDVALID">XML_DOC_DTDVALID</a> = 8 /* DTD validation was successful */
<a name="XML_DOC_XINCLUDE">XML_DOC_XINCLUDE</a> = 16 /* XInclude substitution was done */
<a name="XML_DOC_USERBUILT">XML_DOC_USERBUILT</a> = 32 /* Document was built using the API and not by parsing an instance */
<a name="XML_DOC_INTERNAL">XML_DOC_INTERNAL</a> = 64 /* built for internal processing */
<a name="XML_DOC_HTML">XML_DOC_HTML</a> = 128 /* parsed or built HTML document */
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDocPtr">Typedef </a>xmlDocPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * xmlDocPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDtd">Structure </a>xmlDtd</h3>
<pre class="programlisting">struct _xmlDtd {
void * _private : application data
<a href="libxml2-tree.html#xmlElementType">xmlElementType</a> type : XML_DTD_NODE, must be second !
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * 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 <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ExternalID : External identifier for PUBLIC DTD
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * SystemID : URI for a SYSTEM or PUBLIC DTD
void * pentities : Hash table for param entities if any
} xmlDtd;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDtdPtr">Typedef </a>xmlDtdPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlDtd">xmlDtd</a> * xmlDtdPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlElement">Structure </a>xmlElement</h3>
<pre class="programlisting">struct _xmlElement {
void * _private : application data
<a href="libxml2-tree.html#xmlElementType">xmlElementType</a> type : XML_ELEMENT_DECL, must be second !
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * 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
<a href="libxml2-tree.html#xmlElementTypeVal">xmlElementTypeVal</a> etype : The type
<a href="libxml2-tree.html#xmlElementContentPtr">xmlElementContentPtr</a> content : the allowed element content
<a href="libxml2-tree.html#xmlAttributePtr">xmlAttributePtr</a> attributes : List of the declared attributes
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix : the namespace prefix if any
<a href="libxml2-xmlregexp.html#xmlRegexpPtr">xmlRegexpPtr</a> contModel : the validating regexp
void * contModel
} xmlElement;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlElementContent">Structure </a>xmlElementContent</h3>
<pre class="programlisting">struct _xmlElementContent {
<a href="libxml2-tree.html#xmlElementContentType">xmlElementContentType</a> type : PCDATA, ELEMENT, SEQ or OR
<a href="libxml2-tree.html#xmlElementContentOccur">xmlElementContentOccur</a> ocur : ONCE, OPT, MULT or PLUS
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name : Element name
struct _xmlElementContent * c1 : first child
struct _xmlElementContent * c2 : second child
struct _xmlElementContent * parent : parent
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix : Namespace prefix
} xmlElementContent;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlElementContentOccur">Enum </a>xmlElementContentOccur</h3>
<pre class="programlisting">enum <a href="#xmlElementContentOccur">xmlElementContentOccur</a> {
<a name="XML_ELEMENT_CONTENT_ONCE">XML_ELEMENT_CONTENT_ONCE</a> = 1
<a name="XML_ELEMENT_CONTENT_OPT">XML_ELEMENT_CONTENT_OPT</a> = 2
<a name="XML_ELEMENT_CONTENT_MULT">XML_ELEMENT_CONTENT_MULT</a> = 3
<a name="XML_ELEMENT_CONTENT_PLUS">XML_ELEMENT_CONTENT_PLUS</a> = 4
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlElementContentPtr">Typedef </a>xmlElementContentPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlElementContent">xmlElementContent</a> * xmlElementContentPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlElementContentType">Enum </a>xmlElementContentType</h3>
<pre class="programlisting">enum <a href="#xmlElementContentType">xmlElementContentType</a> {
<a name="XML_ELEMENT_CONTENT_PCDATA">XML_ELEMENT_CONTENT_PCDATA</a> = 1
<a name="XML_ELEMENT_CONTENT_ELEMENT">XML_ELEMENT_CONTENT_ELEMENT</a> = 2
<a name="XML_ELEMENT_CONTENT_SEQ">XML_ELEMENT_CONTENT_SEQ</a> = 3
<a name="XML_ELEMENT_CONTENT_OR">XML_ELEMENT_CONTENT_OR</a> = 4
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlElementPtr">Typedef </a>xmlElementPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlElement">xmlElement</a> * xmlElementPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlElementType">Enum </a>xmlElementType</h3>
<pre class="programlisting">enum <a href="#xmlElementType">xmlElementType</a> {
<a name="XML_ELEMENT_NODE">XML_ELEMENT_NODE</a> = 1
<a name="XML_ATTRIBUTE_NODE">XML_ATTRIBUTE_NODE</a> = 2
<a name="XML_TEXT_NODE">XML_TEXT_NODE</a> = 3
<a name="XML_CDATA_SECTION_NODE">XML_CDATA_SECTION_NODE</a> = 4
<a name="XML_ENTITY_REF_NODE">XML_ENTITY_REF_NODE</a> = 5
<a name="XML_ENTITY_NODE">XML_ENTITY_NODE</a> = 6 /* unused */
<a name="XML_PI_NODE">XML_PI_NODE</a> = 7
<a name="XML_COMMENT_NODE">XML_COMMENT_NODE</a> = 8
<a name="XML_DOCUMENT_NODE">XML_DOCUMENT_NODE</a> = 9
<a name="XML_DOCUMENT_TYPE_NODE">XML_DOCUMENT_TYPE_NODE</a> = 10 /* unused */
<a name="XML_DOCUMENT_FRAG_NODE">XML_DOCUMENT_FRAG_NODE</a> = 11
<a name="XML_NOTATION_NODE">XML_NOTATION_NODE</a> = 12 /* unused */
<a name="XML_HTML_DOCUMENT_NODE">XML_HTML_DOCUMENT_NODE</a> = 13
<a name="XML_DTD_NODE">XML_DTD_NODE</a> = 14
<a name="XML_ELEMENT_DECL">XML_ELEMENT_DECL</a> = 15
<a name="XML_ATTRIBUTE_DECL">XML_ATTRIBUTE_DECL</a> = 16
<a name="XML_ENTITY_DECL">XML_ENTITY_DECL</a> = 17
<a name="XML_NAMESPACE_DECL">XML_NAMESPACE_DECL</a> = 18
<a name="XML_XINCLUDE_START">XML_XINCLUDE_START</a> = 19
<a name="XML_XINCLUDE_END">XML_XINCLUDE_END</a> = 20 /* XML_DOCB_DOCUMENT_NODE= 21 removed */
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlElementTypeVal">Enum </a>xmlElementTypeVal</h3>
<pre class="programlisting">enum <a href="#xmlElementTypeVal">xmlElementTypeVal</a> {
<a name="XML_ELEMENT_TYPE_UNDEFINED">XML_ELEMENT_TYPE_UNDEFINED</a> = 0
<a name="XML_ELEMENT_TYPE_EMPTY">XML_ELEMENT_TYPE_EMPTY</a> = 1
<a name="XML_ELEMENT_TYPE_ANY">XML_ELEMENT_TYPE_ANY</a> = 2
<a name="XML_ELEMENT_TYPE_MIXED">XML_ELEMENT_TYPE_MIXED</a> = 3
<a name="XML_ELEMENT_TYPE_ELEMENT">XML_ELEMENT_TYPE_ELEMENT</a> = 4
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlEntity">Structure </a>xmlEntity</h3>
<pre class="programlisting">struct _xmlEntity {
void * _private : application data
<a href="libxml2-tree.html#xmlElementType">xmlElementType</a> type : XML_ENTITY_DECL, must be second !
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name : Entity name
struct _xmlNode * children : First child link
struct _xmlNode * last : Last child link
struct _xmlDtd * parent : -> DTD
struct _xmlNode * next : next sibling link
struct _xmlNode * prev : previous sibling link
struct _xmlDoc * doc : the containing document
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * orig : content without ref substitution
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content : content or ndata if unparsed
int length : the content length
<a href="libxml2-entities.html#xmlEntityType">xmlEntityType</a> etype : The entity type
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ExternalID : External identifier for PUBLIC
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * SystemID : URI for a SYSTEM or PUBLIC Entity
struct _xmlEntity * nexte : unused
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * URI : the full URI as computed
int owner : unused
int flags : various flags
unsigned long expandedSize : expanded size
} xmlEntity;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlEntityPtr">Typedef </a>xmlEntityPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlEntity">xmlEntity</a> * xmlEntityPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlEnumeration">Structure </a>xmlEnumeration</h3>
<pre class="programlisting">struct _xmlEnumeration {
struct _xmlEnumeration * next : next one
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name : Enumeration name
} xmlEnumeration;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlEnumerationPtr">Typedef </a>xmlEnumerationPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlEnumeration">xmlEnumeration</a> * xmlEnumerationPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlID">Structure </a>xmlID</h3>
<pre class="programlisting">struct _xmlID {
struct _xmlID * next : next ID
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value : The ID name
<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> attr : The <a href="libxml2-SAX.html#attribute">attribute</a> holding it
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name : The <a href="libxml2-SAX.html#attribute">attribute</a> if attr is not available
int lineno : The line number if attr is not available
struct _xmlDoc * doc : The document holding the ID
} xmlID;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlIDPtr">Typedef </a>xmlIDPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlID">xmlID</a> * xmlIDPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNode">Structure </a>xmlNode</h3>
<pre class="programlisting">struct _xmlNode {
void * _private : application data
<a href="libxml2-tree.html#xmlElementType">xmlElementType</a> type : type number, must be second !
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * 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
<a href="libxml2-tree.html#xmlNs">xmlNs</a> * ns : pointer to the associated namespace
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content : the content
struct _xmlAttr * properties : properties list
<a href="libxml2-tree.html#xmlNs">xmlNs</a> * nsDef : namespace definitions on this node
void * psvi : for type/PSVI information
unsigned short line : line number
unsigned short extra : extra data for XPath/XSLT
} xmlNode;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodePtr">Typedef </a>xmlNodePtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNode">xmlNode</a> * xmlNodePtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNotation">Structure </a>xmlNotation</h3>
<pre class="programlisting">struct _xmlNotation {
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name : Notation name
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * PublicID : Public identifier, if any
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * SystemID : System identifier, if any
} xmlNotation;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNotationPtr">Typedef </a>xmlNotationPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNotation">xmlNotation</a> * xmlNotationPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNs">Structure </a>xmlNs</h3>
<pre class="programlisting">struct _xmlNs {
struct _xmlNs * next : next Ns link for this node
<a href="libxml2-tree.html#xmlNsType">xmlNsType</a> type : global or local
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * href : URL for the namespace
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix : prefix for the namespace
void * _private : application data
struct _xmlDoc * context : normally an <a href="libxml2-tree.html#xmlDoc">xmlDoc</a>
} xmlNs;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNsPtr">Typedef </a>xmlNsPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNs">xmlNs</a> * xmlNsPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNsType">Typedef </a>xmlNsType</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlElementType">xmlElementType</a> xmlNsType;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlOutputBuffer">Structure </a>xmlOutputBuffer</h3>
<pre class="programlisting">struct _xmlOutputBuffer {
void * context
<a href="libxml2-xmlIO.html#xmlOutputWriteCallback">xmlOutputWriteCallback</a> writecallback
<a href="libxml2-xmlIO.html#xmlOutputCloseCallback">xmlOutputCloseCallback</a> closecallback
<a href="libxml2-encoding.html#xmlCharEncodingHandlerPtr">xmlCharEncodingHandlerPtr</a> encoder : I18N conversions to UTF-8
<a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> buffer : Local buffer encoded in UTF-8 or ISOLatin
<a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> conv : if encoder != NULL buffer for output
int written : total number of byte written
int error
} xmlOutputBuffer;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlOutputBufferPtr">Typedef </a>xmlOutputBufferPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlOutputBuffer">xmlOutputBuffer</a> * xmlOutputBufferPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParserCtxt">Structure </a>xmlParserCtxt</h3>
<pre class="programlisting">struct _xmlParserCtxt {
struct _xmlSAXHandler * sax : The SAX handler
void * userData : For SAX interface only, used by DOM build
<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> myDoc : the document being built
int wellFormed : is the document well formed
int replaceEntities : shall we replace entities ?
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * version : the XML version string
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * encoding : the declared encoding, if any
int standalone : standalone document
int html : an HTML(1) document * 3 is HTML after <head> * 10 is HTML after <body
<a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> input : Current input stream
int inputNr : Number of current input streams
int inputMax : Max number of input streams
<a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> * inputTab : stack of inputs Node analysis stack only used for DOM building
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node : Current parsed Node
int nodeNr : Depth of the parsing stack
int nodeMax : Max depth of the parsing stack
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> * nodeTab : array of nodes
int record_info : Whether node info should be kept
<a href="libxml2-parser.html#xmlParserNodeInfoSeq">xmlParserNodeInfoSeq</a> node_seq : info about each node parsed
int errNo : error code
int hasExternalSubset : <a href="libxml2-SAX.html#reference">reference</a> and external subset
int hasPErefs : the internal subset has PE refs
int external : unused
int valid : is the document valid
int validate : shall we try to validate ?
<a href="libxml2-valid.html#xmlValidCtxt">xmlValidCtxt</a> vctxt : The validity context
<a href="libxml2-parser.html#xmlParserInputState">xmlParserInputState</a> instate : push parser state
int token : unused
char * directory : unused Node name stack
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name : Current parsed Node
int nameNr : Depth of the parsing stack
int nameMax : Max depth of the parsing stack
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * * nameTab : array of nodes
long nbChars : unused
long checkIndex : used by progressive parsing lookup
int keepBlanks : ugly but ...
int disableSAX : SAX callbacks are disabled
int inSubset : Parsing is in int 1/ext 2 subset
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * intSubName : name of subset
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * extSubURI : URI of external subset
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * extSubSystem : SYSTEM ID of external subset xml:space values
int * space : Should the parser preserve spaces
int spaceNr : Depth of the parsing stack
int spaceMax : Max depth of the parsing stack
int * spaceTab : array of space infos
int depth : to prevent entity substitution loops
<a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> entity : unused
int charset : unused
int nodelen : Those two fields are there to
int nodemem : Speed up large node parsing
int pedantic : signal pedantic warnings
void * _private : For user data, libxml won't touch it
int loadsubset : should the external subset be loaded
int linenumbers : set line number in element content
void * catalogs : document's own catalog
int recovery : run in recovery mode
int progressive : unused
<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict : dictionary for the parser
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * * atts : array for the attributes callbacks
int maxatts : the size of the array
int docdict : * pre-interned strings *
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str_xml
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str_xmlns
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str_xml_ns : * Everything below is used only by the new SAX mode *
int sax2 : operating in the new SAX mode
int nsNr : the number of inherited namespaces
int nsMax : the size of the arrays
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * * nsTab : the array of prefix/namespace name
unsigned * attallocs : which <a href="libxml2-SAX.html#attribute">attribute</a> were allocated
<a href="libxml2-parser.html#xmlStartTag">xmlStartTag</a> * pushTab : array of data for push
<a href="libxml2-hash.html#xmlHashTablePtr">xmlHashTablePtr</a> attsDefault : defaulted attributes if any
<a href="libxml2-hash.html#xmlHashTablePtr">xmlHashTablePtr</a> attsSpecial : non-CDATA attributes if any
int nsWellFormed : is the document XML Namespace okay
int options : * Those fields are needed only for streaming parsing so far *
int dictNames : Use dictionary names for the tree
int freeElemsNr : number of freed element nodes
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> freeElems : List of freed element nodes
int freeAttrsNr : number of freed attributes nodes
<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> freeAttrs : * the complete error information for the last error. *
<a href="libxml2-xmlerror.html#xmlError">xmlError</a> lastError
<a href="libxml2-parser.html#xmlParserMode">xmlParserMode</a> parseMode : the parser mode
unsigned long nbentities : unused
unsigned long sizeentities : size of external entities for use by HTML non-recursive parser
<a href="libxml2-parser.html#xmlParserNodeInfo">xmlParserNodeInfo</a> * nodeInfo : Current NodeInfo
int nodeInfoNr : Depth of the parsing stack
int nodeInfoMax : Max depth of the parsing stack
<a href="libxml2-parser.html#xmlParserNodeInfo">xmlParserNodeInfo</a> * nodeInfoTab : array of nodeInfos
int input_id : we need to label inputs
unsigned long sizeentcopy : volume of entity copy
int endCheckState : quote state for push parser
unsigned short nbErrors : number of errors
unsigned short nbWarnings : number of warnings
unsigned maxAmpl : maximum amplification factor
<a href="libxml2-parser.html#xmlParserNsData">xmlParserNsData</a> * nsdb : namespace database
unsigned attrHashMax : allocated size
<a href="libxml2-parser.html#xmlAttrHashBucket">xmlAttrHashBucket</a> * attrHash : atttribute hash table
<a href="libxml2-xmlerror.html#xmlStructuredErrorFunc">xmlStructuredErrorFunc</a> errorHandler
void * errorCtxt
} xmlParserCtxt;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParserCtxtPtr">Typedef </a>xmlParserCtxtPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlParserCtxt">xmlParserCtxt</a> * xmlParserCtxtPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParserInput">Structure </a>xmlParserInput</h3>
<pre class="programlisting">struct _xmlParserInput {
<a href="libxml2-tree.html#xmlParserInputBufferPtr">xmlParserInputBufferPtr</a> buf : UTF-8 encoded buffer
const char * filename : The file analyzed, if any
const char * directory : unused
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * base : Base of the array to parse
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * cur : Current char being parsed
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * end : end of the array to parse
int length : unused
int line : Current line
int col : Current column
unsigned long consumed : How many xmlChars already consumed
<a href="libxml2-parser.html#xmlParserInputDeallocate">xmlParserInputDeallocate</a> free : function to deallocate the base
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * encoding : unused
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * version : the version string for entity
int flags : Flags
int id : an unique identifier for the entity
unsigned long parentConsumed : unused
<a href="libxml2-tree.html#xmlEntityPtr">xmlEntityPtr</a> entity : entity, if any
} xmlParserInput;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParserInputBuffer">Structure </a>xmlParserInputBuffer</h3>
<pre class="programlisting">struct _xmlParserInputBuffer {
void * context
<a href="libxml2-xmlIO.html#xmlInputReadCallback">xmlInputReadCallback</a> readcallback
<a href="libxml2-xmlIO.html#xmlInputCloseCallback">xmlInputCloseCallback</a> closecallback
<a href="libxml2-encoding.html#xmlCharEncodingHandlerPtr">xmlCharEncodingHandlerPtr</a> encoder : I18N conversions to UTF-8
<a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> buffer : Local buffer encoded in UTF-8
<a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> raw : if encoder != NULL buffer for raw input
int compressed : -1=unknown, 0=not compressed, 1=compressed
int error
unsigned long rawconsumed : amount consumed from raw
} xmlParserInputBuffer;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParserInputBufferPtr">Typedef </a>xmlParserInputBufferPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlParserInputBuffer">xmlParserInputBuffer</a> * xmlParserInputBufferPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParserInputPtr">Typedef </a>xmlParserInputPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlParserInput">xmlParserInput</a> * xmlParserInputPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlRef">Structure </a>xmlRef</h3>
<pre class="programlisting">struct _xmlRef {
struct _xmlRef * next : next Ref
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value : The Ref name
<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> attr : The <a href="libxml2-SAX.html#attribute">attribute</a> holding it
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name : The <a href="libxml2-SAX.html#attribute">attribute</a> if attr is not available
int lineno : The line number if attr is not available
} xmlRef;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlRefPtr">Typedef </a>xmlRefPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlRef">xmlRef</a> * xmlRefPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSAXHandler">Structure </a>xmlSAXHandler</h3>
<pre class="programlisting">struct _xmlSAXHandler {
<a href="libxml2-parser.html#internalSubsetSAXFunc">internalSubsetSAXFunc</a> internalSubset
<a href="libxml2-parser.html#isStandaloneSAXFunc">isStandaloneSAXFunc</a> isStandalone
<a href="libxml2-parser.html#hasInternalSubsetSAXFunc">hasInternalSubsetSAXFunc</a> hasInternalSubset
<a href="libxml2-parser.html#hasExternalSubsetSAXFunc">hasExternalSubsetSAXFunc</a> hasExternalSubset
<a href="libxml2-parser.html#resolveEntitySAXFunc">resolveEntitySAXFunc</a> resolveEntity
<a href="libxml2-parser.html#getEntitySAXFunc">getEntitySAXFunc</a> getEntity
<a href="libxml2-parser.html#entityDeclSAXFunc">entityDeclSAXFunc</a> entityDecl
<a href="libxml2-parser.html#notationDeclSAXFunc">notationDeclSAXFunc</a> notationDecl
<a href="libxml2-parser.html#attributeDeclSAXFunc">attributeDeclSAXFunc</a> attributeDecl
<a href="libxml2-parser.html#elementDeclSAXFunc">elementDeclSAXFunc</a> elementDecl
<a href="libxml2-parser.html#unparsedEntityDeclSAXFunc">unparsedEntityDeclSAXFunc</a> unparsedEntityDecl
<a href="libxml2-parser.html#setDocumentLocatorSAXFunc">setDocumentLocatorSAXFunc</a> setDocumentLocator
<a href="libxml2-parser.html#startDocumentSAXFunc">startDocumentSAXFunc</a> startDocument
<a href="libxml2-parser.html#endDocumentSAXFunc">endDocumentSAXFunc</a> endDocument : * `startElement` and `endElement` are only used by the legacy SAX1 * i
<a href="libxml2-parser.html#startElementSAXFunc">startElementSAXFunc</a> startElement
<a href="libxml2-parser.html#endElementSAXFunc">endElementSAXFunc</a> endElement
<a href="libxml2-parser.html#referenceSAXFunc">referenceSAXFunc</a> reference
<a href="libxml2-parser.html#charactersSAXFunc">charactersSAXFunc</a> characters
<a href="libxml2-parser.html#ignorableWhitespaceSAXFunc">ignorableWhitespaceSAXFunc</a> ignorableWhitespace
<a href="libxml2-parser.html#processingInstructionSAXFunc">processingInstructionSAXFunc</a> processingInstruction
<a href="libxml2-parser.html#commentSAXFunc">commentSAXFunc</a> comment
<a href="libxml2-parser.html#warningSAXFunc">warningSAXFunc</a> warning
<a href="libxml2-parser.html#errorSAXFunc">errorSAXFunc</a> error
<a href="libxml2-parser.html#fatalErrorSAXFunc">fatalErrorSAXFunc</a> fatalError : unused error() get all the errors
<a href="libxml2-parser.html#getParameterEntitySAXFunc">getParameterEntitySAXFunc</a> getParameterEntity
<a href="libxml2-parser.html#cdataBlockSAXFunc">cdataBlockSAXFunc</a> cdataBlock
<a href="libxml2-parser.html#externalSubsetSAXFunc">externalSubsetSAXFunc</a> externalSubset : * `initialized` should always be set to <a href="libxml2-parser.html#XML_SAX2_MAGIC">XML_SAX2_MAGIC</a> to enable the *
unsigned int initialized : * The following members are only used by the SAX2 interface. *
void * _private
<a href="libxml2-parser.html#startElementNsSAX2Func">startElementNsSAX2Func</a> startElementNs
<a href="libxml2-parser.html#endElementNsSAX2Func">endElementNsSAX2Func</a> endElementNs
<a href="libxml2-xmlerror.html#xmlStructuredErrorFunc">xmlStructuredErrorFunc</a> serror
} xmlSAXHandler;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSAXHandlerPtr">Typedef </a>xmlSAXHandlerPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlSAXHandler">xmlSAXHandler</a> * xmlSAXHandlerPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSAXLocator">Structure </a>xmlSAXLocator</h3>
<pre class="programlisting">struct _xmlSAXLocator {
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> *(*getPublicId) getPublicId
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> *(*getSystemId) getSystemId
int(*getLineNumber) getLineNumber
int(*getColumnNumber) getColumnNumber
} xmlSAXLocator;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSAXLocatorPtr">Typedef </a>xmlSAXLocatorPtr</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlSAXLocator">xmlSAXLocator</a> * xmlSAXLocatorPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDOMWrapAcquireNsFunction"></a>Function type xmlDOMWrapAcquireNsFunction</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> xmlDOMWrapAcquireNsFunction (<a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * nsName, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * nsPrefix)<br>
</pre>
<p>A function called to acquire namespaces (xmlNs) from the wrapper.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>a DOM wrapper context</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the context node (element or attribute)</td>
</tr>
<tr>
<td><span class="term"><i><tt>nsName</tt></i>:</span></td>
<td>the requested namespace name</td>
</tr>
<tr>
<td><span class="term"><i><tt>nsPrefix</tt></i>:</span></td>
<td>the requested namespace prefix</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>an <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> or NULL in case of an error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDeregisterNodeFunc"></a>Function type xmlDeregisterNodeFunc</h3>
<pre class="programlisting">void xmlDeregisterNodeFunc (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node)<br>
</pre>
<p>Signature for the deregistration callback of a discarded node</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the current node</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlRegisterNodeFunc"></a>Function type xmlRegisterNodeFunc</h3>
<pre class="programlisting">void xmlRegisterNodeFunc (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node)<br>
</pre>
<p>Signature for the registration callback of a created node</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the current node</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAddChild"></a>xmlAddChild ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlAddChild (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Unlink @cur and append it to the children of @parent. If @cur is a text node, it may be merged with an adjacent text node and freed. In this case the text node containing the merged content is returned. If @cur is an <a href="libxml2-SAX.html#attribute">attribute</a> node, it is appended to the attributes of @parent. If the <a href="libxml2-SAX.html#attribute">attribute</a> list contains an <a href="libxml2-SAX.html#attribute">attribute</a> with a name matching @elem, the old <a href="libxml2-SAX.html#attribute">attribute</a> is destroyed. General notes: Move operations like <a href="libxml2-tree.html#xmlAddChild">xmlAddChild</a> can cause element or <a href="libxml2-SAX.html#attribute">attribute</a> nodes to <a href="libxml2-SAX.html#reference">reference</a> namespaces that aren't declared in one of their ancestors. This can lead to use-after-free errors if the elements containing the declarations are freed later, especially when moving nodes from one document to another. You should consider calling <a href="libxml2-tree.html#xmlReconciliateNs">xmlReconciliateNs</a> after a move operation to normalize namespaces. Another option is to call <a href="libxml2-tree.html#xmlDOMWrapAdoptNode">xmlDOMWrapAdoptNode</a> with the target parent before moving a node. For the most part, move operations don't check whether the resulting tree structure is valid. Users must make sure that parent nodes only receive children of valid types. Inserted child nodes must never be an ancestor of the parent node to avoid cycles in the tree structure. In general, only document, document fragments, elements and attributes should be used as parent nodes. When moving a node between documents and a memory allocation fails, the node's content will be corrupted and it will be unlinked. In this case, the node must be freed manually. Moving DTDs between documents isn't supported.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>parent</tt></i>:</span></td>
<td>the parent node</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the child node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>@elem or a sibling if @elem was merged. Returns NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAddChildList"></a>xmlAddChildList ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlAddChildList (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Append a node list to another node. See <a href="libxml2-tree.html#xmlAddChild">xmlAddChild</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>parent</tt></i>:</span></td>
<td>the parent node</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the first node in the list</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the last child or NULL in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAddNextSibling"></a>xmlAddNextSibling ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlAddNextSibling (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> prev, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Unlinks @cur and inserts it as next sibling after @prev. Unlike <a href="libxml2-tree.html#xmlAddChild">xmlAddChild</a> this function does not merge text nodes. If @cur is an <a href="libxml2-SAX.html#attribute">attribute</a> node, it is inserted after <a href="libxml2-SAX.html#attribute">attribute</a> @prev. If the <a href="libxml2-SAX.html#attribute">attribute</a> list contains an <a href="libxml2-SAX.html#attribute">attribute</a> with a name matching @cur, the old <a href="libxml2-SAX.html#attribute">attribute</a> is destroyed. See the notes in <a href="libxml2-tree.html#xmlAddChild">xmlAddChild</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>prev</tt></i>:</span></td>
<td>the target node</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the new node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>@cur or a sibling if @cur was merged. Returns NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAddPrevSibling"></a>xmlAddPrevSibling ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlAddPrevSibling (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> next, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Unlinks @cur and inserts it as previous sibling before @next. Unlike <a href="libxml2-tree.html#xmlAddChild">xmlAddChild</a> this function does not merge text nodes. If @cur is an <a href="libxml2-SAX.html#attribute">attribute</a> node, it is inserted before <a href="libxml2-SAX.html#attribute">attribute</a> @next. If the <a href="libxml2-SAX.html#attribute">attribute</a> list contains an <a href="libxml2-SAX.html#attribute">attribute</a> with a name matching @cur, the old <a href="libxml2-SAX.html#attribute">attribute</a> is destroyed. See the notes in <a href="libxml2-tree.html#xmlAddChild">xmlAddChild</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>next</tt></i>:</span></td>
<td>the target node</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the new node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>@cur or a sibling if @cur was merged. Returns NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAddSibling"></a>xmlAddSibling ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlAddSibling (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Unlinks @cur and inserts it as last sibling of @node. If @cur is a text node, it may be merged with an adjacent text node and freed. In this case the text node containing the merged content is returned. If @cur is an <a href="libxml2-SAX.html#attribute">attribute</a> node, it is appended to the <a href="libxml2-SAX.html#attribute">attribute</a> list containing @node. If the <a href="libxml2-SAX.html#attribute">attribute</a> list contains an <a href="libxml2-SAX.html#attribute">attribute</a> with a name matching @cur, the old <a href="libxml2-SAX.html#attribute">attribute</a> is destroyed. See the notes in <a href="libxml2-tree.html#xmlAddChild">xmlAddChild</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the target node</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the new node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>@cur or a sibling if @cur was merged. Returns NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAttrSerializeTxtContent"></a>xmlAttrSerializeTxtContent ()</h3>
<pre class="programlisting">void xmlAttrSerializeTxtContent (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> attr, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * string)<br>
</pre>
<p>Serialize text <a href="libxml2-SAX.html#attribute">attribute</a> values to an xml simple buffer</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the XML buffer output</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>attr</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> node</td>
</tr>
<tr>
<td><span class="term"><i><tt>string</tt></i>:</span></td>
<td>the text content</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufContent"></a>xmlBufContent ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlBufContent (const <a href="libxml2-tree.html#xmlBuf">xmlBuf</a> * buf)<br>
</pre>
<p>Function to extract the content of a buffer</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the internal content</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufEnd"></a>xmlBufEnd ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlBufEnd (<a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> buf)<br>
</pre>
<p>Function to extract the end of the content of a buffer</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the end of the internal content or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufGetNodeContent"></a>xmlBufGetNodeContent ()</h3>
<pre class="programlisting">int xmlBufGetNodeContent (<a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> buf, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur)<br>
</pre>
<p>Read the value of a node @cur, 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 substituted. Fills up the buffer @buf with this value</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>a buffer <a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being read</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success and -1 in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufNodeDump"></a>xmlBufNodeDump ()</h3>
<pre class="programlisting">size_t xmlBufNodeDump (<a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> buf, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> int level, <br> int format)<br>
</pre>
<p>Dump an XML node, recursive behaviour,children are printed too. Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was called</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the XML buffer output</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node</td>
</tr>
<tr>
<td><span class="term"><i><tt>level</tt></i>:</span></td>
<td>the imbrication level for indenting</td>
</tr>
<tr>
<td><span class="term"><i><tt>format</tt></i>:</span></td>
<td>is formatting allowed</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of bytes written to the buffer, in case of error 0 is returned or @buf stores the error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufShrink"></a>xmlBufShrink ()</h3>
<pre class="programlisting">size_t xmlBufShrink (<a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> buf, <br> size_t len)<br>
</pre>
<p>Remove the beginning of an XML buffer. NOTE that this routine behaviour differs from xmlBufferShrink() as it will return 0 on error instead of -1 due to size_t being used as the return type.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer to dump</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>the number of <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> to remove</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of byte removed or 0 in case of failure</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufUse"></a>xmlBufUse ()</h3>
<pre class="programlisting">size_t xmlBufUse (const <a href="libxml2-tree.html#xmlBufPtr">xmlBufPtr</a> buf)<br>
</pre>
<p>Function to get the length of a buffer</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the length of data in the internal content</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferAdd"></a>xmlBufferAdd ()</h3>
<pre class="programlisting">int xmlBufferAdd (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str, <br> int len)<br>
</pre>
<p>Add a string range to an XML buffer. if len == -1, the length of str is recomputed.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer to dump</td>
</tr>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>the #xmlChar string</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>the number of #xmlChar to add</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 successful, a positive error code number otherwise and -1 in case of internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferAddHead"></a>xmlBufferAddHead ()</h3>
<pre class="programlisting">int xmlBufferAddHead (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str, <br> int len)<br>
</pre>
<p>Add a string range to the beginning of an XML buffer. if len == -1, the length of @str is recomputed.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>the #xmlChar string</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>the number of #xmlChar to add</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 successful, a positive error code number otherwise and -1 in case of internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferCCat"></a>xmlBufferCCat ()</h3>
<pre class="programlisting">int xmlBufferCCat (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const char * str)<br>
</pre>
<p>Append a zero terminated C string to an XML buffer.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer to dump</td>
</tr>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>the C char string</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 successful, a positive error code number otherwise and -1 in case of internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferCat"></a>xmlBufferCat ()</h3>
<pre class="programlisting">int xmlBufferCat (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str)<br>
</pre>
<p>Append a zero terminated string to an XML buffer.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer to add to</td>
</tr>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>the #xmlChar string</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 successful, a positive error code number otherwise and -1 in case of internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferContent"></a>xmlBufferContent ()</h3>
<pre class="programlisting">const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlBufferContent (const <a href="libxml2-tree.html#xmlBuffer">xmlBuffer</a> * buf)<br>
</pre>
<p>Function to extract the content of a buffer</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the internal content</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferCreate"></a>xmlBufferCreate ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> xmlBufferCreate (void)<br>
</pre>
<p>routine to create an XML buffer.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new structure.</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferCreateSize"></a>xmlBufferCreateSize ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> xmlBufferCreateSize (size_t size)<br>
</pre>
<p>routine to create an XML buffer.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>size</tt></i>:</span></td>
<td>initial size of buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new structure.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferCreateStatic"></a>xmlBufferCreateStatic ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> xmlBufferCreateStatic (void * mem, <br> size_t size)<br>
</pre>
<p></p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>mem</tt></i>:</span></td>
<td>the memory area</td>
</tr>
<tr>
<td><span class="term"><i><tt>size</tt></i>:</span></td>
<td>the size in byte</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>an XML buffer initialized with bytes.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferDetach"></a>xmlBufferDetach ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlBufferDetach (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf)<br>
</pre>
<p>Remove the string contained in a buffer and gie it back to the caller. The buffer is reset to an empty content. This doesn't work with immutable buffers as they can't be reset.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the previous string contained by the buffer.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferDump"></a>xmlBufferDump ()</h3>
<pre class="programlisting">int xmlBufferDump (FILE * file, <br> <a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf)<br>
</pre>
<p>Dumps an XML buffer to a FILE *.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>file</tt></i>:</span></td>
<td>the file output</td>
</tr>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer to dump</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of #xmlChar written</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferEmpty"></a>xmlBufferEmpty ()</h3>
<pre class="programlisting">void xmlBufferEmpty (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf)<br>
</pre>
<p>empty a buffer.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferFree"></a>xmlBufferFree ()</h3>
<pre class="programlisting">void xmlBufferFree (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf)<br>
</pre>
<p>Frees an XML buffer. It frees both the content and the structure which encapsulate it.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer to free</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferGrow"></a>xmlBufferGrow ()</h3>
<pre class="programlisting">int xmlBufferGrow (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> unsigned int len)<br>
</pre>
<p>Grow the available space of an XML buffer.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>the minimum free size to allocate</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new available space or -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferLength"></a>xmlBufferLength ()</h3>
<pre class="programlisting">int xmlBufferLength (const <a href="libxml2-tree.html#xmlBuffer">xmlBuffer</a> * buf)<br>
</pre>
<p>Function to get the length of a buffer</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the length of data in the internal content</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferResize"></a>xmlBufferResize ()</h3>
<pre class="programlisting">int xmlBufferResize (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> unsigned int size)<br>
</pre>
<p>Resize a buffer to accommodate minimum size of @size.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer to resize</td>
</tr>
<tr>
<td><span class="term"><i><tt>size</tt></i>:</span></td>
<td>the desired size</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of problems, 1 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferSetAllocationScheme"></a>xmlBufferSetAllocationScheme ()</h3>
<pre class="programlisting">void xmlBufferSetAllocationScheme (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> <a href="libxml2-tree.html#xmlBufferAllocationScheme">xmlBufferAllocationScheme</a> scheme)<br>
</pre>
<p>Sets the allocation scheme for this buffer</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer to tune</td>
</tr>
<tr>
<td><span class="term"><i><tt>scheme</tt></i>:</span></td>
<td>allocation scheme to use</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferShrink"></a>xmlBufferShrink ()</h3>
<pre class="programlisting">int xmlBufferShrink (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> unsigned int len)<br>
</pre>
<p>Remove the beginning of an XML buffer.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the buffer to dump</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>the number of <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> to remove</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of #xmlChar removed, or -1 in case of failure.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferWriteCHAR"></a>xmlBufferWriteCHAR ()</h3>
<pre class="programlisting">void xmlBufferWriteCHAR (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * string)<br>
</pre>
<p>routine which manages and grows an output buffer. This one adds xmlChars at the end of the buffer.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the XML buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>string</tt></i>:</span></td>
<td>the string to add</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferWriteChar"></a>xmlBufferWriteChar ()</h3>
<pre class="programlisting">void xmlBufferWriteChar (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const char * string)<br>
</pre>
<p>routine which manage and grows an output buffer. This one add C chars at the end of the array.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the XML buffer output</td>
</tr>
<tr>
<td><span class="term"><i><tt>string</tt></i>:</span></td>
<td>the string to add</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBufferWriteQuotedString"></a>xmlBufferWriteQuotedString ()</h3>
<pre class="programlisting">void xmlBufferWriteQuotedString (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * string)<br>
</pre>
<p>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</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the XML buffer output</td>
</tr>
<tr>
<td><span class="term"><i><tt>string</tt></i>:</span></td>
<td>the string to add</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBuildQName"></a>xmlBuildQName ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlBuildQName (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ncname, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * memory, <br> int len)<br>
</pre>
<p>Builds the QName @prefix:@ncname in @memory if there is enough space and prefix is not NULL nor empty, otherwise allocate a new string. If prefix is NULL or empty it returns ncname.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ncname</tt></i>:</span></td>
<td>the Name</td>
</tr>
<tr>
<td><span class="term"><i><tt>prefix</tt></i>:</span></td>
<td>the prefix</td>
</tr>
<tr>
<td><span class="term"><i><tt>memory</tt></i>:</span></td>
<td>preallocated memory</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>preallocated memory length</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new string which must be freed by the caller if different from @memory and @ncname or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlChildElementCount"></a>xmlChildElementCount ()</h3>
<pre class="programlisting">unsigned long xmlChildElementCount (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent)<br>
</pre>
<p>Count the number of child nodes which are elements. Note that entity references are not expanded.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>parent</tt></i>:</span></td>
<td>the parent node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of element children or 0 if arguments are invalid.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCopyDoc"></a>xmlCopyDoc ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> xmlCopyDoc (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> int recursive)<br>
</pre>
<p>Copy a document. If recursive, the content tree will be copied too as well as DTD, namespaces and entities.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>recursive</tt></i>:</span></td>
<td>if not zero do a recursive copy.</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the copied document or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCopyDtd"></a>xmlCopyDtd ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlDtdPtr">xmlDtdPtr</a> xmlCopyDtd (<a href="libxml2-tree.html#xmlDtdPtr">xmlDtdPtr</a> dtd)<br>
</pre>
<p>Copy a DTD.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>dtd</tt></i>:</span></td>
<td>the DTD</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the copied DTD or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCopyNamespace"></a>xmlCopyNamespace ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> xmlCopyNamespace (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> cur)<br>
</pre>
<p>Copy a namespace.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the namespace</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the copied namespace or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCopyNamespaceList"></a>xmlCopyNamespaceList ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> xmlCopyNamespaceList (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> cur)<br>
</pre>
<p>Copy a namespace list.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the first namespace</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the head of the copied list or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCopyNode"></a>xmlCopyNode ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlCopyNode (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> int extended)<br>
</pre>
<p>Copy a node. Use of this function is DISCOURAGED in favor of <a href="libxml2-tree.html#xmlDocCopyNode">xmlDocCopyNode</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>extended</tt></i>:</span></td>
<td>if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the copied node or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCopyNodeList"></a>xmlCopyNodeList ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlCopyNodeList (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node)<br>
</pre>
<p>Copy a node list and all children. Use of this function is DISCOURAGED in favor of <a href="libxml2-tree.html#xmlDocCopyNodeList">xmlDocCopyNodeList</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the first node in the list.</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the head of the copied list or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCopyProp"></a>xmlCopyProp ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> xmlCopyProp (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> target, <br> <a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> cur)<br>
</pre>
<p>Create a copy of the <a href="libxml2-SAX.html#attribute">attribute</a>. This function sets the parent pointer of the copy to @target but doesn't set the <a href="libxml2-SAX.html#attribute">attribute</a> on the target element. Users should consider to set the <a href="libxml2-SAX.html#attribute">attribute</a> by calling <a href="libxml2-tree.html#xmlAddChild">xmlAddChild</a> afterwards or reset the parent pointer to NULL.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>target</tt></i>:</span></td>
<td>the element where the <a href="libxml2-SAX.html#attribute">attribute</a> will be grafted</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the copied <a href="libxml2-SAX.html#attribute">attribute</a> or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCopyPropList"></a>xmlCopyPropList ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> xmlCopyPropList (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> target, <br> <a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> cur)<br>
</pre>
<p>Create a copy of an <a href="libxml2-SAX.html#attribute">attribute</a> list. This function sets the parent pointers of the copied attributes to @target but doesn't set the attributes on the target element.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>target</tt></i>:</span></td>
<td>the element where the attributes will be grafted</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the first <a href="libxml2-SAX.html#attribute">attribute</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the head of the copied list or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCreateIntSubset"></a>xmlCreateIntSubset ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlDtdPtr">xmlDtdPtr</a> xmlCreateIntSubset (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ExternalID, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * SystemID)<br>
</pre>
<p>Create a DTD node. If a document is provided and it already has an internal subset, the existing DTD object is returned without creating a new object. If the document has no internal subset, it will be set to the created DTD.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document pointer (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the DTD name (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>ExternalID</tt></i>:</span></td>
<td>the external (PUBLIC) ID (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>SystemID</tt></i>:</span></td>
<td>the system ID (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new or existing DTD object or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDOMWrapAdoptNode"></a>xmlDOMWrapAdoptNode ()</h3>
<pre class="programlisting">int xmlDOMWrapAdoptNode (<a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> sourceDoc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> destDoc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> destParent, <br> int options)<br>
</pre>
<p>References of out-of scope ns-decls are remapped to point to @destDoc: 1) If @destParent is given, then nsDef entries on element-nodes are used 2) If *no* @destParent is given, then @destDoc->oldNs entries are used This is the case when you have an unlinked node and just want to move it to the context of If @destParent is given, it ensures that the tree is namespace wellformed by creating additional ns-decls where needed. Note that, since prefixes of already existent ns-decls can be shadowed by this process, it could break QNames in <a href="libxml2-SAX.html#attribute">attribute</a> values or element content. NOTE: This function was not intensively tested.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the optional context for custom processing</td>
</tr>
<tr>
<td><span class="term"><i><tt>sourceDoc</tt></i>:</span></td>
<td>the optional sourceDoc</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node to start with</td>
</tr>
<tr>
<td><span class="term"><i><tt>destDoc</tt></i>:</span></td>
<td>the destination doc</td>
</tr>
<tr>
<td><span class="term"><i><tt>destParent</tt></i>:</span></td>
<td>the optional new parent of @node in @destDoc</td>
</tr>
<tr>
<td><span class="term"><i><tt>options</tt></i>:</span></td>
<td>option flags</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if the operation succeeded, 1 if a node of unsupported type was given, 2 if a node of not yet supported type was given and -1 on API/internal errors.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDOMWrapCloneNode"></a>xmlDOMWrapCloneNode ()</h3>
<pre class="programlisting">int xmlDOMWrapCloneNode (<a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> sourceDoc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> * resNode, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> destDoc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> destParent, <br> int deep, <br> int options)<br>
</pre>
<p>References of out-of scope ns-decls are remapped to point to @destDoc: 1) If @destParent is given, then nsDef entries on element-nodes are used 2) If *no* @destParent is given, then @destDoc->oldNs entries are used. This is the case when you don't know already where the cloned branch will be added to. If @destParent is given, it ensures that the tree is namespace wellformed by creating additional ns-decls where needed. Note that, since prefixes of already existent ns-decls can be shadowed by this process, it could break QNames in <a href="libxml2-SAX.html#attribute">attribute</a> values or element content. TODO: 1) What to do with XInclude? Currently this returns an error for XInclude.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the optional context for custom processing</td>
</tr>
<tr>
<td><span class="term"><i><tt>sourceDoc</tt></i>:</span></td>
<td>the optional sourceDoc</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node to start with</td>
</tr>
<tr>
<td><span class="term"><i><tt>resNode</tt></i>:</span></td>
<td>the clone of the given @node</td>
</tr>
<tr>
<td><span class="term"><i><tt>destDoc</tt></i>:</span></td>
<td>the destination doc</td>
</tr>
<tr>
<td><span class="term"><i><tt>destParent</tt></i>:</span></td>
<td>the optional new parent of @node in @destDoc</td>
</tr>
<tr>
<td><span class="term"><i><tt>deep</tt></i>:</span></td>
<td>descend into child if set</td>
</tr>
<tr>
<td><span class="term"><i><tt>options</tt></i>:</span></td>
<td>option flags</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if the operation succeeded, 1 if a node of unsupported (or not yet supported) type was given, -1 on API/internal errors.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDOMWrapFreeCtxt"></a>xmlDOMWrapFreeCtxt ()</h3>
<pre class="programlisting">void xmlDOMWrapFreeCtxt (<a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> ctxt)<br>
</pre>
<p>Frees the DOM-wrapper context.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the DOM-wrapper context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDOMWrapNewCtxt"></a>xmlDOMWrapNewCtxt ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> xmlDOMWrapNewCtxt (void)<br>
</pre>
<p>Allocates and initializes a new DOM-wrapper context.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> or NULL in case of an internal error.</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDOMWrapReconcileNamespaces"></a>xmlDOMWrapReconcileNamespaces ()</h3>
<pre class="programlisting">int xmlDOMWrapReconcileNamespaces (<a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> elem, <br> int options)<br>
</pre>
<p>Ensures that ns-references point to ns-decls hold on element-nodes. Ensures that the tree is namespace wellformed by creating additional ns-decls where needed. Note that, since prefixes of already existent ns-decls can be shadowed by this process, it could break QNames in <a href="libxml2-SAX.html#attribute">attribute</a> values or element content. NOTE: This function was not intensively tested.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>DOM wrapper context, unused at the moment</td>
</tr>
<tr>
<td><span class="term"><i><tt>elem</tt></i>:</span></td>
<td>the element-node</td>
</tr>
<tr>
<td><span class="term"><i><tt>options</tt></i>:</span></td>
<td>option flags</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if succeeded, -1 otherwise and on API/internal errors.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDOMWrapRemoveNode"></a>xmlDOMWrapRemoveNode ()</h3>
<pre class="programlisting">int xmlDOMWrapRemoveNode (<a href="libxml2-tree.html#xmlDOMWrapCtxtPtr">xmlDOMWrapCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> int options)<br>
</pre>
<p>Unlinks the given node from its owner. This will substitute ns-references to node->nsDef for ns-references to doc->oldNs, thus ensuring the removed branch to be autark wrt ns-references. NOTE: This function was not intensively tested.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>a DOM wrapper context</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the doc</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node to be removed.</td>
</tr>
<tr>
<td><span class="term"><i><tt>options</tt></i>:</span></td>
<td>set of options, unused at the moment</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success, 1 if the node is not supported, -1 on API and internal errors.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDeregisterNodeDefault"></a>xmlDeregisterNodeDefault ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlDeregisterNodeFunc">xmlDeregisterNodeFunc</a> xmlDeregisterNodeDefault (<a href="libxml2-tree.html#xmlDeregisterNodeFunc">xmlDeregisterNodeFunc</a> func)<br>
</pre>
<p>DEPRECATED: don't use Registers a callback for node destruction</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>func</tt></i>:</span></td>
<td>function pointer to the new DeregisterNodeFunc</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the previous value of the deregistration function</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDocCopyNode"></a>xmlDocCopyNode ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlDocCopyNode (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> int extended)<br>
</pre>
<p>Copy a node into another document.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>extended</tt></i>:</span></td>
<td>if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the copied node or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDocCopyNodeList"></a>xmlDocCopyNodeList ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlDocCopyNodeList (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node)<br>
</pre>
<p>Copy a node list and all children into a new document.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the target document</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the first node in the list.</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the head of the copied list or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDocDump"></a>xmlDocDump ()</h3>
<pre class="programlisting">int xmlDocDump (FILE * f, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur)<br>
</pre>
<p>Dump an XML document to an open FILE.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>f</tt></i>:</span></td>
<td>the FILE*</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of bytes written or -1 in case of failure.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDocDumpFormatMemory"></a>xmlDocDumpFormatMemory ()</h3>
<pre class="programlisting">void xmlDocDumpFormatMemory (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** mem, <br> int * size, <br> int format)<br>
</pre>
<p>Dump an XML document in memory and return the #xmlChar * and it's size. It's up to the caller to free the memory with xmlFree(). Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was called</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>mem</tt></i>:</span></td>
<td>OUT: the memory pointer</td>
</tr>
<tr>
<td><span class="term"><i><tt>size</tt></i>:</span></td>
<td>OUT: the memory length</td>
</tr>
<tr>
<td><span class="term"><i><tt>format</tt></i>:</span></td>
<td>should formatting spaces been added</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDocDumpFormatMemoryEnc"></a>xmlDocDumpFormatMemoryEnc ()</h3>
<pre class="programlisting">void xmlDocDumpFormatMemoryEnc (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> out_doc, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** doc_txt_ptr, <br> int * doc_txt_len, <br> const char * txt_encoding, <br> int format)<br>
</pre>
<p>Dump the current DOM tree into memory using the character encoding specified by the caller. Note it is up to the caller of this function to free the allocated memory with xmlFree(). Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was called</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>out_doc</tt></i>:</span></td>
<td>Document to generate XML text from</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc_txt_ptr</tt></i>:</span></td>
<td>Memory pointer for allocated XML text</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc_txt_len</tt></i>:</span></td>
<td>Length of the generated XML text</td>
</tr>
<tr>
<td><span class="term"><i><tt>txt_encoding</tt></i>:</span></td>
<td>Character encoding to use when generating XML text</td>
</tr>
<tr>
<td><span class="term"><i><tt>format</tt></i>:</span></td>
<td>should formatting spaces been added</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDocDumpMemory"></a>xmlDocDumpMemory ()</h3>
<pre class="programlisting">void xmlDocDumpMemory (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** mem, <br> int * size)<br>
</pre>
<p>Dump an XML document in memory and return the #xmlChar * and it's size in bytes. It's up to the caller to free the memory with xmlFree(). The resulting byte array is zero terminated, though the last 0 is not included in the returned size.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>mem</tt></i>:</span></td>
<td>OUT: the memory pointer</td>
</tr>
<tr>
<td><span class="term"><i><tt>size</tt></i>:</span></td>
<td>OUT: the memory length</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDocDumpMemoryEnc"></a>xmlDocDumpMemoryEnc ()</h3>
<pre class="programlisting">void xmlDocDumpMemoryEnc (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> out_doc, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** doc_txt_ptr, <br> int * doc_txt_len, <br> const char * txt_encoding)<br>
</pre>
<p>Dump the current DOM tree into memory using the character encoding specified by the caller. Note it is up to the caller of this function to free the allocated memory with xmlFree().</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>out_doc</tt></i>:</span></td>
<td>Document to generate XML text from</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc_txt_ptr</tt></i>:</span></td>
<td>Memory pointer for allocated XML text</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc_txt_len</tt></i>:</span></td>
<td>Length of the generated XML text</td>
</tr>
<tr>
<td><span class="term"><i><tt>txt_encoding</tt></i>:</span></td>
<td>Character encoding to use when generating XML text</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDocFormatDump"></a>xmlDocFormatDump ()</h3>
<pre class="programlisting">int xmlDocFormatDump (FILE * f, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> int format)<br>
</pre>
<p>Dump an XML document to an open FILE.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>f</tt></i>:</span></td>
<td>the FILE*</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>format</tt></i>:</span></td>
<td>should formatting spaces been added</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of bytes written or -1 in case of failure. Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was called</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDocGetRootElement"></a>xmlDocGetRootElement ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlDocGetRootElement (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc)<br>
</pre>
<p>Get the root element of the document (doc->children is a list containing possibly comments, PIs, etc ...).</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the root element or NULL if no element was found.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDocSetRootElement"></a>xmlDocSetRootElement ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlDocSetRootElement (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> root)<br>
</pre>
<p>Set the root element of the document (doc->children is a list containing possibly comments, PIs, etc ...). @root must be an element node. It is unlinked before insertion.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>root</tt></i>:</span></td>
<td>the new document root element, if root is NULL no action is taken, to remove a node from a document use xmlUnlinkNode(root) instead.</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the unlinked old root element or NULL if the document didn't have a root element or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlElemDump"></a>xmlElemDump ()</h3>
<pre class="programlisting">void xmlElemDump (FILE * f, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Dump an XML/HTML node, recursive behaviour, children are printed too.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>f</tt></i>:</span></td>
<td>the FILE * for the output</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFirstElementChild"></a>xmlFirstElementChild ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlFirstElementChild (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent)<br>
</pre>
<p>Find the first child node which is an element. Note that entity references are not expanded.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>parent</tt></i>:</span></td>
<td>the parent node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the first element or NULL if parent has no children.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFreeDoc"></a>xmlFreeDoc ()</h3>
<pre class="programlisting">void xmlFreeDoc (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur)<br>
</pre>
<p>Free a document including all children and associated DTDs.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>pointer to the document</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFreeDtd"></a>xmlFreeDtd ()</h3>
<pre class="programlisting">void xmlFreeDtd (<a href="libxml2-tree.html#xmlDtdPtr">xmlDtdPtr</a> cur)<br>
</pre>
<p>Free a DTD structure.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the DTD structure to free up</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFreeNode"></a>xmlFreeNode ()</h3>
<pre class="programlisting">void xmlFreeNode (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Free a node including all the children. This doesn't unlink the node from the tree. Call <a href="libxml2-tree.html#xmlUnlinkNode">xmlUnlinkNode</a> first unless @cur is a root node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFreeNodeList"></a>xmlFreeNodeList ()</h3>
<pre class="programlisting">void xmlFreeNodeList (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Free a node list including all children.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the first node in the list</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFreeNs"></a>xmlFreeNs ()</h3>
<pre class="programlisting">void xmlFreeNs (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> cur)<br>
</pre>
<p>Free an <a href="libxml2-tree.html#xmlNs">xmlNs</a> object.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the namespace pointer</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFreeNsList"></a>xmlFreeNsList ()</h3>
<pre class="programlisting">void xmlFreeNsList (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> cur)<br>
</pre>
<p>Free a list of <a href="libxml2-tree.html#xmlNs">xmlNs</a> objects.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the first namespace pointer</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFreeProp"></a>xmlFreeProp ()</h3>
<pre class="programlisting">void xmlFreeProp (<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> cur)<br>
</pre>
<p>Free an <a href="libxml2-SAX.html#attribute">attribute</a> including all children.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>an <a href="libxml2-SAX.html#attribute">attribute</a>
</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFreePropList"></a>xmlFreePropList ()</h3>
<pre class="programlisting">void xmlFreePropList (<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> cur)<br>
</pre>
<p>Free an <a href="libxml2-SAX.html#attribute">attribute</a> list including all children.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the first <a href="libxml2-SAX.html#attribute">attribute</a> in the list</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetBufferAllocationScheme"></a>xmlGetBufferAllocationScheme ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlBufferAllocationScheme">xmlBufferAllocationScheme</a> xmlGetBufferAllocationScheme (void)<br>
</pre>
<p>Types are <a href="libxml2-tree.html#XML_BUFFER_ALLOC_EXACT">XML_BUFFER_ALLOC_EXACT</a> - use exact sizes, keeps memory usage down <a href="libxml2-tree.html#XML_BUFFER_ALLOC_DOUBLEIT">XML_BUFFER_ALLOC_DOUBLEIT</a> - double buffer when extra needed, improves performance <a href="libxml2-tree.html#XML_BUFFER_ALLOC_HYBRID">XML_BUFFER_ALLOC_HYBRID</a> - use exact sizes on small strings to keep memory usage tight in normal usage, and doubleit on large strings to avoid pathological performance.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the current allocation scheme</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetCompressMode"></a>xmlGetCompressMode ()</h3>
<pre class="programlisting">int xmlGetCompressMode (void)<br>
</pre>
<p>DEPRECATED: Use <a href="libxml2-tree.html#xmlGetDocCompressMode">xmlGetDocCompressMode</a> get the default compression mode used, ZLIB based.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 (uncompressed) to 9 (max compression)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetDocCompressMode"></a>xmlGetDocCompressMode ()</h3>
<pre class="programlisting">int xmlGetDocCompressMode (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc)<br>
</pre>
<p>get the compression ratio for a document, ZLIB based</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 (uncompressed) to 9 (max compression)</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetIntSubset"></a>xmlGetIntSubset ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlDtdPtr">xmlDtdPtr</a> xmlGetIntSubset (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc)<br>
</pre>
<p>Get the internal subset of a document.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document pointer</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the DTD object or NULL if not found.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetLastChild"></a>xmlGetLastChild ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlGetLastChild (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * parent)<br>
</pre>
<p>Find the last child of a node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>parent</tt></i>:</span></td>
<td>the parent node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the last child or NULL if parent has no children.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetLineNo"></a>xmlGetLineNo ()</h3>
<pre class="programlisting">long xmlGetLineNo (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node)<br>
</pre>
<p>Get line number of @node. Try to override the limitation of lines being store in 16 bits ints if <a href="libxml2-parser.html#XML_PARSE_BIG_LINES">XML_PARSE_BIG_LINES</a> parser option was used</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>valid node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the line number if successful, -1 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetNoNsProp"></a>xmlGetNoNsProp ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlGetNoNsProp (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Search and get the value of an <a href="libxml2-SAX.html#attribute">attribute</a> associated to a node This does the entity substitution. This function looks in DTD <a href="libxml2-SAX.html#attribute">attribute</a> declaration for #FIXED or default declaration values. This function is similar to <a href="libxml2-tree.html#xmlGetProp">xmlGetProp</a> except it will accept only an <a href="libxml2-SAX.html#attribute">attribute</a> in no namespace. NOTE: This function doesn't allow to distinguish malloc failures from missing attributes. It's more robust to use <a href="libxml2-tree.html#xmlNodeGetAttrValue">xmlNodeGetAttrValue</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> value or NULL if not found or a memory allocation failed. It's up to the caller to free the memory with xmlFree().</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetNodePath"></a>xmlGetNodePath ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlGetNodePath (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node)<br>
</pre>
<p>Build a structure based Path for the given node</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>a node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new path or NULL in case of error. The caller must free the returned string</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetNsList"></a>xmlGetNsList ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> * xmlGetNsList (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node)<br>
</pre>
<p>Find all in-scope namespaces of a node. Use <a href="libxml2-tree.html#xmlGetNsListSafe">xmlGetNsListSafe</a> for better error reporting.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the current node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a NULL terminated array of namespace pointers that must be freed by the caller or NULL if no namespaces were found or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetNsListSafe"></a>xmlGetNsListSafe ()</h3>
<pre class="programlisting">int xmlGetNsListSafe (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ** out)<br>
</pre>
<p>Find all in-scope namespaces of a node. @out returns a NULL terminated array of namespace pointers that must be freed by the caller. Available since 2.13.0.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the current node</td>
</tr>
<tr>
<td><span class="term"><i><tt>out</tt></i>:</span></td>
<td>the returned namespace array</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success, 1 if no namespaces were found, -1 if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetNsProp"></a>xmlGetNsProp ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlGetNsProp (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * nameSpace)<br>
</pre>
<p>Search and get the value of an <a href="libxml2-SAX.html#attribute">attribute</a> associated to a node This <a href="libxml2-SAX.html#attribute">attribute</a> has to be anchored in the namespace specified. This does the entity substitution. This function looks in DTD <a href="libxml2-SAX.html#attribute">attribute</a> declaration for #FIXED or default declaration values. NOTE: This function doesn't allow to distinguish malloc failures from missing attributes. It's more robust to use <a href="libxml2-tree.html#xmlNodeGetAttrValue">xmlNodeGetAttrValue</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> name</td>
</tr>
<tr>
<td><span class="term"><i><tt>nameSpace</tt></i>:</span></td>
<td>the URI of the namespace</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> value or NULL if not found or a memory allocation failed. It's up to the caller to free the memory with xmlFree().</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetProp"></a>xmlGetProp ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlGetProp (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Search and get the value of an <a href="libxml2-SAX.html#attribute">attribute</a> associated to a node This does the entity substitution. This function looks in DTD <a href="libxml2-SAX.html#attribute">attribute</a> declaration for #FIXED or default declaration values. NOTE: This function acts independently of namespaces associated to the <a href="libxml2-SAX.html#attribute">attribute</a>. Use xmlGetNsProp() or xmlGetNoNsProp() for namespace aware processing. NOTE: This function doesn't allow to distinguish malloc failures from missing attributes. It's more robust to use <a href="libxml2-tree.html#xmlNodeGetAttrValue">xmlNodeGetAttrValue</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> value or NULL if not found or a memory allocation failed. It's up to the caller to free the memory with xmlFree().</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlHasNsProp"></a>xmlHasNsProp ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> xmlHasNsProp (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * nameSpace)<br>
</pre>
<p>Search for an <a href="libxml2-SAX.html#attribute">attribute</a> associated to a node This <a href="libxml2-SAX.html#attribute">attribute</a> has to be anchored in the namespace specified. This does the entity substitution. This function looks in DTD <a href="libxml2-SAX.html#attribute">attribute</a> declaration for #FIXED or default declaration values. Note that a namespace of NULL indicates to use the default namespace.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> name</td>
</tr>
<tr>
<td><span class="term"><i><tt>nameSpace</tt></i>:</span></td>
<td>the URI of the namespace</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> or the <a href="libxml2-SAX.html#attribute">attribute</a> declaration or NULL if neither was found. Also returns NULL if a memory allocation failed making this function unreliable.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlHasProp"></a>xmlHasProp ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> xmlHasProp (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Search an <a href="libxml2-SAX.html#attribute">attribute</a> associated to a node This function also looks in DTD <a href="libxml2-SAX.html#attribute">attribute</a> declaration for #FIXED or default declaration values.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> or the <a href="libxml2-SAX.html#attribute">attribute</a> declaration or NULL if neither was found. Also returns NULL if a memory allocation failed making this function unreliable.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlIsBlankNode"></a>xmlIsBlankNode ()</h3>
<pre class="programlisting">int xmlIsBlankNode (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node)<br>
</pre>
<p>Checks whether this node is an empty or whitespace only (and possibly ignorable) text-node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 yes, 0 no</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlIsXHTML"></a>xmlIsXHTML ()</h3>
<pre class="programlisting">int xmlIsXHTML (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * systemID, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * publicID)<br>
</pre>
<p>Try to find if the document correspond to an XHTML DTD</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>systemID</tt></i>:</span></td>
<td>the system identifier</td>
</tr>
<tr>
<td><span class="term"><i><tt>publicID</tt></i>:</span></td>
<td>the public identifier</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true, 0 if not and -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlLastElementChild"></a>xmlLastElementChild ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlLastElementChild (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent)<br>
</pre>
<p>Find the last child node which is an element. Note that entity references are not expanded.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>parent</tt></i>:</span></td>
<td>the parent node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the last element or NULL if parent has no children.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewCDataBlock"></a>xmlNewCDataBlock ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewCDataBlock (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content, <br> int len)<br>
</pre>
<p>Create a CDATA section node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the target document (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>raw text content (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>size of text content</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewCharRef"></a>xmlNewCharRef ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewCharRef (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>This function is MISNAMED. It doesn't create a character <a href="libxml2-SAX.html#reference">reference</a> but an entity <a href="libxml2-SAX.html#reference">reference</a>. Create an empty entity <a href="libxml2-SAX.html#reference">reference</a> node. This function doesn't attempt to look up the entity in @doc. Entity names like '&entity;' are handled as well.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the target document (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the entity name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewChild"></a>xmlNewChild ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewChild (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content)<br>
</pre>
<p>Create a new child element and append it to a parent element. If @ns is NULL, the newly created element inherits the namespace of the parent. If provided, @content is expected to be a valid XML <a href="libxml2-SAX.html#attribute">attribute</a> value possibly containing character and entity references. Text and entity <a href="libxml2-SAX.html#reference">reference</a> node will be added to the child element, see <a href="libxml2-tree.html#xmlNewDocNode">xmlNewDocNode</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>parent</tt></i>:</span></td>
<td>the parent node</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>a namespace (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the name of the child</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>text content with XML references (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewComment"></a>xmlNewComment ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewComment (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content)<br>
</pre>
<p>Use of this function is DISCOURAGED in favor of <a href="libxml2-tree.html#xmlNewDocComment">xmlNewDocComment</a>. Create a <a href="libxml2-SAX.html#comment">comment</a> node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#comment">comment</a> content (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewDoc"></a>xmlNewDoc ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> xmlNewDoc (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * version)<br>
</pre>
<p>Creates a new XML document. If version is NULL, "1.0" is used.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>version</tt></i>:</span></td>
<td>XML version string like "1.0" (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new document or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewDocComment"></a>xmlNewDocComment ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewDocComment (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content)<br>
</pre>
<p>Create a <a href="libxml2-SAX.html#comment">comment</a> node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#comment">comment</a> content</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewDocFragment"></a>xmlNewDocFragment ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewDocFragment (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc)<br>
</pre>
<p>Create a document fragment node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the target document (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewDocNode"></a>xmlNewDocNode ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewDocNode (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content)<br>
</pre>
<p>Create an element node. If provided, @content is expected to be a valid XML <a href="libxml2-SAX.html#attribute">attribute</a> value possibly containing character and entity references. Syntax errors and references to undeclared entities are ignored silently. Only references are handled, nested elements, comments or PIs are not. See <a href="libxml2-tree.html#xmlNewDocRawNode">xmlNewDocRawNode</a> for an alternative. General notes on object creation: Each node and all its children are associated with the same document. The document should be provided when creating nodes to avoid a performance penalty when adding the node to a document tree. Note that a document only owns nodes reachable from the root node. Unlinked subtrees must be freed manually.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the target document</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>namespace (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the node name</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>text content with XML references (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewDocNodeEatName"></a>xmlNewDocNodeEatName ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewDocNodeEatName (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content)<br>
</pre>
<p>Create an element node. Like xmlNewDocNode, but the @name string will be used directly without making a copy. Takes ownership of @name which will also be freed on error.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the target document</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>namespace (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the node name</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>text content with XML references (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewDocPI"></a>xmlNewDocPI ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewDocPI (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content)<br>
</pre>
<p>Create a processing instruction object.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the target document (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the processing instruction target</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>the PI content (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewDocProp"></a>xmlNewDocProp ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> xmlNewDocProp (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value)<br>
</pre>
<p>Create an <a href="libxml2-SAX.html#attribute">attribute</a> object. If provided, @value is expected to be a valid XML <a href="libxml2-SAX.html#attribute">attribute</a> value possibly containing character and entity references. Syntax errors and references to undeclared entities are ignored silently. If you want to pass a raw string, see <a href="libxml2-tree.html#xmlNewProp">xmlNewProp</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the target document (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the name of the <a href="libxml2-SAX.html#attribute">attribute</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>
<a href="libxml2-SAX.html#attribute">attribute</a> value with XML references (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the <a href="libxml2-SAX.html#attribute">attribute</a> or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewDocRawNode"></a>xmlNewDocRawNode ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewDocRawNode (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content)<br>
</pre>
<p>Create an element node. If provided, @value should be a raw, unescaped string.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the target document</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>namespace (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the node name</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>raw text content (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewDocText"></a>xmlNewDocText ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewDocText (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content)<br>
</pre>
<p>Create a new text node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the target document</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>raw text content (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewDocTextLen"></a>xmlNewDocTextLen ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewDocTextLen (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content, <br> int len)<br>
</pre>
<p>Create a new text node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the target document</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>raw text content (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>size of text content</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewDtd"></a>xmlNewDtd ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlDtdPtr">xmlDtdPtr</a> xmlNewDtd (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ExternalID, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * SystemID)<br>
</pre>
<p>Create a DTD node. If a document is provided, it is an error if it already has an external subset. If the document has no external subset, it will be set to the created DTD. To create an internal subset, use xmlCreateIntSubset().</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document pointer (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the DTD name (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>ExternalID</tt></i>:</span></td>
<td>the external ID (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>SystemID</tt></i>:</span></td>
<td>the system ID (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new DTD object or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewGlobalNs"></a>xmlNewGlobalNs ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> xmlNewGlobalNs (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * href, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix)<br>
</pre>
<p>Creation of a Namespace, the old way using PI and without scoping DEPRECATED !!!</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document carrying the namespace</td>
</tr>
<tr>
<td><span class="term"><i><tt>href</tt></i>:</span></td>
<td>the URI associated</td>
</tr>
<tr>
<td><span class="term"><i><tt>prefix</tt></i>:</span></td>
<td>the prefix for the namespace</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>NULL this functionality had been removed</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewNode"></a>xmlNewNode ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewNode (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Create an element node. Use of this function is DISCOURAGED in favor of <a href="libxml2-tree.html#xmlNewDocNode">xmlNewDocNode</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>namespace (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the node name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewNodeEatName"></a>xmlNewNodeEatName ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewNodeEatName (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Create an element node. Use of this function is DISCOURAGED in favor of <a href="libxml2-tree.html#xmlNewDocNodeEatName">xmlNewDocNodeEatName</a>. Like xmlNewNode, but the @name string will be used directly without making a copy. Takes ownership of @name which will also be freed on error.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>namespace (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the node name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewNs"></a>xmlNewNs ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> xmlNewNs (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * href, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix)<br>
</pre>
<p>Create a new namespace. For a default namespace, @prefix should be NULL. The namespace URI in @href is not checked. You should make sure to pass a valid URI. If @node is provided, it must be an element node. The namespace will be appended to the node's namespace declarations. It is an error if the node already has a definition for the prefix or default namespace.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the element carrying the namespace (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>href</tt></i>:</span></td>
<td>the URI associated</td>
</tr>
<tr>
<td><span class="term"><i><tt>prefix</tt></i>:</span></td>
<td>the prefix for the namespace (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new namespace pointer or NULL if arguments are invalid, the prefix is already in use or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewNsProp"></a>xmlNewNsProp ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> xmlNewNsProp (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value)<br>
</pre>
<p>Create an <a href="libxml2-SAX.html#attribute">attribute</a> object. If provided, @value should be a raw, unescaped string. If @node is provided, the created <a href="libxml2-SAX.html#attribute">attribute</a> will be appended without checking for duplicate names. It is an error if @node is not an element.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the parent node (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>the namespace (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the local name of the <a href="libxml2-SAX.html#attribute">attribute</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the value of the <a href="libxml2-SAX.html#attribute">attribute</a> (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the <a href="libxml2-SAX.html#attribute">attribute</a> or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewNsPropEatName"></a>xmlNewNsPropEatName ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> xmlNewNsPropEatName (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value)<br>
</pre>
<p>Like xmlNewNsProp, but the @name string will be used directly without making a copy. Takes ownership of @name which will also be freed on error.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the parent node (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>the namespace (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the local name of the <a href="libxml2-SAX.html#attribute">attribute</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the value of the <a href="libxml2-SAX.html#attribute">attribute</a> (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the <a href="libxml2-SAX.html#attribute">attribute</a> or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewPI"></a>xmlNewPI ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewPI (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content)<br>
</pre>
<p>Create a processing instruction node. Use of this function is DISCOURAGED in favor of <a href="libxml2-tree.html#xmlNewDocPI">xmlNewDocPI</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the processing instruction target</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>the PI content (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewProp"></a>xmlNewProp ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> xmlNewProp (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value)<br>
</pre>
<p>Create an <a href="libxml2-SAX.html#attribute">attribute</a> node. If provided, @value should be a raw, unescaped string. If @node is provided, the created <a href="libxml2-SAX.html#attribute">attribute</a> will be appended without checking for duplicate names. It is an error if @node is not an element.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the parent node (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the name of the <a href="libxml2-SAX.html#attribute">attribute</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the value of the <a href="libxml2-SAX.html#attribute">attribute</a> (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the <a href="libxml2-SAX.html#attribute">attribute</a> or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewReference"></a>xmlNewReference ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewReference (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Create a new entity <a href="libxml2-SAX.html#reference">reference</a> node, linking the result with the entity in @doc if found. Entity names like '&entity;' are handled as well.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the target document (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the entity name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewText"></a>xmlNewText ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewText (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content)<br>
</pre>
<p>Create a text node. Use of this function is DISCOURAGED in favor of <a href="libxml2-tree.html#xmlNewDocText">xmlNewDocText</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>raw text content (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewTextChild"></a>xmlNewTextChild ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewTextChild (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> parent, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content)<br>
</pre>
<p>Create a new child element and append it to a parent element. If @ns is NULL, the newly created element inherits the namespace of the parent. If @content is provided, a text node will be added to the child element, see <a href="libxml2-tree.html#xmlNewDocRawNode">xmlNewDocRawNode</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>parent</tt></i>:</span></td>
<td>the parent node</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>a namespace (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the name of the child</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>raw text content of the child (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewTextLen"></a>xmlNewTextLen ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNewTextLen (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content, <br> int len)<br>
</pre>
<p>Use of this function is DISCOURAGED in favor of <a href="libxml2-tree.html#xmlNewDocTextLen">xmlNewDocTextLen</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>raw text content (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>size of text content</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new node object or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNextElementSibling"></a>xmlNextElementSibling ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlNextElementSibling (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node)<br>
</pre>
<p>Find the closest following sibling which is a element. Note that entity references are not expanded.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the current node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the sibling or NULL if no sibling was found.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeAddContent"></a>xmlNodeAddContent ()</h3>
<pre class="programlisting">int xmlNodeAddContent (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content)<br>
</pre>
<p>Append the extra substring to the node content. NOTE: In contrast to xmlNodeSetContent(), @content is supposed to be raw text, so unescaped XML special chars are allowed, entity references are not supported.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being modified</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>extra content</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success, 1 on error, -1 if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeAddContentLen"></a>xmlNodeAddContentLen ()</h3>
<pre class="programlisting">int xmlNodeAddContentLen (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content, <br> int len)<br>
</pre>
<p>Append the extra substring to the node content. NOTE: In contrast to xmlNodeSetContentLen(), @content is supposed to be raw text, so unescaped XML special chars are allowed, entity references are not supported.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being modified</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>extra content</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>the size of @content</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success, 1 on error, -1 if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeBufGetContent"></a>xmlNodeBufGetContent ()</h3>
<pre class="programlisting">int xmlNodeBufGetContent (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buffer, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur)<br>
</pre>
<p>Read the value of a node @cur, 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 substituted. Fills up the buffer @buffer with this value</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buffer</tt></i>:</span></td>
<td>a buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being read</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success and -1 in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeDump"></a>xmlNodeDump ()</h3>
<pre class="programlisting">int xmlNodeDump (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buf, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> int level, <br> int format)<br>
</pre>
<p>Dump an XML node, recursive behaviour,children are printed too. Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was called. Since this is using <a href="libxml2-tree.html#xmlBuffer">xmlBuffer</a> structures it is limited to 2GB and somehow deprecated, use xmlNodeDumpOutput() instead.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the XML buffer output</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node</td>
</tr>
<tr>
<td><span class="term"><i><tt>level</tt></i>:</span></td>
<td>the imbrication level for indenting</td>
</tr>
<tr>
<td><span class="term"><i><tt>format</tt></i>:</span></td>
<td>is formatting allowed</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of bytes written to the buffer or -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeDumpOutput"></a>xmlNodeDumpOutput ()</h3>
<pre class="programlisting">void xmlNodeDumpOutput (<a href="libxml2-tree.html#xmlOutputBufferPtr">xmlOutputBufferPtr</a> buf, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> int level, <br> int format, <br> const char * encoding)<br>
</pre>
<p>Dump an XML node, recursive behaviour, children are printed too. Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was called</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>the XML buffer output</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node</td>
</tr>
<tr>
<td><span class="term"><i><tt>level</tt></i>:</span></td>
<td>the imbrication level for indenting</td>
</tr>
<tr>
<td><span class="term"><i><tt>format</tt></i>:</span></td>
<td>is formatting allowed</td>
</tr>
<tr>
<td><span class="term"><i><tt>encoding</tt></i>:</span></td>
<td>an optional encoding string</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeGetAttrValue"></a>xmlNodeGetAttrValue ()</h3>
<pre class="programlisting">int xmlNodeGetAttrValue (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * nsUri, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** out)<br>
</pre>
<p>Search and get the value of an <a href="libxml2-SAX.html#attribute">attribute</a> associated to a node This <a href="libxml2-SAX.html#attribute">attribute</a> has to be anchored in the namespace specified. This does the entity substitution. The returned value must be freed by the caller. Available since 2.13.0.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> name</td>
</tr>
<tr>
<td><span class="term"><i><tt>nsUri</tt></i>:</span></td>
<td>the URI of the namespace</td>
</tr>
<tr>
<td><span class="term"><i><tt>out</tt></i>:</span></td>
<td>the returned string</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success, 1 if no <a href="libxml2-SAX.html#attribute">attribute</a> was found, -1 if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeGetBase"></a>xmlNodeGetBase ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlNodeGetBase (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur)<br>
</pre>
<p>See <a href="libxml2-tree.html#xmlNodeGetBaseSafe">xmlNodeGetBaseSafe</a>. This function doesn't allow to distinguish memory allocation failures from a non-existing base.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document the node pertains to</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being checked</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the base URL, or NULL if not found It's up to the caller to free the memory with xmlFree().</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeGetBaseSafe"></a>xmlNodeGetBaseSafe ()</h3>
<pre class="programlisting">int xmlNodeGetBaseSafe (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** baseOut)<br>
</pre>
<p>Searches for the BASE URL. The code should work on both XML and HTML document even if base mechanisms are completely different. It returns the base as defined in RFC 2396 sections 5.1.1. Base URI within Document Content and 5.1.2. Base URI from the Encapsulating Entity However it does not return the document base (5.1.3), use doc->URL in this case Available since 2.13.0.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document the node pertains to</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being checked</td>
</tr>
<tr>
<td><span class="term"><i><tt>baseOut</tt></i>:</span></td>
<td>pointer to base</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success, 1 if a URI or argument is invalid, -1 if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeGetContent"></a>xmlNodeGetContent ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlNodeGetContent (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur)<br>
</pre>
<p>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 substituted.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being read</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new #xmlChar * or NULL if no content is available. It's up to the caller to free the memory with xmlFree().</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeGetLang"></a>xmlNodeGetLang ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlNodeGetLang (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur)<br>
</pre>
<p>Searches the language of a node, i.e. the values of the xml:lang <a href="libxml2-SAX.html#attribute">attribute</a> or the one carried by the nearest ancestor.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being checked</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the lang value, or NULL if not found It's up to the caller to free the memory with xmlFree().</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeGetSpacePreserve"></a>xmlNodeGetSpacePreserve ()</h3>
<pre class="programlisting">int xmlNodeGetSpacePreserve (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * cur)<br>
</pre>
<p>Searches the space preserving behaviour of a node, i.e. the values of the xml:space <a href="libxml2-SAX.html#attribute">attribute</a> or the one carried by the nearest ancestor.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being checked</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>-1 if xml:space is not inherited, 0 if "default", 1 if "preserve"</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeIsText"></a>xmlNodeIsText ()</h3>
<pre class="programlisting">int xmlNodeIsText (const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * node)<br>
</pre>
<p>Is this node a Text node ?</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 yes, 0 no</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeListGetRawString"></a>xmlNodeListGetRawString ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlNodeListGetRawString (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * list, <br> int inLine)<br>
</pre>
<p>Serializes <a href="libxml2-SAX.html#attribute">attribute</a> children (text and entity <a href="libxml2-SAX.html#reference">reference</a> nodes) into a string. An empty list produces an empty string. If @inLine is true, entity references will be substituted. Otherwise, entity references will be kept and special <a href="libxml2-SAX.html#characters">characters</a> like '&' will be escaped.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>a document (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>list</tt></i>:</span></td>
<td>a node list of <a href="libxml2-SAX.html#attribute">attribute</a> children (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>inLine</tt></i>:</span></td>
<td>whether entity references are substituted</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a string or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeListGetString"></a>xmlNodeListGetString ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlNodeListGetString (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> const <a href="libxml2-tree.html#xmlNode">xmlNode</a> * list, <br> int inLine)<br>
</pre>
<p>Serializes <a href="libxml2-SAX.html#attribute">attribute</a> children (text and entity <a href="libxml2-SAX.html#reference">reference</a> nodes) into a string. An empty list produces an empty string. If @inLine is true, entity references will be substituted. Otherwise, entity references will be kept and special <a href="libxml2-SAX.html#characters">characters</a> like '&' as well as non-ASCII chars will be escaped. See <a href="libxml2-tree.html#xmlNodeListGetRawString">xmlNodeListGetRawString</a> for an alternative option.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>a document (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>list</tt></i>:</span></td>
<td>a node list of <a href="libxml2-SAX.html#attribute">attribute</a> children (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>inLine</tt></i>:</span></td>
<td>whether entity references are substituted</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a string or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeSetBase"></a>xmlNodeSetBase ()</h3>
<pre class="programlisting">int xmlNodeSetBase (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * uri)<br>
</pre>
<p>Set (or reset) the base URI of a node, i.e. the value of the xml:base <a href="libxml2-SAX.html#attribute">attribute</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being changed</td>
</tr>
<tr>
<td><span class="term"><i><tt>uri</tt></i>:</span></td>
<td>the new base URI</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success, -1 on error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeSetContent"></a>xmlNodeSetContent ()</h3>
<pre class="programlisting">int xmlNodeSetContent (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content)<br>
</pre>
<p>Replace the text content of a node. Sets the raw text content of text, CDATA, <a href="libxml2-SAX.html#comment">comment</a> or PI nodes. For element and <a href="libxml2-SAX.html#attribute">attribute</a> nodes, removes all children and replaces them by parsing @content which is expected to be a valid XML <a href="libxml2-SAX.html#attribute">attribute</a> value possibly containing character and entity references. Syntax errors and references to undeclared entities are ignored silently. Unfortunately, there isn't an API to pass raw content directly. An inefficient work-around is to escape the content with <a href="libxml2-entities.html#xmlEncodeSpecialChars">xmlEncodeSpecialChars</a> before passing it. A better trick is clearing the old content with xmlNodeSetContent(node, NULL) first and then calling xmlNodeAddContent(node, content). Unlike this function, <a href="libxml2-tree.html#xmlNodeAddContent">xmlNodeAddContent</a> accepts raw text.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being modified</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>the new value of the content</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success, 1 on error, -1 if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeSetContentLen"></a>xmlNodeSetContentLen ()</h3>
<pre class="programlisting">int xmlNodeSetContentLen (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content, <br> int len)<br>
</pre>
<p>See <a href="libxml2-tree.html#xmlNodeSetContent">xmlNodeSetContent</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being modified</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>the new value of the content</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>the size of @content</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success, 1 on error, -1 if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeSetLang"></a>xmlNodeSetLang ()</h3>
<pre class="programlisting">int xmlNodeSetLang (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * lang)<br>
</pre>
<p>Set the language of a node, i.e. the values of the xml:lang <a href="libxml2-SAX.html#attribute">attribute</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being changed</td>
</tr>
<tr>
<td><span class="term"><i><tt>lang</tt></i>:</span></td>
<td>the language description</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success, 1 if arguments are invalid, -1 if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeSetName"></a>xmlNodeSetName ()</h3>
<pre class="programlisting">void xmlNodeSetName (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Set (or reset) the name of a node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being changed</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the new tag name</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNodeSetSpacePreserve"></a>xmlNodeSetSpacePreserve ()</h3>
<pre class="programlisting">int xmlNodeSetSpacePreserve (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur, <br> int val)<br>
</pre>
<p>Set (or reset) the space preserving behaviour of a node, i.e. the value of the xml:space <a href="libxml2-SAX.html#attribute">attribute</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node being changed</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the xml:space value ("0": default, 1: "preserve")</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success, 1 if arguments are invalid, -1 if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlPreviousElementSibling"></a>xmlPreviousElementSibling ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlPreviousElementSibling (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node)<br>
</pre>
<p>Find the closest preceding sibling which is a element. Note that entity references are not expanded.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the current node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the sibling or NULL if no sibling was found.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlReconciliateNs"></a>xmlReconciliateNs ()</h3>
<pre class="programlisting">int xmlReconciliateNs (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> tree)<br>
</pre>
<p>This function checks that all the namespaces declared within the given tree are properly declared. This is needed for example after Copy or Cut and then paste operations. The subtree may still hold pointers to namespace declarations outside the subtree or invalid/masked. As much as possible the function try to reuse the existing namespaces found in the new environment. If not possible the new namespaces are redeclared on @tree at the top of the given subtree.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>tree</tt></i>:</span></td>
<td>a node defining the subtree to reconciliate</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success or -1 in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlRegisterNodeDefault"></a>xmlRegisterNodeDefault ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlRegisterNodeFunc">xmlRegisterNodeFunc</a> xmlRegisterNodeDefault (<a href="libxml2-tree.html#xmlRegisterNodeFunc">xmlRegisterNodeFunc</a> func)<br>
</pre>
<p>DEPRECATED: don't use Registers a callback for node creation</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>func</tt></i>:</span></td>
<td>function pointer to the new RegisterNodeFunc</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the old value of the registration function</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlRemoveProp"></a>xmlRemoveProp ()</h3>
<pre class="programlisting">int xmlRemoveProp (<a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> cur)<br>
</pre>
<p>Unlink and free an <a href="libxml2-SAX.html#attribute">attribute</a> including all children. Note this doesn't work for namespace declarations. The <a href="libxml2-SAX.html#attribute">attribute</a> must have a non-NULL parent pointer.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>an <a href="libxml2-SAX.html#attribute">attribute</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success or -1 if the <a href="libxml2-SAX.html#attribute">attribute</a> was not found or arguments are invalid.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlReplaceNode"></a>xmlReplaceNode ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlReplaceNode (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> old, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Unlink the old node. If @cur is provided, it is unlinked and inserted in place of @old. It is an error if @old has no parent. Unlike xmlAddChild, this function doesn't merge text nodes or delete duplicate attributes. See the notes in <a href="libxml2-tree.html#xmlAddChild">xmlAddChild</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>old</tt></i>:</span></td>
<td>the old node</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>@old or NULL if arguments are invalid or a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveFile"></a>xmlSaveFile ()</h3>
<pre class="programlisting">int xmlSaveFile (const char * filename, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur)<br>
</pre>
<p>Dump an XML document to a file. Will use compression if compiled in and enabled. If @filename is "-" the stdout file is used.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>filename</tt></i>:</span></td>
<td>the filename (or URL)</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of bytes written or -1 in case of failure.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveFileEnc"></a>xmlSaveFileEnc ()</h3>
<pre class="programlisting">int xmlSaveFileEnc (const char * filename, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> const char * encoding)<br>
</pre>
<p>Dump an XML document, converting it to the given encoding</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>filename</tt></i>:</span></td>
<td>the filename (or URL)</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>encoding</tt></i>:</span></td>
<td>the name of an encoding (or NULL)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of bytes written or -1 in case of failure.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveFileTo"></a>xmlSaveFileTo ()</h3>
<pre class="programlisting">int xmlSaveFileTo (<a href="libxml2-tree.html#xmlOutputBufferPtr">xmlOutputBufferPtr</a> buf, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> const char * encoding)<br>
</pre>
<p>Dump an XML document to an I/O buffer. Warning ! This call xmlOutputBufferClose() on buf which is not available after this call.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>an output I/O buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>encoding</tt></i>:</span></td>
<td>the encoding if any assuming the I/O layer handles the transcoding</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of bytes written or -1 in case of failure.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveFormatFile"></a>xmlSaveFormatFile ()</h3>
<pre class="programlisting">int xmlSaveFormatFile (const char * filename, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> int format)<br>
</pre>
<p>Dump an XML document to a file. Will use compression if compiled in and enabled. If @filename is "-" the stdout file is used. If @format is set then the document will be indented on output. Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was called</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>filename</tt></i>:</span></td>
<td>the filename (or URL)</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>format</tt></i>:</span></td>
<td>should formatting spaces been added</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of bytes written or -1 in case of failure.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveFormatFileEnc"></a>xmlSaveFormatFileEnc ()</h3>
<pre class="programlisting">int xmlSaveFormatFileEnc (const char * filename, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> const char * encoding, <br> int format)<br>
</pre>
<p>Dump an XML document to a file or an URL.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>filename</tt></i>:</span></td>
<td>the filename or URL to output</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the document being saved</td>
</tr>
<tr>
<td><span class="term"><i><tt>encoding</tt></i>:</span></td>
<td>the name of the encoding to use or NULL.</td>
</tr>
<tr>
<td><span class="term"><i><tt>format</tt></i>:</span></td>
<td>should formatting spaces be added.</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of bytes written or -1 in case of error. Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was called</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveFormatFileTo"></a>xmlSaveFormatFileTo ()</h3>
<pre class="programlisting">int xmlSaveFormatFileTo (<a href="libxml2-tree.html#xmlOutputBufferPtr">xmlOutputBufferPtr</a> buf, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> cur, <br> const char * encoding, <br> int format)<br>
</pre>
<p>Dump an XML document to an I/O buffer. Warning ! This call xmlOutputBufferClose() on buf which is not available after this call.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buf</tt></i>:</span></td>
<td>an output I/O buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>encoding</tt></i>:</span></td>
<td>the encoding if any assuming the I/O layer handles the transcoding</td>
</tr>
<tr>
<td><span class="term"><i><tt>format</tt></i>:</span></td>
<td>should formatting spaces been added</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of bytes written or -1 in case of failure.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSearchNs"></a>xmlSearchNs ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> xmlSearchNs (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * nameSpace)<br>
</pre>
<p>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. We don't allow to cross entities boundaries. If you don't declare the namespace within those you will be in troubles !!! A warning is generated to cover this case.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the current node</td>
</tr>
<tr>
<td><span class="term"><i><tt>nameSpace</tt></i>:</span></td>
<td>the namespace prefix</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the namespace pointer or NULL if no namespace was found or a memory allocation failed. Allocations can only fail if the "xml" namespace is queried.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSearchNsByHref"></a>xmlSearchNsByHref ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> xmlSearchNsByHref (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * href)<br>
</pre>
<p>Search a Ns aliasing a given URI. Recurse on the parents until it finds the defined namespace or return NULL otherwise.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the current node</td>
</tr>
<tr>
<td><span class="term"><i><tt>href</tt></i>:</span></td>
<td>the namespace value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the namespace pointer or NULL if no namespace was found or a memory allocation failed. Allocations can only fail if the "xml" namespace is queried.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSetBufferAllocationScheme"></a>xmlSetBufferAllocationScheme ()</h3>
<pre class="programlisting">void xmlSetBufferAllocationScheme (<a href="libxml2-tree.html#xmlBufferAllocationScheme">xmlBufferAllocationScheme</a> scheme)<br>
</pre>
<p>Set the buffer allocation method. Types are <a href="libxml2-tree.html#XML_BUFFER_ALLOC_EXACT">XML_BUFFER_ALLOC_EXACT</a> - use exact sizes, keeps memory usage down <a href="libxml2-tree.html#XML_BUFFER_ALLOC_DOUBLEIT">XML_BUFFER_ALLOC_DOUBLEIT</a> - double buffer when extra needed, improves performance</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>scheme</tt></i>:</span></td>
<td>allocation method to use</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSetCompressMode"></a>xmlSetCompressMode ()</h3>
<pre class="programlisting">void xmlSetCompressMode (int mode)<br>
</pre>
<p>DEPRECATED: Use <a href="libxml2-tree.html#xmlSetDocCompressMode">xmlSetDocCompressMode</a> set the default compression mode used, ZLIB based Correct values: 0 (uncompressed) to 9 (max compression)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>mode</tt></i>:</span></td>
<td>the compression ratio</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSetDocCompressMode"></a>xmlSetDocCompressMode ()</h3>
<pre class="programlisting">void xmlSetDocCompressMode (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc, <br> int mode)<br>
</pre>
<p>set the compression ratio for a document, ZLIB based Correct values: 0 (uncompressed) to 9 (max compression)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>mode</tt></i>:</span></td>
<td>the compression ratio</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSetListDoc"></a>xmlSetListDoc ()</h3>
<pre class="programlisting">int xmlSetListDoc (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> list, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc)<br>
</pre>
<p>Associate all subtrees in @list with a new document. Internal function, see <a href="libxml2-tree.html#xmlSetTreeDoc">xmlSetTreeDoc</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>list</tt></i>:</span></td>
<td>a node list</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>new document</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success. If a memory allocation fails, returns -1. All subtrees will be updated on failure but some strings may be lost.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSetNs"></a>xmlSetNs ()</h3>
<pre class="programlisting">void xmlSetNs (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns)<br>
</pre>
<p>Set the namespace of an element or <a href="libxml2-SAX.html#attribute">attribute</a> node. Passing a NULL namespace unsets the namespace.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>a node in the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>a namespace pointer (optional)</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSetNsProp"></a>xmlSetNsProp ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> xmlSetNsProp (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value)<br>
</pre>
<p>Set (or reset) an <a href="libxml2-SAX.html#attribute">attribute</a> carried by a node. The ns structure must be in scope, this is not checked</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>the namespace definition</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> name</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> pointer.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSetProp"></a>xmlSetProp ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlAttrPtr">xmlAttrPtr</a> xmlSetProp (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value)<br>
</pre>
<p>Set (or reset) an <a href="libxml2-SAX.html#attribute">attribute</a> carried by a node. If @name has a prefix, then the corresponding namespace-binding will be used, if in scope; it is an error it there's no such ns-binding for the prefix in scope.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> name (a QName)</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> pointer.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSetTreeDoc"></a>xmlSetTreeDoc ()</h3>
<pre class="programlisting">int xmlSetTreeDoc (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> tree, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc)<br>
</pre>
<p>This is an internal function which shouldn't be used. It is invoked by functions like xmlAddChild, <a href="libxml2-tree.html#xmlAddSibling">xmlAddSibling</a> or <a href="libxml2-tree.html#xmlReplaceNode">xmlReplaceNode</a>. @tree must be the root node of an unlinked subtree. Associate all nodes in a tree with a new document. Also copy strings from the old document's dictionary and remove ID attributes from the old ID table.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>tree</tt></i>:</span></td>
<td>root of a subtree</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>new document</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 on success. If a memory allocation fails, returns -1. The whole tree will be updated on failure but some strings may be lost.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSplitQName2"></a>xmlSplitQName2 ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlSplitQName2 (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** prefix)<br>
</pre>
<p>DEPRECATED: This function doesn't report malloc failures. parse an XML qualified name string [NS 5] QName ::= (Prefix ':')? LocalPart [NS 6] Prefix ::= NCName [NS 7] LocalPart ::= NCName</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the full QName</td>
</tr>
<tr>
<td><span class="term"><i><tt>prefix</tt></i>:</span></td>
<td>a <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> **</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>NULL if the name doesn't have a prefix. Otherwise, returns the local part, and prefix is updated to get the Prefix. Both the return value and the prefix must be freed by the caller.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSplitQName3"></a>xmlSplitQName3 ()</h3>
<pre class="programlisting">const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlSplitQName3 (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> int * len)<br>
</pre>
<p>parse an XML qualified name string,i</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the full QName</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>an int *</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>NULL if it is not a Qualified Name, otherwise, update len with the length in byte of the prefix and return a pointer to the start of the name without the prefix</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlStringGetNodeList"></a>xmlStringGetNodeList ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlStringGetNodeList (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value)<br>
</pre>
<p>DEPRECATED: Use <a href="libxml2-tree.html#xmlNodeSetContent">xmlNodeSetContent</a>. Parse an <a href="libxml2-SAX.html#attribute">attribute</a> value and build a node list containing only text and entity <a href="libxml2-SAX.html#reference">reference</a> nodes. The resulting nodes will be associated with the document if provided. The document is also used to look up entities. The input is not validated. Syntax errors or references to undeclared entities will be ignored silently with unspecified results.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>a document (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>an <a href="libxml2-SAX.html#attribute">attribute</a> value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the first child or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlStringLenGetNodeList"></a>xmlStringLenGetNodeList ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlStringLenGetNodeList (const <a href="libxml2-tree.html#xmlDoc">xmlDoc</a> * doc, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> int len)<br>
</pre>
<p>DEPRECATED: Use <a href="libxml2-tree.html#xmlNodeSetContentLen">xmlNodeSetContentLen</a>. See <a href="libxml2-tree.html#xmlStringGetNodeList">xmlStringGetNodeList</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>a document (optional)</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>an <a href="libxml2-SAX.html#attribute">attribute</a> value</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>maximum length of the <a href="libxml2-SAX.html#attribute">attribute</a> value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the first child or NULL if a memory allocation failed.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlTextConcat"></a>xmlTextConcat ()</h3>
<pre class="programlisting">int xmlTextConcat (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * content, <br> int len)<br>
</pre>
<p>Concat the given string at the end of the existing node content. If @len is -1, the string length will be calculated.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>content</tt></i>:</span></td>
<td>the content</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>@content length</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>-1 in case of error, 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlTextMerge"></a>xmlTextMerge ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlTextMerge (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> first, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> second)<br>
</pre>
<p>Merge the second text node into the first. The second node is unlinked and freed.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>first</tt></i>:</span></td>
<td>the first text node</td>
</tr>
<tr>
<td><span class="term"><i><tt>second</tt></i>:</span></td>
<td>the second text node being merged</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the first text node augmented or NULL in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlThrDefBufferAllocScheme"></a>xmlThrDefBufferAllocScheme ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlBufferAllocationScheme">xmlBufferAllocationScheme</a> xmlThrDefBufferAllocScheme (<a href="libxml2-tree.html#xmlBufferAllocationScheme">xmlBufferAllocationScheme</a> v)<br>
</pre>
<p></p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>v</tt></i>:</span></td>
<td></td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td></td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlThrDefDefaultBufferSize"></a>xmlThrDefDefaultBufferSize ()</h3>
<pre class="programlisting">int xmlThrDefDefaultBufferSize (int v)<br>
</pre>
<p></p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>v</tt></i>:</span></td>
<td></td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td></td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlThrDefDeregisterNodeDefault"></a>xmlThrDefDeregisterNodeDefault ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlDeregisterNodeFunc">xmlDeregisterNodeFunc</a> xmlThrDefDeregisterNodeDefault (<a href="libxml2-tree.html#xmlDeregisterNodeFunc">xmlDeregisterNodeFunc</a> func)<br>
</pre>
<p></p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>func</tt></i>:</span></td>
<td></td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td></td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlThrDefRegisterNodeDefault"></a>xmlThrDefRegisterNodeDefault ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlRegisterNodeFunc">xmlRegisterNodeFunc</a> xmlThrDefRegisterNodeDefault (<a href="libxml2-tree.html#xmlRegisterNodeFunc">xmlRegisterNodeFunc</a> func)<br>
</pre>
<p></p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>func</tt></i>:</span></td>
<td></td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td></td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUnlinkNode"></a>xmlUnlinkNode ()</h3>
<pre class="programlisting">void xmlUnlinkNode (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Unlink a node from its tree. The node is not freed. Unless it is reinserted, it must be managed manually and freed eventually by calling <a href="libxml2-tree.html#xmlFreeNode">xmlFreeNode</a>.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUnsetNsProp"></a>xmlUnsetNsProp ()</h3>
<pre class="programlisting">int xmlUnsetNsProp (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Remove an <a href="libxml2-SAX.html#attribute">attribute</a> carried by a node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>the namespace definition</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if successful, -1 if not found</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUnsetProp"></a>xmlUnsetProp ()</h3>
<pre class="programlisting">int xmlUnsetProp (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Remove an <a href="libxml2-SAX.html#attribute">attribute</a> carried by a node. This handles only attributes in no namespace.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if successful, -1 if not found</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlValidateNCName"></a>xmlValidateNCName ()</h3>
<pre class="programlisting">int xmlValidateNCName (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> int space)<br>
</pre>
<p>Check that a value conforms to the lexical space of NCName</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the value to check</td>
</tr>
<tr>
<td><span class="term"><i><tt>space</tt></i>:</span></td>
<td>allow spaces in front and end of the string</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if this validates, a positive error code number otherwise and -1 in case of internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlValidateNMToken"></a>xmlValidateNMToken ()</h3>
<pre class="programlisting">int xmlValidateNMToken (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> int space)<br>
</pre>
<p>Check that a value conforms to the lexical space of NMToken</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the value to check</td>
</tr>
<tr>
<td><span class="term"><i><tt>space</tt></i>:</span></td>
<td>allow spaces in front and end of the string</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if this validates, a positive error code number otherwise and -1 in case of internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlValidateName"></a>xmlValidateName ()</h3>
<pre class="programlisting">int xmlValidateName (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> int space)<br>
</pre>
<p>Check that a value conforms to the lexical space of Name</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the value to check</td>
</tr>
<tr>
<td><span class="term"><i><tt>space</tt></i>:</span></td>
<td>allow spaces in front and end of the string</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if this validates, a positive error code number otherwise and -1 in case of internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlValidateQName"></a>xmlValidateQName ()</h3>
<pre class="programlisting">int xmlValidateQName (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> int space)<br>
</pre>
<p>Check that a value conforms to the lexical space of QName</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the value to check</td>
</tr>
<tr>
<td><span class="term"><i><tt>space</tt></i>:</span></td>
<td>allow spaces in front and end of the string</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if this validates, a positive error code number otherwise and -1 in case of internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
</div>
</div>
</body>
</html>
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists