Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/tree.c

 /*
  * tree.c : implementation of access function for an XML tree.
  *
  * References:
  *   XHTML 1.0 W3C REC: http://www.w3.org/TR/2002/REC-xhtml1-20020801/
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  *
@@ skipping 23 matching lines @@
 #include <libxml/xmlerror.h>
 #include <libxml/parserInternals.h>
 #include <libxml/globals.h>
 #ifdef LIBXML_HTML_ENABLED
 #include <libxml/HTMLtree.h>
 #endif
 #ifdef LIBXML_DEBUG_ENABLED
 #include <libxml/debugXML.h>
 #endif
 
+#include "buf.h"
+#include "save.h"
+
 int __xmlRegisterCallbacks = 0;
 
 /************************************************************************
  *                                                                      *
  *              Forward declarations                                    *
  *                                                                      *
  ************************************************************************/
 
 static xmlNsPtr
 xmlNewReconciliedNs(xmlDocPtr doc, xmlNodePtr tree, xmlNsPtr ns);
 
-static xmlChar* xmlGetPropNodeValueInternal(xmlAttrPtr prop);
+static xmlChar* xmlGetPropNodeValueInternal(const xmlAttr *prop);
 
 /************************************************************************
  *                                                                      *
  *              Tree memory error handler                               *
  *                                                                      *
  ************************************************************************/
 /**
  * xmlTreeErrMemory:
  * @extra:  extra informations
  *
@@ skipping 84 matching lines @@
  * xmlGetEntityFromDtd:
  * @dtd:  A pointer to the DTD to search
  * @name:  The entity name
  *
  * Do an entity lookup in the DTD entity hash table and
  * return the corresponding entity, if found.
  *
  * Returns A pointer to the entity structure or NULL if not found.
  */
 static xmlEntityPtr
-xmlGetEntityFromDtd(xmlDtdPtr dtd, const xmlChar *name) {
+xmlGetEntityFromDtd(const xmlDtd *dtd, const xmlChar *name) {
     xmlEntitiesTablePtr table;
 
     if((dtd != NULL) && (dtd->entities != NULL)) {
         table = (xmlEntitiesTablePtr) dtd->entities;
         return((xmlEntityPtr) xmlHashLookup(table, name));
         /* return(xmlGetEntityFromTable(table, name)); */
     }
     return(NULL);
 }
 /**
  * xmlGetParameterEntityFromDtd:
  * @dtd:  A pointer to the DTD to search
  * @name:  The entity name
  *
  * Do an entity lookup in the DTD pararmeter entity hash table and
  * return the corresponding entity, if found.
  *
  * Returns A pointer to the entity structure or NULL if not found.
  */
 static xmlEntityPtr
-xmlGetParameterEntityFromDtd(xmlDtdPtr dtd, const xmlChar *name) {
+xmlGetParameterEntityFromDtd(const xmlDtd *dtd, const xmlChar *name) {
     xmlEntitiesTablePtr table;
 
     if ((dtd != NULL) && (dtd->pentities != NULL)) {
         table = (xmlEntitiesTablePtr) dtd->pentities;
         return((xmlEntityPtr) xmlHashLookup(table, name));
         /* return(xmlGetEntityFromTable(table, name)); */
     }
     return(NULL);
 }
 #endif /* LIBXML_TREE_ENABLED */
@@ skipping 112 matching lines @@
 }
 
 /**
  * xmlSplitQName3:
  * @name:  the full QName
  * @len: an int *
  *
  * parse an XML qualified name string,i
  *
  * returns NULL if it is not a Qualified Name, otherwise, update len
- *         with the lenght in byte of the prefix and return a pointer
+ *         with the length in byte of the prefix and return a pointer
  *         to the start of the name without the prefix
  */
 
 const xmlChar *
 xmlSplitQName3(const xmlChar *name, int *len) {
     int l = 0;
 
     if (name == NULL) return(NULL);
     if (len == NULL) return(NULL);
 
@@ skipping 17 matching lines @@
 }
 
 /************************************************************************
  *                                                                      *
  *              Check Name, NCName and QName strings                    *
  *                                                                      *
  ************************************************************************/
 
 #define CUR_SCHAR(s, l) xmlStringCurrentChar(NULL, s, &l)
 
-#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
 /**
  * xmlValidateNCName:
  * @value: the value to check
  * @space: allow spaces in front and end of the string
  *
  * Check that a value conforms to the lexical space of NCName
  *
  * Returns 0 if this validates, a positive error code number otherwise
  *         and -1 in case of internal or API error.
  */
@@ skipping 312 matching lines @@
  * @scheme:  allocation method to use
  *
  * Set the buffer allocation method.  Types are
  * XML_BUFFER_ALLOC_EXACT - use exact sizes, keeps memory usage down
  * XML_BUFFER_ALLOC_DOUBLEIT - double buffer when extra needed,
  *                             improves performance
  */
 void
 xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme) {
     if ((scheme == XML_BUFFER_ALLOC_EXACT) ||
-        (scheme == XML_BUFFER_ALLOC_DOUBLEIT))
+        (scheme == XML_BUFFER_ALLOC_DOUBLEIT) ||
+        (scheme == XML_BUFFER_ALLOC_HYBRID))
         xmlBufferAllocScheme = scheme;
 }
 
 /**
  * xmlGetBufferAllocationScheme:
  *
  * Types are
  * XML_BUFFER_ALLOC_EXACT - use exact sizes, keeps memory usage down
  * XML_BUFFER_ALLOC_DOUBLEIT - double buffer when extra needed,
  *                             improves performance
+ * XML_BUFFER_ALLOC_HYBRID - use exact sizes on small strings to keep memory usage tight
+ *                            in normal usage, and doubleit on large strings to avoid
+ *                            pathological performance.
  *
  * Returns the current allocation scheme
  */
 xmlBufferAllocationScheme
 xmlGetBufferAllocationScheme(void) {
     return(xmlBufferAllocScheme);
 }
 
 /**
  * xmlNewNs:
  * @node:  the element carrying the namespace
  * @href:  the URI associated
  * @prefix:  the prefix for the namespace
  *
  * Creation of a new Namespace. This function will refuse to create
  * a namespace with a similar prefix than an existing one present on this
  * node.
+ * Note that for a default namespace, @prefix should be NULL.
+ *
  * We use href==NULL in the case of an element creation where the namespace
  * was not defined.
+ *
  * Returns a new namespace pointer or NULL
  */
 xmlNsPtr
 xmlNewNs(xmlNodePtr node, const xmlChar *href, const xmlChar *prefix) {
     xmlNsPtr cur;
 
     if ((node != NULL) && (node->type != XML_ELEMENT_NODE))
         return(NULL);
 
-    if ((prefix != NULL) && (xmlStrEqual(prefix, BAD_CAST "xml")))
-        return(NULL);
+    if ((prefix != NULL) && (xmlStrEqual(prefix, BAD_CAST "xml"))) {
+        /* xml namespace is predefined, no need to add it */
+        if (xmlStrEqual(href, XML_XML_NAMESPACE))
+            return(NULL);
+
+        /*
+         * Problem, this is an attempt to bind xml prefix to a wrong
+         * namespace, which breaks
+         * Namespace constraint: Reserved Prefixes and Namespace Names
+         * from XML namespace. But documents authors may not care in
+         * their context so let's proceed.
+         */
+    }
 
     /*
      * Allocate a new Namespace and fill the fields.
      */
     cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
     if (cur == NULL) {
         xmlTreeErrMemory("building namespace");
         return(NULL);
     }
     memset(cur, 0, sizeof(xmlNs));
@@ skipping 42 matching lines @@
  */
 void
 xmlSetNs(xmlNodePtr node, xmlNsPtr ns) {
     if (node == NULL) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlSetNs: node == NULL\n");
 #endif
         return;
     }
-    node->ns = ns;
+    if ((node->type == XML_ELEMENT_NODE) ||
+        (node->type == XML_ATTRIBUTE_NODE))
+        node->ns = ns;
 }
 
 /**
  * xmlFreeNs:
  * @cur:  the namespace pointer
  *
  * Free up the structures associated to a namespace
  */
 void
 xmlFreeNs(xmlNsPtr cur) {
@@ skipping 87 matching lines @@
 
 /**
  * xmlGetIntSubset:
  * @doc:  the document pointer
  *
  * Get the internal subset of a document
  * Returns a pointer to the DTD structure or NULL if not found
  */
 
 xmlDtdPtr
-xmlGetIntSubset(xmlDocPtr doc) {
+xmlGetIntSubset(const xmlDoc *doc) {
     xmlNodePtr cur;
 
     if (doc == NULL)
         return(NULL);
     cur = doc->children;
     while (cur != NULL) {
         if (cur->type == XML_DTD_NODE)
             return((xmlDtdPtr) cur);
         cur = cur->next;
     }
@@ skipping 329 matching lines @@
  * xmlStringLenGetNodeList:
  * @doc:  the document
  * @value:  the value of the text
  * @len:  the length of the string value
  *
  * Parse the value string and build the node list associated. Should
  * produce a flat tree with only TEXTs and ENTITY_REFs.
  * Returns a pointer to the first child
  */
 xmlNodePtr
-xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *value, int len) {
+xmlStringLenGetNodeList(const xmlDoc *doc, const xmlChar *value, int len) {
     xmlNodePtr ret = NULL, last = NULL;
     xmlNodePtr node;
     xmlChar *val;
     const xmlChar *cur = value, *end = cur + len;
     const xmlChar *q;
     xmlEntityPtr ent;
+    xmlBufPtr buf;
 
     if (value == NULL) return(NULL);
 
+    buf = xmlBufCreateSize(0);
+    if (buf == NULL) return(NULL);
+    xmlBufSetAllocationScheme(buf, XML_BUFFER_ALLOC_HYBRID);
+
     q = cur;
     while ((cur < end) && (*cur != 0)) {
         if (cur[0] == '&') {
             int charval = 0;
             xmlChar tmp;
 
             /*
              * Save the current text.
              */
             if (cur != q) {
-                if ((last != NULL) && (last->type == XML_TEXT_NODE)) {
-                    xmlNodeAddContentLen(last, q, cur - q);
-                } else {
-                    node = xmlNewDocTextLen(doc, q, cur - q);
-                    if (node == NULL) return(ret);
-                    if (last == NULL)
-                        last = ret = node;
-                    else {
-                        last->next = node;
-                        node->prev = last;
-                        last = node;
-                    }
-                }
+                if (xmlBufAdd(buf, q, cur - q))
+                    goto out;
             }
             q = cur;
             if ((cur + 2 < end) && (cur[1] == '#') && (cur[2] == 'x')) {
                 cur += 3;
                 if (cur < end)
                     tmp = *cur;
                 else
                     tmp = 0;
                 while (tmp != ';') { /* Non input consuming loop */
                     if ((tmp >= '0') && (tmp <= '9'))
@@ skipping 44 matching lines @@
             } else {
                 /*
                  * Read the entity string
                  */
                 cur++;
                 q = cur;
                 while ((cur < end) && (*cur != 0) && (*cur != ';')) cur++;
                 if ((cur >= end) || (*cur == 0)) {
                     xmlTreeErr(XML_TREE_UNTERMINATED_ENTITY, (xmlNodePtr) doc,
                                (const char *) q);
-                    return(ret);
+                    goto out;
                 }
                 if (cur != q) {
                     /*
                      * Predefined entities don't generate nodes
                      */
                     val = xmlStrndup(q, cur - q);
                     ent = xmlGetDocEntity(doc, val);
                     if ((ent != NULL) &&
                         (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
-                        if (last == NULL) {
-                            node = xmlNewDocText(doc, ent->content);
-                            last = ret = node;
-                        } else if (last->type != XML_TEXT_NODE) {
-                            node = xmlNewDocText(doc, ent->content);
-                            last = xmlAddNextSibling(last, node);
-                        } else
-                            xmlNodeAddContent(last, ent->content);
+
+                        if (xmlBufCat(buf, ent->content))
+                            goto out;
 
                     } else {
                         /*
+                         * Flush buffer so far
+                         */
+                        if (!xmlBufIsEmpty(buf)) {
+                            node = xmlNewDocText(doc, NULL);
+                            if (node == NULL) {
+                                if (val != NULL) xmlFree(val);
+                                goto out;
+                            }
+                            node->content = xmlBufDetach(buf);
+
+                            if (last == NULL) {
+                                last = ret = node;
+                            } else {
+                                last = xmlAddNextSibling(last, node);
+                            }
+                        }
+
+                        /*
                          * Create a new REFERENCE_REF node
                          */
                         node = xmlNewReference(doc, val);
                         if (node == NULL) {
                             if (val != NULL) xmlFree(val);
-                            return(ret);
+                            goto out;
                         }
                         else if ((ent != NULL) && (ent->children == NULL)) {
                             xmlNodePtr temp;
 
                             ent->children = xmlStringGetNodeList(doc,
                                     (const xmlChar*)node->content);
                             ent->owner = 1;
                             temp = ent->children;
                             while (temp) {
                                 temp->parent = (xmlNodePtr)ent;
                                 ent->last = temp;
                                 temp = temp->next;
                             }
                         }
                         if (last == NULL) {
                             last = ret = node;
                         } else {
                             last = xmlAddNextSibling(last, node);
                         }
                     }
                     xmlFree(val);
                 }
                 cur++;
                 q = cur;
             }
             if (charval != 0) {
-                xmlChar buf[10];
+                xmlChar buffer[10];
                 int l;
 
-                l = xmlCopyCharMultiByte(buf, charval);
-                buf[l] = 0;
-                node = xmlNewDocText(doc, buf);
-                if (node != NULL) {
-                    if (last == NULL) {
-                        last = ret = node;
-                    } else {
-                        last = xmlAddNextSibling(last, node);
-                    }
-                }
+                l = xmlCopyCharMultiByte(buffer, charval);
+                buffer[l] = 0;
+
+                if (xmlBufCat(buf, buffer))
+                    goto out;
                 charval = 0;
             }
         } else
             cur++;
     }
-    if ((cur != q) || (ret == NULL)) {
+
+    if (cur != q) {
         /*
          * Handle the last piece of text.
          */
-        if ((last != NULL) && (last->type == XML_TEXT_NODE)) {
-            xmlNodeAddContentLen(last, q, cur - q);
+        if (xmlBufAdd(buf, q, cur - q))
+            goto out;
+    }
+
+    if (!xmlBufIsEmpty(buf)) {
+        node = xmlNewDocText(doc, NULL);
+        if (node == NULL) goto out;
+        node->content = xmlBufDetach(buf);
+
+        if (last == NULL) {
+            last = ret = node;
         } else {
-            node = xmlNewDocTextLen(doc, q, cur - q);
-            if (node == NULL) return(ret);
-            if (last == NULL) {
-                ret = node;
-            } else {
-                xmlAddNextSibling(last, node);
-            }
+            last = xmlAddNextSibling(last, node);
         }
+    } else if (ret == NULL) {
+        ret = xmlNewDocText(doc, BAD_CAST "");
     }
+
+out:
+    xmlBufFree(buf);
     return(ret);
 }
 
 /**
  * xmlStringGetNodeList:
  * @doc:  the document
  * @value:  the value of the attribute
  *
  * Parse the value string and build the node list associated. Should
  * produce a flat tree with only TEXTs and ENTITY_REFs.
  * Returns a pointer to the first child
  */
 xmlNodePtr
-xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *value) {
+xmlStringGetNodeList(const xmlDoc *doc, const xmlChar *value) {
     xmlNodePtr ret = NULL, last = NULL;
     xmlNodePtr node;
     xmlChar *val;
     const xmlChar *cur = value;
     const xmlChar *q;
     xmlEntityPtr ent;
+    xmlBufPtr buf;
 
     if (value == NULL) return(NULL);
 
+    buf = xmlBufCreateSize(0);
+    if (buf == NULL) return(NULL);
+    xmlBufSetAllocationScheme(buf, XML_BUFFER_ALLOC_HYBRID);
+
     q = cur;
     while (*cur != 0) {
         if (cur[0] == '&') {
             int charval = 0;
             xmlChar tmp;
 
             /*
              * Save the current text.
              */
             if (cur != q) {
-                if ((last != NULL) && (last->type == XML_TEXT_NODE)) {
-                    xmlNodeAddContentLen(last, q, cur - q);
-                } else {
-                    node = xmlNewDocTextLen(doc, q, cur - q);
-                    if (node == NULL) return(ret);
-                    if (last == NULL)
-                        last = ret = node;
-                    else {
-                        last->next = node;
-                        node->prev = last;
-                        last = node;
-                    }
-                }
+                if (xmlBufAdd(buf, q, cur - q))
+                    goto out;
             }
             q = cur;
             if ((cur[1] == '#') && (cur[2] == 'x')) {
                 cur += 3;
                 tmp = *cur;
                 while (tmp != ';') { /* Non input consuming loop */
                     if ((tmp >= '0') && (tmp <= '9'))
                         charval = charval * 16 + (tmp - '0');
                     else if ((tmp >= 'a') && (tmp <= 'f'))
                         charval = charval * 16 + (tmp - 'a') + 10;
@@ skipping 32 matching lines @@
             } else {
                 /*
                  * Read the entity string
                  */
                 cur++;
                 q = cur;
                 while ((*cur != 0) && (*cur != ';')) cur++;
                 if (*cur == 0) {
                     xmlTreeErr(XML_TREE_UNTERMINATED_ENTITY,
                                (xmlNodePtr) doc, (const char *) q);
-                    return(ret);
+                    goto out;
                 }
                 if (cur != q) {
                     /*
                      * Predefined entities don't generate nodes
                      */
                     val = xmlStrndup(q, cur - q);
                     ent = xmlGetDocEntity(doc, val);
                     if ((ent != NULL) &&
                         (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
-                        if (last == NULL) {
-                            node = xmlNewDocText(doc, ent->content);
-                            last = ret = node;
-                        } else if (last->type != XML_TEXT_NODE) {
-                            node = xmlNewDocText(doc, ent->content);
-                            last = xmlAddNextSibling(last, node);
-                        } else
-                            xmlNodeAddContent(last, ent->content);
+
+                        if (xmlBufCat(buf, ent->content))
+                            goto out;
 
                     } else {
                         /*
+                         * Flush buffer so far
+                         */
+                        if (!xmlBufIsEmpty(buf)) {
+                            node = xmlNewDocText(doc, NULL);
+                            node->content = xmlBufDetach(buf);
+
+                            if (last == NULL) {
+                                last = ret = node;
+                            } else {
+                                last = xmlAddNextSibling(last, node);
+                            }
+                        }
+
+                        /*
                          * Create a new REFERENCE_REF node
                          */
                         node = xmlNewReference(doc, val);
                         if (node == NULL) {
                             if (val != NULL) xmlFree(val);
-                            return(ret);
+                            goto out;
                         }
                         else if ((ent != NULL) && (ent->children == NULL)) {
                             xmlNodePtr temp;
 
                             ent->children = xmlStringGetNodeList(doc,
                                     (const xmlChar*)node->content);
                             ent->owner = 1;
                             temp = ent->children;
                             while (temp) {
                                 temp->parent = (xmlNodePtr)ent;
                                 temp = temp->next;
                             }
                         }
                         if (last == NULL) {
                             last = ret = node;
                         } else {
                             last = xmlAddNextSibling(last, node);
                         }
                     }
                     xmlFree(val);
                 }
                 cur++;
                 q = cur;
             }
             if (charval != 0) {
-                xmlChar buf[10];
+                xmlChar buffer[10];
                 int len;
 
-                len = xmlCopyCharMultiByte(buf, charval);
-                buf[len] = 0;
-                node = xmlNewDocText(doc, buf);
-                if (node != NULL) {
-                    if (last == NULL) {
-                        last = ret = node;
-                    } else {
-                        last = xmlAddNextSibling(last, node);
-                    }
-                }
+                len = xmlCopyCharMultiByte(buffer, charval);
+                buffer[len] = 0;
+
+                if (xmlBufCat(buf, buffer))
+                    goto out;
+                charval = 0;
             }
         } else
             cur++;
     }
     if ((cur != q) || (ret == NULL)) {
         /*
          * Handle the last piece of text.
          */
-        if ((last != NULL) && (last->type == XML_TEXT_NODE)) {
-            xmlNodeAddContentLen(last, q, cur - q);
+        xmlBufAdd(buf, q, cur - q);
+    }
+
+    if (!xmlBufIsEmpty(buf)) {
+        node = xmlNewDocText(doc, NULL);
+        node->content = xmlBufDetach(buf);
+
+        if (last == NULL) {
+            last = ret = node;
         } else {
-            node = xmlNewDocTextLen(doc, q, cur - q);
-            if (node == NULL) return(ret);
-            if (last == NULL) {
-                last = ret = node;
-            } else {
-                last = xmlAddNextSibling(last, node);
-            }
+            last = xmlAddNextSibling(last, node);
         }
     }
+
+out:
+    xmlBufFree(buf);
     return(ret);
 }
 
 /**
  * xmlNodeListGetString:
  * @doc:  the document
  * @list:  a Node list
  * @inLine:  should we replace entity contents or show their external form
  *
  * Build the string equivalent to the text contained in the Node list
  * made of TEXTs and ENTITY_REFs
  *
  * Returns a pointer to the string copy, the caller must free it with xmlFree().
  */
 xmlChar *
-xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine)
+xmlNodeListGetString(xmlDocPtr doc, const xmlNode *list, int inLine)
 {
-    xmlNodePtr node = list;
+    const xmlNode *node = list;
     xmlChar *ret = NULL;
     xmlEntityPtr ent;
+    int attr;
 
     if (list == NULL)
         return (NULL);
+    if ((list->parent != NULL) && (list->parent->type == XML_ATTRIBUTE_NODE))
+        attr = 1;
+    else
+        attr = 0;
 
     while (node != NULL) {
         if ((node->type == XML_TEXT_NODE) ||
             (node->type == XML_CDATA_SECTION_NODE)) {
             if (inLine) {
                 ret = xmlStrcat(ret, node->content);
             } else {
                 xmlChar *buffer;
 
-                buffer = xmlEncodeEntitiesReentrant(doc, node->content);
+                if (attr)
+                    buffer = xmlEncodeAttributeEntities(doc, node->content);
+                else
+                    buffer = xmlEncodeEntitiesReentrant(doc, node->content);
                 if (buffer != NULL) {
                     ret = xmlStrcat(ret, buffer);
                     xmlFree(buffer);
                 }
             }
         } else if (node->type == XML_ENTITY_REF_NODE) {
             if (inLine) {
                 ent = xmlGetDocEntity(doc, node->name);
                 if (ent != NULL) {
                     xmlChar *buffer;
@@ skipping 44 matching lines @@
  * @list:  a Node list
  * @inLine:  should we replace entity contents or show their external form
  *
  * Builds the string equivalent to the text contained in the Node list
  * made of TEXTs and ENTITY_REFs, contrary to xmlNodeListGetString()
  * this function doesn't do any character encoding handling.
  *
  * Returns a pointer to the string copy, the caller must free it with xmlFree().
  */
 xmlChar *
-xmlNodeListGetRawString(xmlDocPtr doc, xmlNodePtr list, int inLine)
+xmlNodeListGetRawString(const xmlDoc *doc, const xmlNode *list, int inLine)
 {
-    xmlNodePtr node = list;
+    const xmlNode *node = list;
     xmlChar *ret = NULL;
     xmlEntityPtr ent;
 
     if (list == NULL)
         return (NULL);
 
     while (node != NULL) {
         if ((node->type == XML_TEXT_NODE) ||
             (node->type == XML_CDATA_SECTION_NODE)) {
             if (inLine) {
@@ skipping 808 matching lines @@
 
 /**
  * xmlNewReference:
  * @doc: the document
  * @name:  the reference name, or the reference string with & and ;
  *
  * Creation of a new reference node.
  * Returns a pointer to the new node object.
  */
 xmlNodePtr
-xmlNewReference(xmlDocPtr doc, const xmlChar *name) {
+xmlNewReference(const xmlDoc *doc, const xmlChar *name) {
     xmlNodePtr cur;
     xmlEntityPtr ent;
 
     if (name == NULL)
         return(NULL);
 
     /*
      * Allocate a new node and fill the fields.
      */
     cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
     if (cur == NULL) {
         xmlTreeErrMemory("building reference");
         return(NULL);
     }
     memset(cur, 0, sizeof(xmlNode));
     cur->type = XML_ENTITY_REF_NODE;
 
-    cur->doc = doc;
+    cur->doc = (xmlDoc *)doc;
     if (name[0] == '&') {
         int len;
         name++;
         len = xmlStrlen(name);
         if (name[len - 1] == ';')
             cur->name = xmlStrndup(name, len - 1);
         else
             cur->name = xmlStrndup(name, len);
     } else
         cur->name = xmlStrdup(name);
@@ skipping 17 matching lines @@
 
 /**
  * xmlNewDocText:
  * @doc: the document
  * @content:  the text content
  *
  * Creation of a new text node within a document.
  * Returns a pointer to the new node object.
  */
 xmlNodePtr
-xmlNewDocText(xmlDocPtr doc, const xmlChar *content) {
+xmlNewDocText(const xmlDoc *doc, const xmlChar *content) {
     xmlNodePtr cur;
 
     cur = xmlNewText(content);
-    if (cur != NULL) cur->doc = doc;
+    if (cur != NULL) cur->doc = (xmlDoc *)doc;
     return(cur);
 }
 
 /**
  * xmlNewTextLen:
  * @content:  the text content
  * @len:  the text len.
  *
  * Creation of a new text node with an extra parameter for the content's length
  * Returns a pointer to the new node object.
@@ skipping 129 matching lines @@
  * xmlSetTreeDoc:
  * @tree:  the top element
  * @doc:  the document
  *
  * update all nodes under the tree to point to the right document
  */
 void
 xmlSetTreeDoc(xmlNodePtr tree, xmlDocPtr doc) {
     xmlAttrPtr prop;
 
-    if (tree == NULL)
+    if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL))
         return;
     if (tree->doc != doc) {
         if(tree->type == XML_ELEMENT_NODE) {
             prop = tree->properties;
             while (prop != NULL) {
                 prop->doc = doc;
                 xmlSetListDoc(prop->children, doc);
                 prop = prop->next;
             }
         }
         if (tree->children != NULL)
             xmlSetListDoc(tree->children, doc);
         tree->doc = doc;
     }
 }
 
 /**
  * xmlSetListDoc:
  * @list:  the first element
  * @doc:  the document
  *
  * update all nodes in the list to point to the right document
  */
 void
 xmlSetListDoc(xmlNodePtr list, xmlDocPtr doc) {
     xmlNodePtr cur;
 
-    if (list == NULL)
+    if ((list == NULL) || (list->type == XML_NAMESPACE_DECL))
         return;
     cur = list;
     while (cur != NULL) {
         if (cur->doc != doc)
             xmlSetTreeDoc(cur, doc);
         cur = cur->next;
     }
 }
 
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
@@ skipping 86 matching lines @@
  * When inserting before @cur, @prev is passed as @cur->prev.
  * When inserting after @cur, @prev is passed as @cur.
  * If an existing attribute is found it is detroyed prior to adding @prop.
  *
  * Returns the attribute being inserted or NULL in case of error.
  */
 static xmlNodePtr
 xmlAddPropSibling(xmlNodePtr prev, xmlNodePtr cur, xmlNodePtr prop) {
         xmlAttrPtr attr;
 
-        if (cur->type != XML_ATTRIBUTE_NODE)
+        if ((cur == NULL) || (cur->type != XML_ATTRIBUTE_NODE) ||
+            (prop == NULL) || (prop->type != XML_ATTRIBUTE_NODE) ||
+            ((prev != NULL) && (prev->type != XML_ATTRIBUTE_NODE)))
                 return(NULL);
 
         /* check if an attribute with the same name exists */
         if (prop->ns == NULL)
                 attr = xmlHasNsProp(cur->parent, prop->name, NULL);
         else
                 attr = xmlHasNsProp(cur->parent, prop->name, prop->ns->href);
 
         if (prop->doc != cur->doc) {
                 xmlSetTreeDoc(prop, cur->doc);
@@ skipping 27 matching lines @@
  * If the new node was already inserted in a document it is
  * first unlinked from its existing context.
  * As a result of text merging @elem may be freed.
  * If the new node is ATTRIBUTE, it is added into properties instead of children.
  * If there is an attribute with equal name, it is first destroyed.
  *
  * Returns the new node or NULL in case of error.
  */
 xmlNodePtr
 xmlAddNextSibling(xmlNodePtr cur, xmlNodePtr elem) {
-    if (cur == NULL) {
+    if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlAddNextSibling : cur == NULL\n");
 #endif
         return(NULL);
     }
-    if (elem == NULL) {
+    if ((elem == NULL) || (elem->type == XML_NAMESPACE_DECL)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlAddNextSibling : elem == NULL\n");
 #endif
         return(NULL);
     }
 
     if (cur == elem) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
@@ skipping 33 matching lines @@
     elem->next = cur->next;
     cur->next = elem;
     if (elem->next != NULL)
         elem->next->prev = elem;
     if ((elem->parent != NULL) && (elem->parent->last == cur))
         elem->parent->last = elem;
     return(elem);
 }
 
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
-    defined(LIBXML_SCHEMAS_ENABLED)
+    defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
 /**
  * xmlAddPrevSibling:
  * @cur:  the child node
  * @elem:  the new node
  *
  * Add a new node @elem as the previous sibling of @cur
  * merging adjacent TEXT nodes (@elem may be freed)
  * If the new node was already inserted in a document it is
  * first unlinked from its existing context.
  * If the new node is ATTRIBUTE, it is added into properties instead of children.
  * If there is an attribute with equal name, it is first destroyed.
  *
  * Returns the new node or NULL in case of error.
  */
 xmlNodePtr
 xmlAddPrevSibling(xmlNodePtr cur, xmlNodePtr elem) {
-    if (cur == NULL) {
+    if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlAddPrevSibling : cur == NULL\n");
 #endif
         return(NULL);
     }
-    if (elem == NULL) {
+    if ((elem == NULL) || (elem->type == XML_NAMESPACE_DECL)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlAddPrevSibling : elem == NULL\n");
 #endif
         return(NULL);
     }
 
     if (cur == elem) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
@@ skipping 50 matching lines @@
  * merging adjacent TEXT nodes (@elem may be freed)
  * If the new element was already inserted in a document it is
  * first unlinked from its existing context.
  *
  * Returns the new element or NULL in case of error.
  */
 xmlNodePtr
 xmlAddSibling(xmlNodePtr cur, xmlNodePtr elem) {
     xmlNodePtr parent;
 
-    if (cur == NULL) {
+    if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlAddSibling : cur == NULL\n");
 #endif
         return(NULL);
     }
 
-    if (elem == NULL) {
+    if ((elem == NULL) || (elem->type == XML_NAMESPACE_DECL)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlAddSibling : elem == NULL\n");
 #endif
         return(NULL);
     }
 
     if (cur == elem) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
@@ skipping 47 matching lines @@
  *
  * Add a list of node at the end of the child list of the parent
  * merging adjacent TEXT nodes (@cur may be freed)
  *
  * Returns the last child or NULL in case of error.
  */
 xmlNodePtr
 xmlAddChildList(xmlNodePtr parent, xmlNodePtr cur) {
     xmlNodePtr prev;
 
-    if (parent == NULL) {
+    if ((parent == NULL) || (parent->type == XML_NAMESPACE_DECL)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlAddChildList : parent == NULL\n");
 #endif
         return(NULL);
     }
 
-    if (cur == NULL) {
+    if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlAddChildList : child == NULL\n");
 #endif
         return(NULL);
     }
 
     if ((cur->doc != NULL) && (parent->doc != NULL) &&
         (cur->doc != parent->doc)) {
 #ifdef DEBUG_TREE
@@ skipping 57 matching lines @@
  * merging adjacent TEXT nodes (in which case @cur is freed)
  * If the new node is ATTRIBUTE, it is added into properties instead of children.
  * If there is an attribute with equal name, it is first destroyed.
  *
  * Returns the child or NULL in case of error.
  */
 xmlNodePtr
 xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) {
     xmlNodePtr prev;
 
-    if (parent == NULL) {
+    if ((parent == NULL) || (parent->type == XML_NAMESPACE_DECL)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlAddChild : parent == NULL\n");
 #endif
         return(NULL);
     }
 
-    if (cur == NULL) {
+    if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlAddChild : child == NULL\n");
 #endif
         return(NULL);
     }
 
     if (parent == cur) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
@@ skipping 92 matching lines @@
 }
 
 /**
  * xmlGetLastChild:
  * @parent:  the parent node
  *
  * Search the last child of a node.
  * Returns the last child or NULL if none.
  */
 xmlNodePtr
-xmlGetLastChild(xmlNodePtr parent) {
-    if (parent == NULL) {
+xmlGetLastChild(const xmlNode *parent) {
+    if ((parent == NULL) || (parent->type == XML_NAMESPACE_DECL)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlGetLastChild : parent == NULL\n");
 #endif
         return(NULL);
     }
     return(parent->last);
 }
 
 #ifdef LIBXML_TREE_ENABLED
@@ skipping 17 matching lines @@
 xmlChildElementCount(xmlNodePtr parent) {
     unsigned long ret = 0;
     xmlNodePtr cur = NULL;
 
     if (parent == NULL)
         return(0);
     switch (parent->type) {
         case XML_ELEMENT_NODE:
         case XML_ENTITY_NODE:
         case XML_DOCUMENT_NODE:
+        case XML_DOCUMENT_FRAG_NODE:
         case XML_HTML_DOCUMENT_NODE:
             cur = parent->children;
             break;
         default:
             return(0);
     }
     while (cur != NULL) {
         if (cur->type == XML_ELEMENT_NODE)
             ret++;
         cur = cur->next;
@@ skipping 15 matching lines @@
 xmlNodePtr
 xmlFirstElementChild(xmlNodePtr parent) {
     xmlNodePtr cur = NULL;
 
     if (parent == NULL)
         return(NULL);
     switch (parent->type) {
         case XML_ELEMENT_NODE:
         case XML_ENTITY_NODE:
         case XML_DOCUMENT_NODE:
+        case XML_DOCUMENT_FRAG_NODE:
         case XML_HTML_DOCUMENT_NODE:
             cur = parent->children;
             break;
         default:
             return(NULL);
     }
     while (cur != NULL) {
         if (cur->type == XML_ELEMENT_NODE)
             return(cur);
         cur = cur->next;
@@ skipping 15 matching lines @@
 xmlNodePtr
 xmlLastElementChild(xmlNodePtr parent) {
     xmlNodePtr cur = NULL;
 
     if (parent == NULL)
         return(NULL);
     switch (parent->type) {
         case XML_ELEMENT_NODE:
         case XML_ENTITY_NODE:
         case XML_DOCUMENT_NODE:
+        case XML_DOCUMENT_FRAG_NODE:
         case XML_HTML_DOCUMENT_NODE:
             cur = parent->last;
             break;
         default:
             return(NULL);
     }
     while (cur != NULL) {
         if (cur->type == XML_ELEMENT_NODE)
             return(cur);
         cur = cur->prev;
@@ skipping 222 matching lines @@
         (cur->nsDef != NULL))
         xmlFreeNsList(cur->nsDef);
     xmlFree(cur);
 }
 
 /**
  * xmlUnlinkNode:
  * @cur:  the node
  *
  * Unlink a node from it's current context, the node is not freed
+ * If one need to free the node, use xmlFreeNode() routine after the
+ * unlink to discard it.
+ * Note that namespace nodes can't be unlinked as they do not have
+ * pointer to their parent.
  */
 void
 xmlUnlinkNode(xmlNodePtr cur) {
     if (cur == NULL) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlUnlinkNode : node == NULL\n");
 #endif
         return;
     }
+    if (cur->type == XML_NAMESPACE_DECL)
+        return;
     if (cur->type == XML_DTD_NODE) {
         xmlDocPtr doc;
         doc = cur->doc;
         if (doc != NULL) {
             if (doc->intSubset == (xmlDtdPtr) cur)
                 doc->intSubset = NULL;
             if (doc->extSubset == (xmlDtdPtr) cur)
                 doc->extSubset = NULL;
         }
     }
@@ skipping 48 matching lines @@
  *
  * Unlink the old node from its current context, prune the new one
  * at the same place. If @cur was already inserted in a document it is
  * first unlinked from its existing context.
  *
  * Returns the @old node
  */
 xmlNodePtr
 xmlReplaceNode(xmlNodePtr old, xmlNodePtr cur) {
     if (old == cur) return(NULL);
-    if ((old == NULL) || (old->parent == NULL)) {
+    if ((old == NULL) || (old->type == XML_NAMESPACE_DECL) ||
+        (old->parent == NULL)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlReplaceNode : old == NULL or without parent\n");
 #endif
         return(NULL);
     }
-    if (cur == NULL) {
+    if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
         xmlUnlinkNode(old);
         return(old);
     }
     if (cur == old) {
         return(old);
     }
     if ((old->type==XML_ATTRIBUTE_NODE) && (cur->type!=XML_ATTRIBUTE_NODE)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlReplaceNode : Trying to replace attribute node with other node type\n");
@@ skipping 93 matching lines @@
 }
 
 static xmlNodePtr
 xmlStaticCopyNodeList(xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent);
 
 static xmlAttrPtr
 xmlCopyPropInternal(xmlDocPtr doc, xmlNodePtr target, xmlAttrPtr cur) {
     xmlAttrPtr ret;
 
     if (cur == NULL) return(NULL);
+    if ((target != NULL) && (target->type != XML_ELEMENT_NODE))
+        return(NULL);
     if (target != NULL)
         ret = xmlNewDocProp(target->doc, cur->name, NULL);
     else if (doc != NULL)
         ret = xmlNewDocProp(doc, cur->name, NULL);
     else if (cur->parent != NULL)
         ret = xmlNewDocProp(cur->parent->doc, cur->name, NULL);
     else if (cur->children != NULL)
         ret = xmlNewDocProp(cur->children->doc, cur->name, NULL);
     else
         ret = xmlNewDocProp(NULL, cur->name, NULL);
@@ skipping 99 matching lines @@
  *
  * Do a copy of an attribute list.
  *
  * Returns: a new #xmlAttrPtr, or NULL in case of error.
  */
 xmlAttrPtr
 xmlCopyPropList(xmlNodePtr target, xmlAttrPtr cur) {
     xmlAttrPtr ret = NULL;
     xmlAttrPtr p = NULL,q;
 
+    if ((target != NULL) && (target->type != XML_ELEMENT_NODE))
+        return(NULL);
     while (cur != NULL) {
         q = xmlCopyProp(target, cur);
         if (q == NULL)
             return(NULL);
         if (p == NULL) {
             ret = p = q;
         } else {
             p->next = q;
             q->prev = p;
             p = q;
@@ skipping 16 matching lines @@
  * a copy of the namespace at the top of the copied tree if
  * not available in the subtree.
  * Hence two functions, the public front-end call the inner ones
  * The argument "recursive" normally indicates a recursive copy
  * of the node with values 0 (no) and 1 (yes).  For XInclude,
  * however, we allow a value of 2 to indicate copy properties and
  * namespace info, but don't recurse on children.
  */
 
 static xmlNodePtr
-xmlStaticCopyNode(const xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent,
+xmlStaticCopyNode(xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent,
                   int extended) {
     xmlNodePtr ret;
 
     if (node == NULL) return(NULL);
     switch (node->type) {
         case XML_TEXT_NODE:
         case XML_CDATA_SECTION_NODE:
         case XML_ELEMENT_NODE:
         case XML_DOCUMENT_FRAG_NODE:
         case XML_ENTITY_REF_NODE:
@@ skipping 145 matching lines @@
 
     while (node != NULL) {
 #ifdef LIBXML_TREE_ENABLED
         if (node->type == XML_DTD_NODE ) {
             if (doc == NULL) {
                 node = node->next;
                 continue;
             }
             if (doc->intSubset == NULL) {
                 q = (xmlNodePtr) xmlCopyDtd( (xmlDtdPtr) node );
+                if (q == NULL) return(NULL);
                 q->doc = doc;
                 q->parent = parent;
                 doc->intSubset = (xmlDtdPtr) q;
                 xmlAddChild(parent, q);
             } else {
                 q = (xmlNodePtr) doc->intSubset;
                 xmlAddChild(parent, q);
             }
         } else
 #endif /* LIBXML_TREE_ENABLED */
             q = xmlStaticCopyNode(node, doc, parent, 1);
+        if (q == NULL) return(NULL);
         if (ret == NULL) {
             q->prev = NULL;
             ret = p = q;
         } else if (p != q) {
         /* the test is required if xmlStaticCopyNode coalesced 2 text nodes */
             p->next = q;
             q->prev = p;
             p = q;
         }
         node = node->next;
     }
     return(ret);
 }
 
 /**
  * xmlCopyNode:
  * @node:  the node
  * @extended:   if 1 do a recursive copy (properties, namespaces and children
  *                      when applicable)
  *              if 2 copy properties and namespaces (when applicable)
  *
  * Do a copy of the node.
  *
  * Returns: a new #xmlNodePtr, or NULL in case of error.
  */
 xmlNodePtr
-xmlCopyNode(const xmlNodePtr node, int extended) {
+xmlCopyNode(xmlNodePtr node, int extended) {
     xmlNodePtr ret;
 
     ret = xmlStaticCopyNode(node, NULL, NULL, extended);
     return(ret);
 }
 
 /**
  * xmlDocCopyNode:
  * @node:  the node
  * @doc:  the document
  * @extended:   if 1 do a recursive copy (properties, namespaces and children
  *                      when applicable)
  *              if 2 copy properties and namespaces (when applicable)
  *
  * Do a copy of the node to a given document.
  *
  * Returns: a new #xmlNodePtr, or NULL in case of error.
  */
 xmlNodePtr
-xmlDocCopyNode(const xmlNodePtr node, xmlDocPtr doc, int extended) {
+xmlDocCopyNode(xmlNodePtr node, xmlDocPtr doc, int extended) {
     xmlNodePtr ret;
 
     ret = xmlStaticCopyNode(node, doc, NULL, extended);
     return(ret);
 }
 
 /**
  * xmlDocCopyNodeList:
  * @doc: the target document
  * @node:  the first node in the list.
  *
  * Do a recursive copy of the node list.
  *
  * Returns: a new #xmlNodePtr, or NULL in case of error.
  */
-xmlNodePtr xmlDocCopyNodeList(xmlDocPtr doc, const xmlNodePtr node) {
+xmlNodePtr xmlDocCopyNodeList(xmlDocPtr doc, xmlNodePtr node) {
     xmlNodePtr ret = xmlStaticCopyNodeList(node, doc, NULL);
     return(ret);
 }
 
 /**
  * xmlCopyNodeList:
  * @node:  the first node in the list.
  *
  * Do a recursive copy of the node list.
  * Use xmlDocCopyNodeList() if possible to ensure string interning.
  *
  * Returns: a new #xmlNodePtr, or NULL in case of error.
  */
-xmlNodePtr xmlCopyNodeList(const xmlNodePtr node) {
+xmlNodePtr xmlCopyNodeList(xmlNodePtr node) {
     xmlNodePtr ret = xmlStaticCopyNodeList(node, NULL, NULL);
     return(ret);
 }
 
 #if defined(LIBXML_TREE_ENABLED)
 /**
  * xmlCopyDtd:
  * @dtd:  the dtd
  *
  * Do a copy of the dtd.
@@ skipping 105 matching lines @@
     ret->charset = doc->charset;
     ret->compression = doc->compression;
     ret->standalone = doc->standalone;
     if (!recursive) return(ret);
 
     ret->last = NULL;
     ret->children = NULL;
 #ifdef LIBXML_TREE_ENABLED
     if (doc->intSubset != NULL) {
         ret->intSubset = xmlCopyDtd(doc->intSubset);
+        if (ret->intSubset == NULL) {
+            xmlFreeDoc(ret);
+            return(NULL);
+        }
         xmlSetTreeDoc((xmlNodePtr)ret->intSubset, ret);
         ret->intSubset->parent = ret;
     }
 #endif
     if (doc->oldNs != NULL)
         ret->oldNs = xmlCopyNamespaceList(doc->oldNs);
     if (doc->children != NULL) {
         xmlNodePtr tmp;
 
         ret->children = xmlStaticCopyNodeList(doc->children, ret,
@@ skipping 10 matching lines @@
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 /************************************************************************
  *                                                                      *
  *              Content access functions                                *
  *                                                                      *
  ************************************************************************/
 
 /**
- * xmlGetLineNo:
+ * xmlGetLineNoInternal:
  * @node: valid node
+ * @depth: used to limit any risk of recursion
  *
- * Get line number of @node. This requires activation of this option
- * before invoking the parser by calling xmlLineNumbersDefault(1)
+ * Get line number of @node.
+ * Try to override the limitation of lines being store in 16 bits ints
  *
  * Returns the line number if successful, -1 otherwise
  */
-long
-xmlGetLineNo(xmlNodePtr node)
+static long
+xmlGetLineNoInternal(const xmlNode *node, int depth)
 {
     long result = -1;
 
+    if (depth >= 5)
+        return(-1);
+
     if (!node)
         return result;
     if ((node->type == XML_ELEMENT_NODE) ||
         (node->type == XML_TEXT_NODE) ||
         (node->type == XML_COMMENT_NODE) ||
-        (node->type == XML_PI_NODE))
-        result = (long) node->line;
-    else if ((node->prev != NULL) &&
+        (node->type == XML_PI_NODE)) {
+        if (node->line == 65535) {
+            if ((node->type == XML_TEXT_NODE) && (node->psvi != NULL))
+                result = (long) node->psvi;
+            else if ((node->type == XML_ELEMENT_NODE) &&
+                     (node->children != NULL))
+                result = xmlGetLineNoInternal(node->children, depth + 1);
+            else if (node->next != NULL)
+                result = xmlGetLineNoInternal(node->next, depth + 1);
+            else if (node->prev != NULL)
+                result = xmlGetLineNoInternal(node->prev, depth + 1);
+        }
+        if ((result == -1) || (result == 65535))
+            result = (long) node->line;
+    } else if ((node->prev != NULL) &&
              ((node->prev->type == XML_ELEMENT_NODE) ||
               (node->prev->type == XML_TEXT_NODE) ||
               (node->prev->type == XML_COMMENT_NODE) ||
               (node->prev->type == XML_PI_NODE)))
-        result = xmlGetLineNo(node->prev);
+        result = xmlGetLineNoInternal(node->prev, depth + 1);
     else if ((node->parent != NULL) &&
              (node->parent->type == XML_ELEMENT_NODE))
-        result = xmlGetLineNo(node->parent);
+        result = xmlGetLineNoInternal(node->parent, depth + 1);
 
     return result;
 }
 
+/**
+ * xmlGetLineNo:
+ * @node: valid node
+ *
+ * Get line number of @node.
+ * Try to override the limitation of lines being store in 16 bits ints
+ * if XML_PARSE_BIG_LINES parser option was used
+ *
+ * Returns the line number if successful, -1 otherwise
+ */
+long
+xmlGetLineNo(const xmlNode *node)
+{
+    return(xmlGetLineNoInternal(node, 0));
+}
+
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
 /**
  * xmlGetNodePath:
  * @node: a node
  *
  * Build a structure based Path for the given node
  *
  * Returns the new path or NULL in case of error. The caller must free
  *     the returned string
  */
 xmlChar *
-xmlGetNodePath(xmlNodePtr node)
+xmlGetNodePath(const xmlNode *node)
 {
-    xmlNodePtr cur, tmp, next;
+    const xmlNode *cur, *tmp, *next;
     xmlChar *buffer = NULL, *temp;
     size_t buf_len;
     xmlChar *buf;
     const char *sep;
     const char *name;
     char nametemp[100];
     int occur = 0, generic;
 
-    if (node == NULL)
+    if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
         return (NULL);
 
     buf_len = 500;
     buffer = (xmlChar *) xmlMallocAtomic(buf_len * sizeof(xmlChar));
     if (buffer == NULL) {
         xmlTreeErrMemory("getting node path");
         return (NULL);
     }
     buf = (xmlChar *) xmlMallocAtomic(buf_len * sizeof(xmlChar));
     if (buf == NULL) {
@@ skipping 214 matching lines @@
 /**
  * xmlDocGetRootElement:
  * @doc:  the document
  *
  * Get the root element of the document (doc->children is a list
  * containing possibly comments, PIs, etc ...).
  *
  * Returns the #xmlNodePtr for the root or NULL
  */
 xmlNodePtr
-xmlDocGetRootElement(xmlDocPtr doc) {
+xmlDocGetRootElement(const xmlDoc *doc) {
     xmlNodePtr ret;
 
     if (doc == NULL) return(NULL);
     ret = doc->children;
     while (ret != NULL) {
         if (ret->type == XML_ELEMENT_NODE)
             return(ret);
         ret = ret->next;
     }
     return(ret);
 }
 
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
 /**
  * xmlDocSetRootElement:
  * @doc:  the document
  * @root:  the new document root element, if root is NULL no action is taken,
  *         to remove a node from a document use xmlUnlinkNode(root) instead.
  *
  * Set the root element of the document (doc->children is a list
  * containing possibly comments, PIs, etc ...).
  *
  * Returns the old root element if any was found, NULL if root was NULL
  */
 xmlNodePtr
 xmlDocSetRootElement(xmlDocPtr doc, xmlNodePtr root) {
     xmlNodePtr old = NULL;
 
     if (doc == NULL) return(NULL);
-    if (root == NULL)
+    if ((root == NULL) || (root->type == XML_NAMESPACE_DECL))
         return(NULL);
     xmlUnlinkNode(root);
     xmlSetTreeDoc(root, doc);
     root->parent = (xmlNodePtr) doc;
     old = doc->children;
     while (old != NULL) {
         if (old->type == XML_ELEMENT_NODE)
             break;
         old = old->next;
     }
@@ skipping 63 matching lines @@
  * xmlNodeGetLang:
  * @cur:  the node being checked
  *
  * Searches the language of a node, i.e. the values of the xml:lang
  * attribute or the one carried by the nearest ancestor.
  *
  * Returns a pointer to the lang value, or NULL if not found
  *     It's up to the caller to free the memory with xmlFree().
  */
 xmlChar *
-xmlNodeGetLang(xmlNodePtr cur) {
+xmlNodeGetLang(const xmlNode *cur) {
     xmlChar *lang;
 
+    if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
+        return(NULL);
     while (cur != NULL) {
         lang = xmlGetNsProp(cur, BAD_CAST "lang", XML_XML_NAMESPACE);
         if (lang != NULL)
             return(lang);
         cur = cur->parent;
     }
     return(NULL);
 }
 
 
@@ skipping 56 matching lines @@
  * xmlNodeGetSpacePreserve:
  * @cur:  the node being checked
  *
  * Searches the space preserving behaviour of a node, i.e. the values
  * of the xml:space attribute or the one carried by the nearest
  * ancestor.
  *
  * Returns -1 if xml:space is not inherited, 0 if "default", 1 if "preserve"
  */
 int
-xmlNodeGetSpacePreserve(xmlNodePtr cur) {
+xmlNodeGetSpacePreserve(const xmlNode *cur) {
     xmlChar *space;
 
+    if ((cur == NULL) || (cur->type != XML_ELEMENT_NODE))
+        return(-1);
     while (cur != NULL) {
         space = xmlGetNsProp(cur, BAD_CAST "space", XML_XML_NAMESPACE);
         if (space != NULL) {
             if (xmlStrEqual(space, BAD_CAST "preserve")) {
                 xmlFree(space);
                 return(1);
             }
             if (xmlStrEqual(space, BAD_CAST "default")) {
                 xmlFree(space);
                 return(0);
@@ skipping 10 matching lines @@
  * xmlNodeSetName:
  * @cur:  the node being changed
  * @name:  the new tag name
  *
  * Set (or reset) the name of a node.
  */
 void
 xmlNodeSetName(xmlNodePtr cur, const xmlChar *name) {
     xmlDocPtr doc;
     xmlDictPtr dict;
+    const xmlChar *freeme = NULL;
 
     if (cur == NULL) return;
     if (name == NULL) return;
     switch(cur->type) {
         case XML_TEXT_NODE:
         case XML_CDATA_SECTION_NODE:
         case XML_COMMENT_NODE:
         case XML_DOCUMENT_TYPE_NODE:
         case XML_DOCUMENT_FRAG_NODE:
         case XML_NOTATION_NODE:
@@ skipping 17 matching lines @@
         case XML_ENTITY_DECL:
             break;
     }
     doc = cur->doc;
     if (doc != NULL)
         dict = doc->dict;
     else
         dict = NULL;
     if (dict != NULL) {
         if ((cur->name != NULL) && (!xmlDictOwns(dict, cur->name)))
-            xmlFree((xmlChar *) cur->name);
+            freeme = cur->name;
         cur->name = xmlDictLookup(dict, name, -1);
     } else {
-        if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
+        if (cur->name != NULL)
+            freeme = cur->name;
         cur->name = xmlStrdup(name);
     }
+
+    if (freeme)
+        xmlFree((xmlChar *) freeme);
 }
 #endif
 
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
 /**
  * xmlNodeSetBase:
  * @cur:  the node being changed
  * @uri:  the new base URI
  *
  * Set (or reset) the base URI of a node, i.e. the value of the
@@ skipping 67 matching lines @@
  * 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
  *
  * Returns a pointer to the base URL, or NULL if not found
  *     It's up to the caller to free the memory with xmlFree().
  */
 xmlChar *
-xmlNodeGetBase(xmlDocPtr doc, xmlNodePtr cur) {
+xmlNodeGetBase(const xmlDoc *doc, const xmlNode *cur) {
     xmlChar *oldbase = NULL;
     xmlChar *base, *newbase;
 
     if ((cur == NULL) && (doc == NULL))
         return(NULL);
+    if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL))
+        return(NULL);
     if (doc == NULL) doc = cur->doc;
     if ((doc != NULL) && (doc->type == XML_HTML_DOCUMENT_NODE)) {
         cur = doc->children;
         while ((cur != NULL) && (cur->name != NULL)) {
             if (cur->type != XML_ELEMENT_NODE) {
                 cur = cur->next;
                 continue;
             }
             if (!xmlStrcasecmp(cur->name, BAD_CAST "html")) {
                 cur = cur->children;
@@ skipping 57 matching lines @@
  *
  * 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
  *
  * Returns 0 in case of success and -1 in case of error.
  */
 int
-xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr cur)
+xmlNodeBufGetContent(xmlBufferPtr buffer, const xmlNode *cur)
 {
+    xmlBufPtr buf;
+    int ret;
+
     if ((cur == NULL) || (buffer == NULL)) return(-1);
+    buf = xmlBufFromBuffer(buffer);
+    ret = xmlBufGetNodeContent(buf, cur);
+    buffer = xmlBufBackToBuffer(buf);
+    if ((ret < 0) || (buffer == NULL))
+        return(-1);
+    return(0);
+}
+
+/**
+ * xmlBufGetNodeContent:
+ * @buf:  a buffer xmlBufPtr
+ * @cur:  the node being read
+ *
+ * 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
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ */
+int
+xmlBufGetNodeContent(xmlBufPtr buf, const xmlNode *cur)
+{
+    if ((cur == NULL) || (buf == NULL)) return(-1);
     switch (cur->type) {
         case XML_CDATA_SECTION_NODE:
         case XML_TEXT_NODE:
-            xmlBufferCat(buffer, cur->content);
+            xmlBufCat(buf, cur->content);
             break;
         case XML_DOCUMENT_FRAG_NODE:
         case XML_ELEMENT_NODE:{
-                xmlNodePtr tmp = cur;
+                const xmlNode *tmp = cur;
 
                 while (tmp != NULL) {
                     switch (tmp->type) {
                         case XML_CDATA_SECTION_NODE:
                         case XML_TEXT_NODE:
                             if (tmp->content != NULL)
-                                xmlBufferCat(buffer, tmp->content);
+                                xmlBufCat(buf, tmp->content);
                             break;
                         case XML_ENTITY_REF_NODE:
-                            xmlNodeBufGetContent(buffer, tmp);
+                            xmlBufGetNodeContent(buf, tmp);
                             break;
                         default:
                             break;
                     }
                     /*
                      * Skip to next node
                      */
                     if (tmp->children != NULL) {
                         if (tmp->children->type != XML_ENTITY_DECL) {
                             tmp = tmp->children;
@@ skipping 23 matching lines @@
                     } while (tmp != NULL);
                 }
                 break;
             }
         case XML_ATTRIBUTE_NODE:{
                 xmlAttrPtr attr = (xmlAttrPtr) cur;
                 xmlNodePtr tmp = attr->children;
 
                 while (tmp != NULL) {
                     if (tmp->type == XML_TEXT_NODE)
-                        xmlBufferCat(buffer, tmp->content);
+                        xmlBufCat(buf, tmp->content);
                     else
-                        xmlNodeBufGetContent(buffer, tmp);
+                        xmlBufGetNodeContent(buf, tmp);
                     tmp = tmp->next;
                 }
                 break;
             }
         case XML_COMMENT_NODE:
         case XML_PI_NODE:
-            xmlBufferCat(buffer, cur->content);
+            xmlBufCat(buf, cur->content);
             break;
         case XML_ENTITY_REF_NODE:{
                 xmlEntityPtr ent;
                 xmlNodePtr tmp;
 
                 /* lookup entity declaration */
                 ent = xmlGetDocEntity(cur->doc, cur->name);
                 if (ent == NULL)
                     return(-1);
 
                 /* an entity content can be any "well balanced chunk",
                  * i.e. the result of the content [43] production:
                  * http://www.w3.org/TR/REC-xml#NT-content
                  * -> we iterate through child nodes and recursive call
                  * xmlNodeGetContent() which handles all possible node types */
                 tmp = ent->children;
                 while (tmp) {
-                    xmlNodeBufGetContent(buffer, tmp);
+                    xmlBufGetNodeContent(buf, tmp);
                     tmp = tmp->next;
                 }
                 break;
             }
         case XML_ENTITY_NODE:
         case XML_DOCUMENT_TYPE_NODE:
         case XML_NOTATION_NODE:
         case XML_DTD_NODE:
         case XML_XINCLUDE_START:
         case XML_XINCLUDE_END:
             break;
         case XML_DOCUMENT_NODE:
 #ifdef LIBXML_DOCB_ENABLED
         case XML_DOCB_DOCUMENT_NODE:
 #endif
         case XML_HTML_DOCUMENT_NODE:
             cur = cur->children;
             while (cur!= NULL) {
                 if ((cur->type == XML_ELEMENT_NODE) ||
                     (cur->type == XML_TEXT_NODE) ||
                     (cur->type == XML_CDATA_SECTION_NODE)) {
-                    xmlNodeBufGetContent(buffer, cur);
+                    xmlBufGetNodeContent(buf, cur);
                 }
                 cur = cur->next;
             }
             break;
         case XML_NAMESPACE_DECL:
-            xmlBufferCat(buffer, ((xmlNsPtr) cur)->href);
+            xmlBufCat(buf, ((xmlNsPtr) cur)->href);
             break;
         case XML_ELEMENT_DECL:
         case XML_ATTRIBUTE_DECL:
         case XML_ENTITY_DECL:
             break;
     }
     return(0);
 }
+
 /**
  * xmlNodeGetContent:
  * @cur:  the node being read
  *
  * 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.
  * Returns a new #xmlChar * or NULL if no content is available.
  *     It's up to the caller to free the memory with xmlFree().
  */
 xmlChar *
-xmlNodeGetContent(xmlNodePtr cur)
+xmlNodeGetContent(const xmlNode *cur)
 {
     if (cur == NULL)
         return (NULL);
     switch (cur->type) {
         case XML_DOCUMENT_FRAG_NODE:
         case XML_ELEMENT_NODE:{
-                xmlBufferPtr buffer;
+                xmlBufPtr buf;
                 xmlChar *ret;
 
-                buffer = xmlBufferCreateSize(64);
-                if (buffer == NULL)
+                buf = xmlBufCreateSize(64);
+                if (buf == NULL)
                     return (NULL);
-                xmlNodeBufGetContent(buffer, cur);
-                ret = buffer->content;
-                buffer->content = NULL;
-                xmlBufferFree(buffer);
+                xmlBufGetNodeContent(buf, cur);
+                ret = xmlBufDetach(buf);
+                xmlBufFree(buf);
                 return (ret);
             }
         case XML_ATTRIBUTE_NODE:
             return(xmlGetPropNodeValueInternal((xmlAttrPtr) cur));
         case XML_COMMENT_NODE:
         case XML_PI_NODE:
             if (cur->content != NULL)
                 return (xmlStrdup(cur->content));
             return (NULL);
         case XML_ENTITY_REF_NODE:{
                 xmlEntityPtr ent;
-                xmlBufferPtr buffer;
+                xmlBufPtr buf;
                 xmlChar *ret;
 
                 /* lookup entity declaration */
                 ent = xmlGetDocEntity(cur->doc, cur->name);
                 if (ent == NULL)
                     return (NULL);
 
-                buffer = xmlBufferCreate();
-                if (buffer == NULL)
+                buf = xmlBufCreate();
+                if (buf == NULL)
                     return (NULL);
 
-                xmlNodeBufGetContent(buffer, cur);
+                xmlBufGetNodeContent(buf, cur);
 
-                ret = buffer->content;
-                buffer->content = NULL;
-                xmlBufferFree(buffer);
+                ret = xmlBufDetach(buf);
+                xmlBufFree(buf);
                 return (ret);
             }
         case XML_ENTITY_NODE:
         case XML_DOCUMENT_TYPE_NODE:
         case XML_NOTATION_NODE:
         case XML_DTD_NODE:
         case XML_XINCLUDE_START:
         case XML_XINCLUDE_END:
             return (NULL);
         case XML_DOCUMENT_NODE:
 #ifdef LIBXML_DOCB_ENABLED
         case XML_DOCB_DOCUMENT_NODE:
 #endif
         case XML_HTML_DOCUMENT_NODE: {
-            xmlBufferPtr buffer;
+            xmlBufPtr buf;
             xmlChar *ret;
 
-            buffer = xmlBufferCreate();
-            if (buffer == NULL)
+            buf = xmlBufCreate();
+            if (buf == NULL)
                 return (NULL);
 
-            xmlNodeBufGetContent(buffer, (xmlNodePtr) cur);
+            xmlBufGetNodeContent(buf, (xmlNodePtr) cur);
 
-            ret = buffer->content;
-            buffer->content = NULL;
-            xmlBufferFree(buffer);
+            ret = xmlBufDetach(buf);
+            xmlBufFree(buf);
             return (ret);
         }
         case XML_NAMESPACE_DECL: {
             xmlChar *tmp;
 
             tmp = xmlStrdup(((xmlNsPtr) cur)->href);
             return (tmp);
         }
         case XML_ELEMENT_DECL:
             /* TODO !!! */
@@ skipping 292 matching lines @@
  * xmlGetNsList:
  * @doc:  the document
  * @node:  the current node
  *
  * Search all the namespace applying to a given element.
  * Returns an NULL terminated array of all the #xmlNsPtr found
  *         that need to be freed by the caller or NULL if no
  *         namespace if defined
  */
 xmlNsPtr *
-xmlGetNsList(xmlDocPtr doc ATTRIBUTE_UNUSED, xmlNodePtr node)
+xmlGetNsList(const xmlDoc *doc ATTRIBUTE_UNUSED, const xmlNode *node)
 {
     xmlNsPtr cur;
     xmlNsPtr *ret = NULL;
     int nbns = 0;
     int maxns = 10;
     int i;
 
+    if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
+        return(NULL);
+
     while (node != NULL) {
         if (node->type == XML_ELEMENT_NODE) {
             cur = node->nsDef;
             while (cur != NULL) {
                 if (ret == NULL) {
                     ret =
                         (xmlNsPtr *) xmlMalloc((maxns + 1) *
                                                sizeof(xmlNsPtr));
                     if (ret == NULL) {
                         xmlTreeErrMemory("getting namespace list");
@@ skipping 76 matching lines @@
  * 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.
  *
  * Returns the namespace pointer or NULL.
  */
 xmlNsPtr
 xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace) {
 
     xmlNsPtr cur;
-    xmlNodePtr orig = node;
+    const xmlNode *orig = node;
 
-    if (node == NULL) return(NULL);
+    if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) return(NULL);
     if ((nameSpace != NULL) &&
         (xmlStrEqual(nameSpace, (const xmlChar *)"xml"))) {
         if ((doc == NULL) && (node->type == XML_ELEMENT_NODE)) {
             /*
              * The XML-1.0 namespace is normally held on the root
              * element. In this case exceptionally create it on the
              * node element.
              */
             cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
             if (cur == NULL) {
@@ skipping 109 matching lines @@
  * the defined namespace or return NULL otherwise.
  * Returns the namespace pointer or NULL.
  */
 xmlNsPtr
 xmlSearchNsByHref(xmlDocPtr doc, xmlNodePtr node, const xmlChar * href)
 {
     xmlNsPtr cur;
     xmlNodePtr orig = node;
     int is_attr;
 
-    if ((node == NULL) || (href == NULL))
+    if ((node == NULL) || (node->type == XML_NAMESPACE_DECL) || (href == NULL))
         return (NULL);
     if (xmlStrEqual(href, XML_XML_NAMESPACE)) {
         /*
          * Only the document can hold the XML spec namespace.
          */
         if ((doc == NULL) && (node->type == XML_ELEMENT_NODE)) {
             /*
              * The XML-1.0 namespace is normally held on the root
              * element. In this case exceptionally create it on the
              * node element.
@@ skipping 70 matching lines @@
  * null (default namespace) or reused within the subtree defined by
  * @tree or on one of its ancestors then a new prefix is generated.
  * Returns the (new) namespace definition or NULL in case of error
  */
 static xmlNsPtr
 xmlNewReconciliedNs(xmlDocPtr doc, xmlNodePtr tree, xmlNsPtr ns) {
     xmlNsPtr def;
     xmlChar prefix[50];
     int counter = 1;
 
-    if (tree == NULL) {
+    if ((tree == NULL) || (tree->type != XML_ELEMENT_NODE)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlNewReconciliedNs : tree == NULL\n");
 #endif
         return(NULL);
     }
     if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL)) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlNewReconciliedNs : ns == NULL\n");
@@ skipping 225 matching lines @@
     }
     if (oldNs != NULL)
         xmlFree(oldNs);
     if (newNs != NULL)
         xmlFree(newNs);
     return(ret);
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 static xmlAttrPtr
-xmlGetPropNodeInternal(xmlNodePtr node, const xmlChar *name,
+xmlGetPropNodeInternal(const xmlNode *node, const xmlChar *name,
                        const xmlChar *nsName, int useDTD)
 {
     xmlAttrPtr prop;
 
     if ((node == NULL) || (node->type != XML_ELEMENT_NODE) || (name == NULL))
         return(NULL);
 
     if (node->properties != NULL) {
         prop = node->properties;
         if (nsName == NULL) {
@@ skipping 93 matching lines @@
         * Only default/fixed attrs are relevant.
         */
         if ((attrDecl != NULL) && (attrDecl->defaultValue != NULL))
             return((xmlAttrPtr) attrDecl);
     }
 #endif /* LIBXML_TREE_ENABLED */
     return(NULL);
 }
 
 static xmlChar*
-xmlGetPropNodeValueInternal(xmlAttrPtr prop)
+xmlGetPropNodeValueInternal(const xmlAttr *prop)
 {
     if (prop == NULL)
         return(NULL);
     if (prop->type == XML_ATTRIBUTE_NODE) {
         /*
         * Note that we return at least the empty string.
         *   TODO: Do we really always want that?
         */
         if (prop->children != NULL) {
             if ((prop->children->next == NULL) &&
@@ skipping 25 matching lines @@
  * @name:  the attribute name
  *
  * Search an attribute associated to a node
  * This function also looks in DTD attribute declaration for #FIXED or
  * default declaration values unless DTD use has been turned off.
  *
  * Returns the attribute or the attribute declaration or NULL if
  *         neither was found.
  */
 xmlAttrPtr
-xmlHasProp(xmlNodePtr node, const xmlChar *name) {
+xmlHasProp(const xmlNode *node, const xmlChar *name) {
     xmlAttrPtr prop;
     xmlDocPtr doc;
 
     if ((node == NULL) || (node->type != XML_ELEMENT_NODE) || (name == NULL))
         return(NULL);
     /*
      * Check on the properties attached to the node
      */
     prop = node->properties;
     while (prop != NULL) {
@@ skipping 34 matching lines @@
  * This attribute has to be anchored in the namespace specified.
  * This does the entity substitution.
  * This function looks in DTD attribute declaration for #FIXED or
  * default declaration values unless DTD use has been turned off.
  * Note that a namespace of NULL indicates to use the default namespace.
  *
  * Returns the attribute or the attribute declaration or NULL
  *     if neither was found.
  */
 xmlAttrPtr
-xmlHasNsProp(xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace) {
+xmlHasNsProp(const xmlNode *node, const xmlChar *name, const xmlChar *nameSpace) {
 
     return(xmlGetPropNodeInternal(node, name, nameSpace, xmlCheckDTD));
 }
 
 /**
  * xmlGetProp:
  * @node:  the node
  * @name:  the attribute name
  *
  * Search and get the value of an attribute associated to a node
  * This does the entity substitution.
  * This function looks in DTD attribute declaration for #FIXED or
  * default declaration values unless DTD use has been turned off.
  * NOTE: this function acts independently of namespaces associated
  *       to the attribute. Use xmlGetNsProp() or xmlGetNoNsProp()
  *       for namespace aware processing.
  *
  * Returns the attribute value or NULL if not found.
  *     It's up to the caller to free the memory with xmlFree().
  */
 xmlChar *
-xmlGetProp(xmlNodePtr node, const xmlChar *name) {
+xmlGetProp(const xmlNode *node, const xmlChar *name) {
     xmlAttrPtr prop;
 
     prop = xmlHasProp(node, name);
     if (prop == NULL)
         return(NULL);
     return(xmlGetPropNodeValueInternal(prop));
 }
 
 /**
  * xmlGetNoNsProp:
  * @node:  the node
  * @name:  the attribute name
  *
  * Search and get the value of an attribute associated to a node
  * This does the entity substitution.
  * This function looks in DTD attribute declaration for #FIXED or
  * default declaration values unless DTD use has been turned off.
  * This function is similar to xmlGetProp except it will accept only
  * an attribute in no namespace.
  *
  * Returns the attribute value or NULL if not found.
  *     It's up to the caller to free the memory with xmlFree().
  */
 xmlChar *
-xmlGetNoNsProp(xmlNodePtr node, const xmlChar *name) {
+xmlGetNoNsProp(const xmlNode *node, const xmlChar *name) {
     xmlAttrPtr prop;
 
     prop = xmlGetPropNodeInternal(node, name, NULL, xmlCheckDTD);
     if (prop == NULL)
         return(NULL);
     return(xmlGetPropNodeValueInternal(prop));
 }
 
 /**
  * xmlGetNsProp:
  * @node:  the node
  * @name:  the attribute name
  * @nameSpace:  the URI of the namespace
  *
  * Search and get the value of an attribute associated to a node
  * This attribute has to be anchored in the namespace specified.
  * This does the entity substitution.
  * This function looks in DTD attribute declaration for #FIXED or
  * default declaration values unless DTD use has been turned off.
  *
  * Returns the attribute value or NULL if not found.
  *     It's up to the caller to free the memory with xmlFree().
  */
 xmlChar *
-xmlGetNsProp(xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace) {
+xmlGetNsProp(const xmlNode *node, const xmlChar *name, const xmlChar *nameSpace) {
     xmlAttrPtr prop;
 
     prop = xmlGetPropNodeInternal(node, name, nameSpace, xmlCheckDTD);
     if (prop == NULL)
         return(NULL);
     return(xmlGetPropNodeValueInternal(prop));
 }
 
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
 /**
@@ skipping 144 matching lines @@
 #endif /* LIBXML_TREE_ENABLED */
 
 /**
  * xmlNodeIsText:
  * @node:  the node
  *
  * Is this node a Text node ?
  * Returns 1 yes, 0 no
  */
 int
-xmlNodeIsText(xmlNodePtr node) {
+xmlNodeIsText(const xmlNode *node) {
     if (node == NULL) return(0);
 
     if (node->type == XML_TEXT_NODE) return(1);
     return(0);
 }
 
 /**
  * xmlIsBlankNode:
  * @node:  the node
  *
  * Checks whether this node is an empty or whitespace only
  * (and possibly ignorable) text-node.
  *
  * Returns 1 yes, 0 no
  */
 int
-xmlIsBlankNode(xmlNodePtr node) {
+xmlIsBlankNode(const xmlNode *node) {
     const xmlChar *cur;
     if (node == NULL) return(0);
 
     if ((node->type != XML_TEXT_NODE) &&
         (node->type != XML_CDATA_SECTION_NODE))
         return(0);
     if (node->content == NULL) return(1);
     cur = node->content;
     while (*cur != 0) {
         if (!IS_BLANK_CH(*cur)) return(0);
@@ skipping 104 matching lines @@
             return(NULL);
         }
         ret->content[0] = 0;
     } else
         ret->content = NULL;
     ret->contentIO = NULL;
     return(ret);
 }
 
 /**
+ * xmlBufferDetach:
+ * @buf:  the buffer
+ *
+ * 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.
+ *
+ * Returns the previous string contained by the buffer.
+ */
+xmlChar *
+xmlBufferDetach(xmlBufferPtr buf) {
+    xmlChar *ret;
+
+    if (buf == NULL)
+        return(NULL);
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)
+        return(NULL);
+
+    ret = buf->content;
+    buf->content = NULL;
+    buf->size = 0;
+    buf->use = 0;
+
+    return ret;
+}
+
+
+/**
  * xmlBufferCreateStatic:
  * @mem: the memory area
  * @size:  the size in byte
  *
  * routine to create an XML buffer from an immutable memory area.
  * The area won't be modified nor copied, and is expected to be
  * present until the end of the buffer lifetime.
  *
  * returns the new structure.
  */
@@ skipping 30 matching lines @@
 #ifdef DEBUG_BUFFER
         xmlGenericError(xmlGenericErrorContext,
                 "xmlBufferSetAllocationScheme: buf == NULL\n");
 #endif
         return;
     }
     if ((buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) ||
         (buf->alloc == XML_BUFFER_ALLOC_IO)) return;
     if ((scheme == XML_BUFFER_ALLOC_DOUBLEIT) ||
         (scheme == XML_BUFFER_ALLOC_EXACT) ||
+        (scheme == XML_BUFFER_ALLOC_HYBRID) ||
         (scheme == XML_BUFFER_ALLOC_IMMUTABLE))
         buf->alloc = scheme;
 }
 
 /**
  * xmlBufferFree:
  * @buf:  the buffer to free
  *
  * Frees an XML buffer. It frees both the content and the structure which
  * encapsulate it.
@@ skipping 179 matching lines @@
 /**
  * xmlBufferContent:
  * @buf:  the buffer
  *
  * Function to extract the content of a buffer
  *
  * Returns the internal content
  */
 
 const xmlChar *
-xmlBufferContent(const xmlBufferPtr buf)
+xmlBufferContent(const xmlBuffer *buf)
 {
     if(!buf)
         return NULL;
 
     return buf->content;
 }
 
 /**
  * xmlBufferLength:
  * @buf:  the buffer
  *
  * Function to get the length of a buffer
  *
  * Returns the length of data in the internal content
  */
 
 int
-xmlBufferLength(const xmlBufferPtr buf)
+xmlBufferLength(const xmlBuffer *buf)
 {
     if(!buf)
         return 0;
 
     return buf->use;
 }
 
 /**
  * xmlBufferResize:
  * @buf:  the buffer to resize
@@ skipping 29 matching lines @@
                 if (newSize > UINT_MAX / 2) {
                     xmlTreeErrMemory("growing buffer");
                     return 0;
                 }
                 newSize *= 2;
             }
             break;
         case XML_BUFFER_ALLOC_EXACT:
             newSize = size+10;
             break;
+        case XML_BUFFER_ALLOC_HYBRID:
+            if (buf->use < BASE_BUFFER_SIZE)
+                newSize = size;
+            else {
+                newSize = buf->size * 2;
+                while (size > newSize) {
+                    if (newSize > UINT_MAX / 2) {
+                        xmlTreeErrMemory("growing buffer");
+                        return 0;
+                    }
+                    newSize *= 2;
+                }
+            }
+            break;
+
         default:
             newSize = size+10;
             break;
     }
 
     if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) {
         start_buf = buf->content - buf->contentIO;
 
         if (start_buf > newSize) {
             /* move data back to start */
@@ skipping 299 matching lines @@
 
 
 /**
  * xmlGetDocCompressMode:
  * @doc:  the document
  *
  * get the compression ratio for a document, ZLIB based
  * Returns 0 (uncompressed) to 9 (max compression)
  */
 int
-xmlGetDocCompressMode (xmlDocPtr doc) {
+xmlGetDocCompressMode (const xmlDoc *doc) {
     if (doc == NULL) return(-1);
     return(doc->compression);
 }
 
 /**
  * xmlSetDocCompressMode:
  * @doc:  the document
  * @mode:  the compression ratio
  *
  * set the compression ratio for a document, ZLIB based
@@ skipping 170 matching lines @@
         ret->prev = map->last;
         map->last->next = ret;
         map->last = ret;
     } else if (position == 0) {
         /*
         * Set on first position.
         */
         map->first->prev = ret;
         ret->next = map->first;
         map->first = ret;
-    } else
-        return(NULL);
+    }
 
     ret->oldNs = oldNs;
     ret->newNs = newNs;
     ret->shadowDepth = -1;
     ret->depth = depth;
     return (ret);
 }
 
 /*
 * xmlDOMWrapStoreNs:
@@ skipping 39 matching lines @@
         return (ns->next);
     }
     return(NULL);
 }
 
 /*
 * xmlDOMWrapNewCtxt:
 *
 * Allocates and initializes a new DOM-wrapper context.
 *
-* Returns the xmlDOMWrapCtxtPtr or NULL in case of an internal errror.
+* Returns the xmlDOMWrapCtxtPtr or NULL in case of an internal error.
 */
 xmlDOMWrapCtxtPtr
 xmlDOMWrapNewCtxt(void)
 {
     xmlDOMWrapCtxtPtr ret;
 
     ret = xmlMalloc(sizeof(xmlDOMWrapCtxt));
     if (ret == NULL) {
         xmlTreeErrMemory("allocating DOM-wrapper context");
         return (NULL);
@@ skipping 64 matching lines @@
 xmlDOMWrapNSNormGatherInScopeNs(xmlNsMapPtr *map,
                                 xmlNodePtr node)
 {
     xmlNodePtr cur;
     xmlNsPtr ns;
     xmlNsMapItemPtr mi;
     int shadowed;
 
     if ((map == NULL) || (*map != NULL))
         return (-1);
+    if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
+        return (-1);
     /*
     * Get in-scope ns-decls of @parent.
     */
     cur = node;
     while ((cur != NULL) && (cur != (xmlNodePtr) cur->doc)) {
         if (cur->type == XML_ELEMENT_NODE) {
             if (cur->nsDef != NULL) {
                 ns = cur->nsDef;
                 do {
                     shadowed = 0;
@@ skipping 247 matching lines @@
 static int
 xmlSearchNsByNamespaceStrict(xmlDocPtr doc, xmlNodePtr node,
                              const xmlChar* nsName,
                              xmlNsPtr *retNs, int prefixed)
 {
     xmlNodePtr cur, prev = NULL, out = NULL;
     xmlNsPtr ns, prevns;
 
     if ((doc == NULL) || (nsName == NULL) || (retNs == NULL))
         return (-1);
+    if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
+        return(-1);
 
     *retNs = NULL;
     if (xmlStrEqual(nsName, XML_XML_NAMESPACE)) {
         *retNs = xmlTreeEnsureXMLDecl(doc);
         if (*retNs == NULL)
             return (-1);
         return (1);
     }
     cur = node;
     do {
@@ skipping 78 matching lines @@
 *         and internal errors.
 */
 static int
 xmlSearchNsByPrefixStrict(xmlDocPtr doc, xmlNodePtr node,
                           const xmlChar* prefix,
                           xmlNsPtr *retNs)
 {
     xmlNodePtr cur;
     xmlNsPtr ns;
 
-    if ((doc == NULL) || (node == NULL))
-        return (-1);
+    if ((doc == NULL) || (node == NULL) || (node->type == XML_NAMESPACE_DECL))
+        return(-1);
 
     if (retNs)
         *retNs = NULL;
     if (IS_STR_XML(prefix)) {
         if (retNs) {
             *retNs = xmlTreeEnsureXMLDecl(doc);
             if (*retNs == NULL)
                 return (-1);
         }
         return (1);
@@ skipping 47 matching lines @@
                                 xmlNodePtr elem,
                                 const xmlChar *nsName,
                                 const xmlChar *prefix,
                                 int checkShadow)
 {
 
     xmlNsPtr ret;
     char buf[50];
     const xmlChar *pref;
     int counter = 0;
+
+    if ((doc == NULL) || (elem == NULL) || (elem->type != XML_ELEMENT_NODE))
+        return(NULL);
     /*
     * Create a ns-decl on @anchor.
     */
     pref = prefix;
     while (1) {
         /*
         * Lookup whether the prefix is unused in elem's ns-decls.
         */
         if ((elem->nsDef != NULL) &&
             (xmlTreeNSListLookupByPrefix(elem->nsDef, pref) != NULL))
@@ skipping 496 matching lines @@
     * 2) custom ns-reference handling is used
     */
     if ((destParent == NULL) ||
         (ctxt && ctxt->getNsForNodeFunc))
     {
         parnsdone = 1;
     } else
         parnsdone = 0;
 
     cur = node;
+    if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL))
+        goto internal_error;
+
     while (cur != NULL) {
         /*
         * Paranoid source-doc sanity check.
         */
         if (cur->doc != sourceDoc) {
             /*
             * We'll assume XIncluded nodes if the doc differs.
             * TODO: Do we need to reconciliate XIncluded nodes?
             * This here skips XIncluded nodes and tries to handle
             * broken sequences.
@@ skipping 359 matching lines @@
     dict = destDoc->dict;
     /*
     * Reuse the namespace map of the context.
     */
     if (ctxt)
         nsMap = (xmlNsMapPtr) ctxt->namespaceMap;
 
     *resNode = NULL;
 
     cur = node;
+    if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL))
+        return(-1);
+
     while (cur != NULL) {
         if (cur->doc != sourceDoc) {
             /*
             * We'll assume XIncluded nodes if the doc differs.
             * TODO: Do we need to reconciliate XIncluded nodes?
             * TODO: This here returns -1 in this case.
             */
             goto internal_error;
         }
         /*
@@ skipping 378 matching lines @@
         if (cur->next != NULL) {
             prevClone = clone;
             cur = cur->next;
         } else if (cur->type != XML_ATTRIBUTE_NODE) {
             /*
             * Set clone->last.
             */
             if (clone->parent != NULL)
                 clone->parent->last = clone;
             clone = clone->parent;
-            parentClone = clone->parent;
+            if (clone != NULL)
+                parentClone = clone->parent;
             /*
             * Process parent --> next;
             */
             cur = cur->parent;
             goto leave_node;
         } else {
             /* This is for attributes only. */
             clone = clone->parent;
             parentClone = clone->parent;
             /*
@@ skipping 98 matching lines @@
 
     XML_TREE_ADOPT_STR(attr->name);
     attr->atype = 0;
     attr->psvi = NULL;
     /*
     * Walk content.
     */
     if (attr->children == NULL)
         return (0);
     cur = attr->children;
+    if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL))
+        goto internal_error;
     while (cur != NULL) {
         cur->doc = destDoc;
         switch (cur->type) {
             case XML_TEXT_NODE:
             case XML_CDATA_SECTION_NODE:
                 XML_TREE_ADOPT_STR_2(cur->content)
                 break;
             case XML_ENTITY_REF_NODE:
                 /*
                 * Remove reference to the entitity-node.
@@ skipping 41 matching lines @@
 * @ctxt: the optional context for custom processing
 * @sourceDoc: the optional sourceDoc
 * @node: the node to start with
 * @destDoc: the destination doc
 * @destParent: the optional new parent of @node in @destDoc
 * @options: option flags
 *
 * 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 unliked node and just want to move it
+*    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 attribute
 * values or element content.
 * NOTE: This function was not intensively tested.
 *
 * Returns 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.
 */
 int
 xmlDOMWrapAdoptNode(xmlDOMWrapCtxtPtr ctxt,
                     xmlDocPtr sourceDoc,
                     xmlNodePtr node,
                     xmlDocPtr destDoc,
                     xmlNodePtr destParent,
                     int options)
 {
-    if ((node == NULL) || (destDoc == NULL) ||
+    if ((node == NULL) || (node->type == XML_NAMESPACE_DECL) ||
+        (destDoc == NULL) ||
         ((destParent != NULL) && (destParent->doc != destDoc)))
         return(-1);
     /*
     * Check node->doc sanity.
     */
     if ((node->doc != NULL) && (sourceDoc != NULL) &&
         (node->doc != sourceDoc)) {
         /*
         * Might be an XIncluded node.
         */
@@ skipping 74 matching lines @@
             }
             default:
                 break;
         }
     }
     return (0);
 }
 
 #define bottom_tree
 #include "elfgcchack.h"