Update libxml to 2.7.7.

third_party/libxml/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
  *
  */
 
 #define IN_LIBXML
 #include "libxml.h"
 
 #include <string.h> /* for memset() only ! */
-
+#include <limits.h>
 #ifdef HAVE_CTYPE_H
 #include <ctype.h>
 #endif
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #endif
 #ifdef HAVE_ZLIB_H
 #include <zlib.h>
 #endif
 
@@ skipping 10 matching lines @@
 #include <libxml/HTMLtree.h>
 #endif
 #ifdef LIBXML_DEBUG_ENABLED
 #include <libxml/debugXML.h>
 #endif
 
 int __xmlRegisterCallbacks = 0;
 
 /************************************************************************
  *                                                                      *
- *              Forward declarations                                    *
+ *              Forward declarations                                    *
  *                                                                      *
  ************************************************************************/
 
-xmlNsPtr xmlNewReconciliedNs(xmlDocPtr doc, xmlNodePtr tree, xmlNsPtr ns);
+static xmlNsPtr
+xmlNewReconciliedNs(xmlDocPtr doc, xmlNodePtr tree, xmlNsPtr ns);
 
 static xmlChar* xmlGetPropNodeValueInternal(xmlAttrPtr prop);
 
 /************************************************************************
  *                                                                      *
- *              Tree memory error handler                               *
+ *              Tree memory error handler                               *
  *                                                                      *
  ************************************************************************/
 /**
  * xmlTreeErrMemory:
  * @extra:  extra informations
  *
  * Handle an out of memory condition
  */
 static void
 xmlTreeErrMemory(const char *extra)
@@ skipping 27 matching lines @@
             msg = "string is not in UTF-8\n";
             break;
         default:
             msg = "unexpected error number\n";
     }
     __xmlSimpleError(XML_FROM_TREE, code, node, msg, extra);
 }
 
 /************************************************************************
  *                                                                      *
- *              A few static variables and macros                       *
+ *              A few static variables and macros                       *
  *                                                                      *
  ************************************************************************/
 /* #undef xmlStringText */
 const xmlChar xmlStringText[] = { 't', 'e', 'x', 't', 0 };
 /* #undef xmlStringTextNoenc */
 const xmlChar xmlStringTextNoenc[] =
               { 't', 'e', 'x', 't', 'n', 'o', 'e', 'n', 'c', 0 };
 /* #undef xmlStringComment */
 const xmlChar xmlStringComment[] = { 'c', 'o', 'm', 'm', 'e', 'n', 't', 0 };
 
 static int xmlCompressMode = 0;
 static int xmlCheckDTD = 1;
 
 #define UPDATE_LAST_CHILD_AND_PARENT(n) if ((n) != NULL) {              \
     xmlNodePtr ulccur = (n)->children;                                  \
     if (ulccur == NULL) {                                               \
         (n)->last = NULL;                                               \
     } else {                                                            \
         while (ulccur->next != NULL) {                                  \
-                ulccur->parent = (n);                                   \
+                ulccur->parent = (n);                                   \
                 ulccur = ulccur->next;                                  \
         }                                                               \
         ulccur->parent = (n);                                           \
         (n)->last = ulccur;                                             \
 }}
 
 #define IS_STR_XML(str) ((str != NULL) && (str[0] == 'x') && \
   (str[1] == 'm') && (str[2] == 'l') && (str[3] == 0))
 
 /* #define DEBUG_BUFFER */
 /* #define DEBUG_TREE */
 
 /************************************************************************
  *                                                                      *
- *              Functions to move to entities.c once the                *
+ *              Functions to move to entities.c once the                *
  *              API freeze is smoothen and they can be made public.     *
  *                                                                      *
  ************************************************************************/
 #include <libxml/hash.h>
- 
+
 #ifdef LIBXML_TREE_ENABLED
 /**
  * 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) {
     xmlEntitiesTablePtr table;
-    
+
     if((dtd != NULL) && (dtd->entities != NULL)) {
         table = (xmlEntitiesTablePtr) dtd->entities;
         return((xmlEntityPtr) xmlHashLookup(table, name));
-        /* return(xmlGetEntityFromTable(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) {
     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 40 matching lines @@
     memcpy(&ret[0], prefix, lenp);
     ret[lenp] = ':';
     memcpy(&ret[lenp + 1], ncname, lenn);
     ret[lenn + lenp + 1] = 0;
     return(ret);
 }
 
 /**
  * xmlSplitQName2:
  * @name:  the full QName
- * @prefix:  a xmlChar ** 
+ * @prefix:  a xmlChar **
  *
  * parse an XML qualified name string
  *
  * [NS 5] QName ::= (Prefix ':')? LocalPart
  *
  * [NS 6] Prefix ::= NCName
  *
  * [NS 7] LocalPart ::= NCName
  *
  * Returns NULL if not a QName, otherwise the local part, and prefix
@@ skipping 17 matching lines @@
 #endif
 
     /* nasty but valid */
     if (name[0] == ':')
         return(NULL);
 
     /*
      * we are not trying to validate but just to cut, and yes it will
      * work even if this is as set of UTF-8 encoded chars
      */
-    while ((name[len] != 0) && (name[len] != ':')) 
+    while ((name[len] != 0) && (name[len] != ':'))
         len++;
-    
+
     if (name[len] == 0)
         return(NULL);
 
     *prefix = xmlStrndup(name, len);
     if (*prefix == NULL) {
         xmlTreeErrMemory("QName split");
         return(NULL);
     }
     ret = xmlStrdup(&name[len + 1]);
     if (ret == NULL) {
@@ skipping 28 matching lines @@
     if (len == NULL) return(NULL);
 
     /* nasty but valid */
     if (name[0] == ':')
         return(NULL);
 
     /*
      * we are not trying to validate but just to cut, and yes it will
      * work even if this is as set of UTF-8 encoded chars
      */
-    while ((name[l] != 0) && (name[l] != ':')) 
+    while ((name[l] != 0) && (name[l] != ':'))
         l++;
-    
+
     if (name[l] == 0)
         return(NULL);
 
     *len = l;
 
     return(&name[l+1]);
 }
 
 /************************************************************************
  *                                                                      *
  *              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)
 /**
  * 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
  *
@@ skipping 302 matching lines @@
         return(1);
     return(0);
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 /************************************************************************
  *                                                                      *
  *              Allocation and deallocation of basic structures         *
  *                                                                      *
  ************************************************************************/
- 
+
 /**
  * xmlSetBufferAllocationScheme:
  * @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, 
+ * XML_BUFFER_ALLOC_DOUBLEIT - double buffer when extra needed,
  *                             improves performance
  */
 void
 xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme) {
-    xmlBufferAllocScheme = scheme;
+    if ((scheme == XML_BUFFER_ALLOC_EXACT) ||
+        (scheme == XML_BUFFER_ALLOC_DOUBLEIT))
+        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, 
+ * XML_BUFFER_ALLOC_DOUBLEIT - double buffer when extra needed,
  *                             improves performance
- * 
+ *
  * Returns the current allocation scheme
  */
 xmlBufferAllocationScheme
 xmlGetBufferAllocationScheme(void) {
     return(xmlBufferAllocScheme);
 }
 
 /**
  * xmlNewNs:
  * @node:  the element carrying the namespace
@@ skipping 22 matching lines @@
      */
     cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
     if (cur == NULL) {
         xmlTreeErrMemory("building namespace");
         return(NULL);
     }
     memset(cur, 0, sizeof(xmlNs));
     cur->type = XML_LOCAL_NAMESPACE;
 
     if (href != NULL)
-        cur->href = xmlStrdup(href); 
+        cur->href = xmlStrdup(href);
     if (prefix != NULL)
-        cur->prefix = xmlStrdup(prefix); 
+        cur->prefix = xmlStrdup(prefix);
 
     /*
      * Add it at the end to preserve parsing order ...
      * and checks for existing use of the prefix
      */
     if (node != NULL) {
         if (node->nsDef == NULL) {
             node->nsDef = cur;
         } else {
             xmlNsPtr prev = node->nsDef;
 
             if (((prev->prefix == NULL) && (cur->prefix == NULL)) ||
                 (xmlStrEqual(prev->prefix, cur->prefix))) {
                 xmlFreeNs(cur);
                 return(NULL);
-            }    
+            }
             while (prev->next != NULL) {
                 prev = prev->next;
                 if (((prev->prefix == NULL) && (cur->prefix == NULL)) ||
                     (xmlStrEqual(prev->prefix, cur->prefix))) {
                     xmlFreeNs(cur);
                     return(NULL);
-                }    
+                }
             }
             prev->next = cur;
         }
     }
     return(cur);
 }
 
 /**
  * xmlSetNs:
  * @node:  a node in the document
@@ skipping 88 matching lines @@
      */
     cur = (xmlDtdPtr) xmlMalloc(sizeof(xmlDtd));
     if (cur == NULL) {
         xmlTreeErrMemory("building DTD");
         return(NULL);
     }
     memset(cur, 0 , sizeof(xmlDtd));
     cur->type = XML_DTD_NODE;
 
     if (name != NULL)
-        cur->name = xmlStrdup(name); 
+        cur->name = xmlStrdup(name);
     if (ExternalID != NULL)
-        cur->ExternalID = xmlStrdup(ExternalID); 
+        cur->ExternalID = xmlStrdup(ExternalID);
     if (SystemID != NULL)
-        cur->SystemID = xmlStrdup(SystemID); 
+        cur->SystemID = xmlStrdup(SystemID);
     if (doc != NULL)
         doc->extSubset = cur;
     cur->doc = doc;
 
     if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
         xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
     return(cur);
 }
 
 /**
@@ skipping 57 matching lines @@
 
     if (name != NULL) {
         cur->name = xmlStrdup(name);
         if (cur->name == NULL) {
             xmlTreeErrMemory("building internal subset");
             xmlFree(cur);
             return(NULL);
         }
     }
     if (ExternalID != NULL) {
-        cur->ExternalID = xmlStrdup(ExternalID); 
+        cur->ExternalID = xmlStrdup(ExternalID);
         if (cur->ExternalID  == NULL) {
             xmlTreeErrMemory("building internal subset");
             if (cur->name != NULL)
                 xmlFree((char *)cur->name);
             xmlFree(cur);
             return(NULL);
         }
     }
     if (SystemID != NULL) {
-        cur->SystemID = xmlStrdup(SystemID); 
+        cur->SystemID = xmlStrdup(SystemID);
         if (cur->SystemID == NULL) {
             xmlTreeErrMemory("building internal subset");
             if (cur->name != NULL)
                 xmlFree((char *)cur->name);
             if (cur->ExternalID != NULL)
                 xmlFree((char *)cur->ExternalID);
             xmlFree(cur);
             return(NULL);
         }
     }
@@ skipping 42 matching lines @@
 }
 
 /**
  * DICT_FREE:
  * @str:  a string
  *
  * Free a string if it is not owned by the "dict" dictionnary in the
  * current scope
  */
 #define DICT_FREE(str)                                          \
-        if ((str) && ((!dict) ||                                \
+        if ((str) && ((!dict) ||                                \
             (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))  \
             xmlFree((char *)(str));
 
 
 /**
  * DICT_COPY:
  * @str:  a string
  *
  * Copy a string using a "dict" dictionnary in the current scope,
  * if availabe.
@@ skipping 62 matching lines @@
             }
             c = next;
         }
     }
     DICT_FREE(cur->name)
     DICT_FREE(cur->SystemID)
     DICT_FREE(cur->ExternalID)
     /* TODO !!! */
     if (cur->notations != NULL)
         xmlFreeNotationTable((xmlNotationTablePtr) cur->notations);
-    
+
     if (cur->elements != NULL)
         xmlFreeElementTable((xmlElementTablePtr) cur->elements);
     if (cur->attributes != NULL)
         xmlFreeAttributeTable((xmlAttributeTablePtr) cur->attributes);
     if (cur->entities != NULL)
         xmlFreeEntitiesTable((xmlEntitiesTablePtr) cur->entities);
     if (cur->pentities != NULL)
         xmlFreeEntitiesTable((xmlEntitiesTablePtr) cur->pentities);
 
     xmlFree(cur);
@@ skipping 18 matching lines @@
      * Allocate a new document and fill the fields.
      */
     cur = (xmlDocPtr) xmlMalloc(sizeof(xmlDoc));
     if (cur == NULL) {
         xmlTreeErrMemory("building doc");
         return(NULL);
     }
     memset(cur, 0, sizeof(xmlDoc));
     cur->type = XML_DOCUMENT_NODE;
 
-    cur->version = xmlStrdup(version); 
+    cur->version = xmlStrdup(version);
     if (cur->version == NULL) {
         xmlTreeErrMemory("building doc");
         xmlFree(cur);
-        return(NULL);
+        return(NULL);
     }
     cur->standalone = -1;
     cur->compression = -1; /* not initialized */
     cur->doc = cur;
+    cur->parseFlags = 0;
+    cur->properties = XML_DOC_USERBUILT;
     /*
      * The in memory encoding is always UTF8
      * This field will never change and would
      * be obsolete if not for binary compatibility.
      */
     cur->charset = XML_CHAR_ENCODING_UTF8;
 
     if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
         xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
     return(cur);
@@ skipping 107 matching lines @@
                 }
             }
             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')) 
+                    if ((tmp >= '0') && (tmp <= '9'))
                         charval = charval * 16 + (tmp - '0');
                     else if ((tmp >= 'a') && (tmp <= 'f'))
                         charval = charval * 16 + (tmp - 'a') + 10;
                     else if ((tmp >= 'A') && (tmp <= 'F'))
                         charval = charval * 16 + (tmp - 'A') + 10;
                     else {
                         xmlTreeErr(XML_TREE_INVALID_HEX, (xmlNodePtr) doc,
                                    NULL);
                         charval = 0;
                         break;
                     }
                     cur++;
                     if (cur < end)
                         tmp = *cur;
                     else
                         tmp = 0;
                 }
                 if (tmp == ';')
                     cur++;
                 q = cur;
             } else if ((cur + 1 < end) && (cur[1] == '#')) {
                 cur += 2;
                 if (cur < end)
                     tmp = *cur;
                 else
                     tmp = 0;
                 while (tmp != ';') { /* Non input consuming loops */
-                    if ((tmp >= '0') && (tmp <= '9')) 
+                    if ((tmp >= '0') && (tmp <= '9'))
                         charval = charval * 10 + (tmp - '0');
                     else {
                         xmlTreeErr(XML_TREE_INVALID_DEC, (xmlNodePtr) doc,
                                    NULL);
                         charval = 0;
                         break;
                     }
                     cur++;
                     if (cur < end)
                         tmp = *cur;
@@ skipping 24 matching lines @@
                     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);
-                            
+
                     } else {
                         /*
                          * Create a new REFERENCE_REF node
                          */
                         node = xmlNewReference(doc, val);
                         if (node == NULL) {
                             if (val != NULL) xmlFree(val);
                             return(ret);
                         }
                         else if ((ent != NULL) && (ent->children == NULL)) {
@@ skipping 42 matching lines @@
     if ((cur != q) || (ret == NULL)) {
         /*
          * Handle the last piece of text.
          */
         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;
+                ret = node;
             } else {
-                last = xmlAddNextSibling(last, node);
+                xmlAddNextSibling(last, node);
             }
         }
     }
     return(ret);
 }
 
 /**
  * xmlStringGetNodeList:
  * @doc:  the document
  * @value:  the value of the attribute
@@ skipping 35 matching lines @@
                         node->prev = last;
                         last = node;
                     }
                 }
             }
             q = cur;
             if ((cur[1] == '#') && (cur[2] == 'x')) {
                 cur += 3;
                 tmp = *cur;
                 while (tmp != ';') { /* Non input consuming loop */
-                    if ((tmp >= '0') && (tmp <= '9')) 
+                    if ((tmp >= '0') && (tmp <= '9'))
                         charval = charval * 16 + (tmp - '0');
                     else if ((tmp >= 'a') && (tmp <= 'f'))
                         charval = charval * 16 + (tmp - 'a') + 10;
                     else if ((tmp >= 'A') && (tmp <= 'F'))
                         charval = charval * 16 + (tmp - 'A') + 10;
                     else {
                         xmlTreeErr(XML_TREE_INVALID_HEX, (xmlNodePtr) doc,
                                    NULL);
                         charval = 0;
                         break;
                     }
                     cur++;
                     tmp = *cur;
                 }
                 if (tmp == ';')
                     cur++;
                 q = cur;
             } else if  (cur[1] == '#') {
                 cur += 2;
                 tmp = *cur;
                 while (tmp != ';') { /* Non input consuming loops */
-                    if ((tmp >= '0') && (tmp <= '9')) 
+                    if ((tmp >= '0') && (tmp <= '9'))
                         charval = charval * 10 + (tmp - '0');
                     else {
                         xmlTreeErr(XML_TREE_INVALID_DEC, (xmlNodePtr) doc,
                                    NULL);
                         charval = 0;
                         break;
                     }
                     cur++;
                     tmp = *cur;
                 }
@@ skipping 21 matching lines @@
                     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);
-                            
+
                     } else {
                         /*
                          * Create a new REFERENCE_REF node
                          */
                         node = xmlNewReference(doc, val);
                         if (node == NULL) {
                             if (val != NULL) xmlFree(val);
                             return(ret);
                         }
                         else if ((ent != NULL) && (ent->children == NULL)) {
@@ skipping 26 matching lines @@
                 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);
                     }
                 }
-
-                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);
@@ skipping 189 matching lines @@
             xmlFree((xmlChar *) name);
         return (NULL);
     }
 
     /*
      * Allocate a new property and fill the fields.
      */
     cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr));
     if (cur == NULL) {
         if ((eatname == 1) &&
-            ((node->doc == NULL) ||
+            ((node == NULL) || (node->doc == NULL) ||
              (!(xmlDictOwns(node->doc->dict, name)))))
             xmlFree((xmlChar *) name);
         xmlTreeErrMemory("building attribute");
         return (NULL);
     }
     memset(cur, 0, sizeof(xmlAttr));
     cur->type = XML_ATTRIBUTE_NODE;
 
     cur->parent = node;
     if (node != NULL) {
@@ skipping 39 matching lines @@
         } else {
             xmlAttrPtr prev = node->properties;
 
             while (prev->next != NULL)
                 prev = prev->next;
             prev->next = cur;
             cur->prev = prev;
         }
     }
 
-    if (xmlIsID((node == NULL) ? NULL : node->doc, node, cur) == 1)
+    if ((value != NULL) && (node != NULL) &&
+        (xmlIsID(node->doc, node, cur) == 1))
         xmlAddID(NULL, node->doc, value, cur);
 
     if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
         xmlRegisterNodeDefaultValue((xmlNodePtr) cur);
     return (cur);
 }
 
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
     defined(LIBXML_SCHEMAS_ENABLED)
 /**
@@ skipping 99 matching lines @@
         xmlTreeErrMemory("building attribute");
         return(NULL);
     }
     memset(cur, 0, sizeof(xmlAttr));
     cur->type = XML_ATTRIBUTE_NODE;
 
     if ((doc != NULL) && (doc->dict != NULL))
         cur->name = xmlDictLookup(doc->dict, name, -1);
     else
         cur->name = xmlStrdup(name);
-    cur->doc = doc; 
+    cur->doc = doc;
     if (value != NULL) {
         xmlNodePtr tmp;
 
         cur->children = xmlStringGetNodeList(doc, value);
         cur->last = NULL;
 
         tmp = cur->children;
         while (tmp != NULL) {
             tmp->parent = (xmlNodePtr) cur;
             if (tmp->next == NULL)
@@ skipping 186 matching lines @@
     /*
      * Allocate a new node and fill the fields.
      */
     cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
     if (cur == NULL) {
         xmlTreeErrMemory("building node");
         return(NULL);
     }
     memset(cur, 0, sizeof(xmlNode));
     cur->type = XML_ELEMENT_NODE;
-    
+
     cur->name = xmlStrdup(name);
     cur->ns = ns;
 
     if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
         xmlRegisterNodeDefaultValue(cur);
     return(cur);
 }
 
 /**
  * xmlNewNodeEatName:
@@ skipping 22 matching lines @@
      * Allocate a new node and fill the fields.
      */
     cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
     if (cur == NULL) {
         xmlTreeErrMemory("building node");
         /* we can't check here that name comes from the doc dictionnary */
         return(NULL);
     }
     memset(cur, 0, sizeof(xmlNode));
     cur->type = XML_ELEMENT_NODE;
-    
+
     cur->name = name;
     cur->ns = ns;
 
     if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
         xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
     return(cur);
 }
 
 /**
  * xmlNewDocNode:
@@ skipping 167 matching lines @@
  * @ns:  a namespace if any
  * @name:  the name of the child
  * @content:  the text content of the child if any.
  *
  * Creation of a new child element, added at the end of @parent children list.
  * @ns and @content parameters are optional (NULL). If @ns is NULL, the newly
  * created element inherits the namespace of @parent. If @content is non NULL,
  * a child TEXT node will be created containing the string @content.
  * NOTE: Use xmlNewChild() if @content will contain entities that need to be
  * preserved. Use this function, xmlNewTextChild(), if you need to ensure that
- * reserved XML chars that might appear in @content, such as the ampersand, 
- * greater-than or less-than signs, are automatically replaced by their XML 
- * escaped entity representations. 
+ * reserved XML chars that might appear in @content, such as the ampersand,
+ * greater-than or less-than signs, are automatically replaced by their XML
+ * escaped entity representations.
  *
  * Returns a pointer to the new node object.
  */
 xmlNodePtr
 xmlNewTextChild(xmlNodePtr parent, xmlNsPtr ns,
             const xmlChar *name, const xmlChar *content) {
     xmlNodePtr cur, prev;
 
     if (parent == NULL) {
 #ifdef DEBUG_TREE
@@ skipping 427 matching lines @@
         cur->prev = prev;
         parent->last = cur;
     }
 
     return(cur);
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 /**
  * xmlAddPropSibling:
- * @prev:  the attribute to which @prop is added after 
+ * @prev:  the attribute to which @prop is added after
  * @cur:   the base attribute passed to calling function
  * @prop:  the new attribute
  *
  * Add a new attribute after @prev using @cur as base attribute.
  * 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. 
+ * 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)
                 return(NULL);
 
@@ skipping 29 matching lines @@
 /**
  * xmlAddNextSibling:
  * @cur:  the child node
  * @elem:  the new node
  *
  * Add a new node @elem as the next sibling of @cur
  * 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. 
+ * 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) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlAddNextSibling : cur == NULL\n");
 #endif
@@ skipping 57 matching lines @@
 /**
  * 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. 
+ * 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) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlAddPrevSibling : cur == NULL\n");
 #endif
@@ skipping 79 matching lines @@
     }
 
     if (elem == NULL) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlAddSibling : elem == NULL\n");
 #endif
         return(NULL);
     }
 
+    if (cur == elem) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+                "xmlAddSibling : cur == elem\n");
+#endif
+        return(NULL);
+    }
+
     /*
      * Constant time is we can rely on the ->parent->last to find
      * the last sibling.
      */
-    if ((cur->type != XML_ATTRIBUTE_NODE) && (cur->parent != NULL) && 
+    if ((cur->type != XML_ATTRIBUTE_NODE) && (cur->parent != NULL) &&
         (cur->parent->children != NULL) &&
         (cur->parent->last != NULL) &&
         (cur->parent->last->next == NULL)) {
         cur = cur->parent->last;
     } else {
         while (cur->next != NULL) cur = cur->next;
     }
 
     xmlUnlinkNode(elem);
 
@@ skipping 61 matching lines @@
     /*
      * add the first element at the end of the children list.
      */
 
     if (parent->children == NULL) {
         parent->children = cur;
     } else {
         /*
          * If cur and parent->last both are TEXT nodes, then merge them.
          */
-        if ((cur->type == XML_TEXT_NODE) && 
+        if ((cur->type == XML_TEXT_NODE) &&
             (parent->last->type == XML_TEXT_NODE) &&
             (cur->name == parent->last->name)) {
-            xmlNodeAddContent(parent->last, cur->content);
+            xmlNodeAddContent(parent->last, cur->content);
             /*
              * if it's the only child, nothing more to be done.
              */
             if (cur->next == NULL) {
                 xmlFreeNode(cur);
                 return(parent->last);
             }
             prev = cur;
             cur = cur->next;
             xmlFreeNode(prev);
         }
         prev = parent->last;
         prev->next = cur;
         cur->prev = prev;
     }
     while (cur->next != NULL) {
         cur->parent = parent;
         if (cur->doc != parent->doc) {
             xmlSetTreeDoc(cur, parent->doc);
         }
         cur = cur->next;
     }
     cur->parent = parent;
-    cur->doc = parent->doc; /* the parent may not be linked to a doc ! */
+    /* the parent may not be linked to a doc ! */
+    if (cur->doc != parent->doc) {
+        xmlSetTreeDoc(cur, parent->doc);
+    }
     parent->last = cur;
 
     return(cur);
 }
 
 /**
  * xmlAddChild:
  * @parent:  the parent node
  * @cur:  the child node
  *
  * Add a new node to @parent, at the end of the child (or property) list
  * 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. 
+ * 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) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
@@ skipping 58 matching lines @@
     if ((parent->type == XML_TEXT_NODE) &&
         (parent->content != NULL) &&
         (parent != cur)) {
         xmlNodeAddContent(parent, cur->content);
         xmlFreeNode(cur);
         return(parent);
     }
     if (cur->type == XML_ATTRIBUTE_NODE) {
                 if (parent->type != XML_ELEMENT_NODE)
                         return(NULL);
-        if (parent->properties == NULL) {
-            parent->properties = (xmlAttrPtr) cur;
-        } else {
+        if (parent->properties != NULL) {
             /* check if an attribute with the same name exists */
             xmlAttrPtr lastattr;
 
             if (cur->ns == NULL)
                 lastattr = xmlHasNsProp(parent, cur->name, NULL);
             else
                 lastattr = xmlHasNsProp(parent, cur->name, cur->ns->href);
             if ((lastattr != NULL) && (lastattr != (xmlAttrPtr) cur) && (lastattr->type != XML_ATTRIBUTE_DECL)) {
                 /* different instance, destroy it (attributes must be unique) */
                         xmlUnlinkNode((xmlNodePtr) lastattr);
                 xmlFreeProp(lastattr);
             }
                 if (lastattr == (xmlAttrPtr) cur)
                         return(cur);
+
+        }
+        if (parent->properties == NULL) {
+            parent->properties = (xmlAttrPtr) cur;
+        } else {
             /* find the end */
-            lastattr = parent->properties;
+            xmlAttrPtr lastattr = parent->properties;
             while (lastattr->next != NULL) {
                 lastattr = lastattr->next;
             }
             lastattr->next = (xmlAttrPtr) cur;
             ((xmlAttrPtr) cur)->prev = lastattr;
         }
     } else {
         if (parent->children == NULL) {
             parent->children = cur;
             parent->last = cur;
@@ skipping 19 matching lines @@
     if (parent == NULL) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlGetLastChild : parent == NULL\n");
 #endif
         return(NULL);
     }
     return(parent->last);
 }
 
+#ifdef LIBXML_TREE_ENABLED
+/*
+ * 5 interfaces from DOM ElementTraversal
+ */
+
+/**
+ * xmlChildElementCount:
+ * @parent: the parent node
+ *
+ * Finds the current number of child nodes of that element which are
+ * element nodes.
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the count of element child or 0 if not available
+ */
+unsigned long
+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_HTML_DOCUMENT_NODE:
+            cur = parent->children;
+            break;
+        default:
+            return(0);
+    }
+    while (cur != NULL) {
+        if (cur->type == XML_ELEMENT_NODE)
+            ret++;
+        cur = cur->next;
+    }
+    return(ret);
+}
+
+/**
+ * xmlFirstElementChild:
+ * @parent: the parent node
+ *
+ * Finds the first child node of that element which is a Element node
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the first element child or NULL if not available
+ */
+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_HTML_DOCUMENT_NODE:
+            cur = parent->children;
+            break;
+        default:
+            return(NULL);
+    }
+    while (cur != NULL) {
+        if (cur->type == XML_ELEMENT_NODE)
+            return(cur);
+        cur = cur->next;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlLastElementChild:
+ * @parent: the parent node
+ *
+ * Finds the last child node of that element which is a Element node
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the last element child or NULL if not available
+ */
+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_HTML_DOCUMENT_NODE:
+            cur = parent->last;
+            break;
+        default:
+            return(NULL);
+    }
+    while (cur != NULL) {
+        if (cur->type == XML_ELEMENT_NODE)
+            return(cur);
+        cur = cur->prev;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlPreviousElementSibling:
+ * @node: the current node
+ *
+ * Finds the first closest previous sibling of the node which is an
+ * element node.
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the previous element sibling or NULL if not available
+ */
+xmlNodePtr
+xmlPreviousElementSibling(xmlNodePtr node) {
+    if (node == NULL)
+        return(NULL);
+    switch (node->type) {
+        case XML_ELEMENT_NODE:
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_ENTITY_REF_NODE:
+        case XML_ENTITY_NODE:
+        case XML_PI_NODE:
+        case XML_COMMENT_NODE:
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+            node = node->prev;
+            break;
+        default:
+            return(NULL);
+    }
+    while (node != NULL) {
+        if (node->type == XML_ELEMENT_NODE)
+            return(node);
+        node = node->prev;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlNextElementSibling:
+ * @node: the current node
+ *
+ * Finds the first closest next sibling of the node which is an
+ * element node.
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the next element sibling or NULL if not available
+ */
+xmlNodePtr
+xmlNextElementSibling(xmlNodePtr node) {
+    if (node == NULL)
+        return(NULL);
+    switch (node->type) {
+        case XML_ELEMENT_NODE:
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_ENTITY_REF_NODE:
+        case XML_ENTITY_NODE:
+        case XML_PI_NODE:
+        case XML_COMMENT_NODE:
+        case XML_DTD_NODE:
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+            node = node->next;
+            break;
+        default:
+            return(NULL);
+    }
+    while (node != NULL) {
+        if (node->type == XML_ELEMENT_NODE)
+            return(node);
+        node = node->next;
+    }
+    return(NULL);
+}
+
+#endif /* LIBXML_TREE_ENABLED */
+
 /**
  * xmlFreeNodeList:
  * @cur:  the first node in the list
  *
  * Free a node and all its siblings, this is a recursive behaviour, all
  * the children are freed too.
  */
 void
 xmlFreeNodeList(xmlNodePtr cur) {
     xmlNodePtr next;
@@ skipping 82 matching lines @@
     if (cur->type == XML_ATTRIBUTE_NODE) {
         xmlFreeProp((xmlAttrPtr) cur);
         return;
     }
 
     if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
         xmlDeregisterNodeDefaultValue(cur);
 
     if (cur->doc != NULL) dict = cur->doc->dict;
 
+    if (cur->type == XML_ENTITY_DECL) {
+        xmlEntityPtr ent = (xmlEntityPtr) cur;
+        DICT_FREE(ent->SystemID);
+        DICT_FREE(ent->ExternalID);
+    }
     if ((cur->children != NULL) &&
         (cur->type != XML_ENTITY_REF_NODE))
         xmlFreeNodeList(cur->children);
     if (((cur->type == XML_ELEMENT_NODE) ||
          (cur->type == XML_XINCLUDE_START) ||
          (cur->type == XML_XINCLUDE_END)) &&
         (cur->properties != NULL))
         xmlFreePropList(cur->properties);
     if ((cur->type != XML_ELEMENT_NODE) &&
         (cur->content != NULL) &&
@@ skipping 40 matching lines @@
     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;
         }
     }
+    if (cur->type == XML_ENTITY_DECL) {
+        xmlDocPtr doc;
+        doc = cur->doc;
+        if (doc != NULL) {
+            if (doc->intSubset != NULL) {
+                if (xmlHashLookup(doc->intSubset->entities, cur->name) == cur)
+                    xmlHashRemoveEntry(doc->intSubset->entities, cur->name,
+                                       NULL);
+                if (xmlHashLookup(doc->intSubset->pentities, cur->name) == cur)
+                    xmlHashRemoveEntry(doc->intSubset->pentities, cur->name,
+                                       NULL);
+            }
+            if (doc->extSubset != NULL) {
+                if (xmlHashLookup(doc->extSubset->entities, cur->name) == cur)
+                    xmlHashRemoveEntry(doc->extSubset->entities, cur->name,
+                                       NULL);
+                if (xmlHashLookup(doc->extSubset->pentities, cur->name) == cur)
+                    xmlHashRemoveEntry(doc->extSubset->pentities, cur->name,
+                                       NULL);
+            }
+        }
+    }
     if (cur->parent != NULL) {
         xmlNodePtr parent;
         parent = cur->parent;
         if (cur->type == XML_ATTRIBUTE_NODE) {
             if (parent->properties == (xmlAttrPtr) cur)
                 parent->properties = ((xmlAttrPtr) cur)->next;
         } else {
             if (parent->children == cur)
                 parent->children = cur->next;
             if (parent->last == cur)
@@ skipping 75 matching lines @@
     old->parent = NULL;
     return(old);
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 /************************************************************************
  *                                                                      *
  *              Copy operations                                         *
  *                                                                      *
  ************************************************************************/
- 
+
 /**
  * xmlCopyNamespace:
  * @cur:  the namespace
  *
  * Do a copy of the namespace.
  *
  * Returns: a new #xmlNsPtr, or NULL in case of error.
  */
 xmlNsPtr
 xmlCopyNamespace(xmlNsPtr cur) {
@@ skipping 96 matching lines @@
           /* this is the nice case */
           ret->ns = ns;
         } else {
           /*
            * we are in trouble: we need a new reconcilied namespace.
            * This is expensive
            */
           ret->ns = xmlNewReconciliedNs(target->doc, target, cur->ns);
         }
       }
- 
+
     } else
         ret->ns = NULL;
 
     if (cur->children != NULL) {
         xmlNodePtr tmp;
 
         ret->children = xmlStaticCopyNodeList(cur->children, ret->doc, (xmlNodePtr) ret);
         ret->last = NULL;
         tmp = ret->children;
         while (tmp != NULL) {
@@ skipping 100 matching lines @@
         case XML_ENTITY_NODE:
         case XML_PI_NODE:
         case XML_COMMENT_NODE:
         case XML_XINCLUDE_START:
         case XML_XINCLUDE_END:
             break;
         case XML_ATTRIBUTE_NODE:
                 return((xmlNodePtr) xmlCopyPropInternal(doc, parent, (xmlAttrPtr) node));
         case XML_NAMESPACE_DECL:
             return((xmlNodePtr) xmlCopyNamespaceList((xmlNsPtr) node));
-            
+
         case XML_DOCUMENT_NODE:
         case XML_HTML_DOCUMENT_NODE:
 #ifdef LIBXML_DOCB_ENABLED
         case XML_DOCB_DOCUMENT_NODE:
 #endif
 #ifdef LIBXML_TREE_ENABLED
             return((xmlNodePtr) xmlCopyDoc((xmlDocPtr) node, extended));
 #endif /* LIBXML_TREE_ENABLED */
         case XML_DOCUMENT_TYPE_NODE:
         case XML_NOTATION_NODE:
         case XML_DTD_NODE:
         case XML_ELEMENT_DECL:
         case XML_ATTRIBUTE_DECL:
         case XML_ENTITY_DECL:
             return(NULL);
     }
 
     /*
      * Allocate a new node and fill the fields.
      */
     ret = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
     if (ret == NULL) {
         xmlTreeErrMemory("copying node");
         return(NULL);
     }
     memset(ret, 0, sizeof(xmlNode));
     ret->type = node->type;
 
     ret->doc = doc;
-    ret->parent = parent; 
+    ret->parent = parent;
     if (node->name == xmlStringText)
         ret->name = xmlStringText;
     else if (node->name == xmlStringTextNoenc)
         ret->name = xmlStringTextNoenc;
     else if (node->name == xmlStringComment)
         ret->name = xmlStringComment;
     else if (node->name != NULL) {
         if ((doc != NULL) && (doc->dict != NULL))
             ret->name = xmlDictLookup(doc->dict, node->name, -1);
         else
@@ skipping 18 matching lines @@
          * the deregister-node callback is called; so we register ret now already
          */
         if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
             xmlRegisterNodeDefaultValue((xmlNodePtr)ret);
 
         tmp = xmlAddChild(parent, ret);
         /* node could have coalesced */
         if (tmp != ret)
             return(tmp);
     }
-    
+
     if (!extended)
         goto out;
-    if ((node->type == XML_ELEMENT_NODE) && (node->nsDef != NULL))
+    if (((node->type == XML_ELEMENT_NODE) ||
+         (node->type == XML_XINCLUDE_START)) && (node->nsDef != NULL))
         ret->nsDef = xmlCopyNamespaceList(node->nsDef);
 
     if (node->ns != NULL) {
         xmlNsPtr ns;
 
         ns = xmlSearchNs(doc, ret, node->ns->prefix);
         if (ns == NULL) {
             /*
              * Humm, we are copying an element whose namespace is defined
              * out of the new tree scope. Search it in the original tree
              * and add it at the top of the new tree
              */
             ns = xmlSearchNs(node->doc, node, node->ns->prefix);
             if (ns != NULL) {
                 xmlNodePtr root = ret;
 
                 while (root->parent != NULL) root = root->parent;
                 ret->ns = xmlNewNs(root, ns->href, ns->prefix);
+                } else {
+                        ret->ns = xmlNewReconciliedNs(doc, ret, node->ns);
             }
         } else {
             /*
              * reference the existing namespace definition in our own tree.
              */
             ret->ns = ns;
         }
     }
-    if ((node->type == XML_ELEMENT_NODE) && (node->properties != NULL))
+    if (((node->type == XML_ELEMENT_NODE) ||
+         (node->type == XML_XINCLUDE_START)) && (node->properties != NULL))
         ret->properties = xmlCopyPropList(ret, node->properties);
     if (node->type == XML_ENTITY_REF_NODE) {
         if ((doc == NULL) || (node->doc != doc)) {
             /*
              * The copied node will go into a separate document, so
              * to avoid dangling references to the ENTITY_DECL node
              * we cannot keep the reference. Try to find it in the
              * target document.
              */
             ret->children = (xmlNodePtr) xmlGetDocEntity(doc, ret->name);
@@ skipping 145 matching lines @@
                             (xmlNotationTablePtr) dtd->notations);
     if (dtd->elements != NULL)
         ret->elements = (void *) xmlCopyElementTable(
                             (xmlElementTablePtr) dtd->elements);
     if (dtd->attributes != NULL)
         ret->attributes = (void *) xmlCopyAttributeTable(
                             (xmlAttributeTablePtr) dtd->attributes);
     if (dtd->pentities != NULL)
         ret->pentities = (void *) xmlCopyEntitiesTable(
                             (xmlEntitiesTablePtr) dtd->pentities);
-    
+
     cur = dtd->children;
     while (cur != NULL) {
         q = NULL;
 
         if (cur->type == XML_ENTITY_DECL) {
             xmlEntityPtr tmp = (xmlEntityPtr) cur;
             switch (tmp->etype) {
                 case XML_INTERNAL_GENERAL_ENTITY:
                 case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
                 case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
                     q = (xmlNodePtr) xmlGetEntityFromDtd(ret, tmp->name);
                     break;
                 case XML_INTERNAL_PARAMETER_ENTITY:
                 case XML_EXTERNAL_PARAMETER_ENTITY:
-                    q = (xmlNodePtr) 
+                    q = (xmlNodePtr)
                         xmlGetParameterEntityFromDtd(ret, tmp->name);
                     break;
                 case XML_INTERNAL_PREDEFINED_ENTITY:
                     break;
             }
         } else if (cur->type == XML_ELEMENT_DECL) {
             xmlElementPtr tmp = (xmlElementPtr) cur;
             q = (xmlNodePtr)
                 xmlGetDtdQElementDesc(ret, tmp->name, tmp->prefix);
         } else if (cur->type == XML_ATTRIBUTE_DECL) {
             xmlAttributePtr tmp = (xmlAttributePtr) cur;
-            q = (xmlNodePtr) 
+            q = (xmlNodePtr)
                 xmlGetDtdQAttrDesc(ret, tmp->elem, tmp->name, tmp->prefix);
         } else if (cur->type == XML_COMMENT_NODE) {
             q = xmlCopyNode(cur, 0);
         }
-        
+
         if (q == NULL) {
             cur = cur->next;
             continue;
         }
-        
+
         if (p == NULL)
             ret->children = q;
         else
-            p->next = q;
-        
-        q->prev = p;
-        q->parent = (xmlNodePtr) ret;
+            p->next = q;
+
+        q->prev = p;
+        q->parent = (xmlNodePtr) ret;
         q->next = NULL;
         ret->last = q;
-        p = q;
+        p = q;
         cur = cur->next;
     }
 
     return(ret);
 }
 #endif
 
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
 /**
  * xmlCopyDoc:
@@ skipping 29 matching lines @@
     if (doc->intSubset != NULL) {
         ret->intSubset = xmlCopyDtd(doc->intSubset);
         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,
                                                (xmlNodePtr)ret);
         ret->last = NULL;
         tmp = ret->children;
         while (tmp != NULL) {
             if (tmp->next == NULL)
                 ret->last = tmp;
             tmp = tmp->next;
         }
     }
     return(ret);
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 /************************************************************************
  *                                                                      *
  *              Content access functions                                *
  *                                                                      *
  ************************************************************************/
- 
+
 /**
  * xmlGetLineNo:
  * @node: valid node
  *
  * Get line number of @node. This requires activation of this option
  * before invoking the parser by calling xmlLineNumbersDefault(1)
  *
  * Returns the line number if successful, -1 otherwise
  */
 long
@@ skipping 71 matching lines @@
                 break;
             sep = "/";
             next = NULL;
         } else if (cur->type == XML_ELEMENT_NODE) {
             generic = 0;
             sep = "/";
             name = (const char *) cur->name;
             if (cur->ns) {
                 if (cur->ns->prefix != NULL) {
                     snprintf(nametemp, sizeof(nametemp) - 1, "%s:%s",
-                        (char *)cur->ns->prefix, (char *)cur->name);
+                        (char *)cur->ns->prefix, (char *)cur->name);
                     nametemp[sizeof(nametemp) - 1] = 0;
                     name = nametemp;
                 } else {
                     /*
                     * We cannot express named elements in the default
                     * namespace, so use "*".
                     */
                     generic = 1;
                     name = "*";
-                }                
+                }
             }
             next = cur->parent;
 
             /*
              * Thumbler index computation
              * TODO: the ocurence test seems bogus for namespaced names
              */
             tmp = cur->prev;
             while (tmp != NULL) {
                 if ((tmp->type == XML_ELEMENT_NODE) &&
@@ skipping 67 matching lines @@
             * if yes, then we'll get "text()", otherwise "text()[1]".
             */
             if (occur == 0) {
                 tmp = cur->next;
                 while (tmp != NULL) {
                     if ((tmp->type == XML_TEXT_NODE) ||
                         (tmp->type == XML_CDATA_SECTION_NODE))
                     {
                         occur = 1;
                         break;
-                    }                   
+                    }
                     tmp = tmp->next;
                 }
             } else
                 occur++;
         } else if (cur->type == XML_PI_NODE) {
             sep = "/";
             snprintf(nametemp, sizeof(nametemp) - 1,
                      "processing-instruction('%s')", (char *)cur->name);
             nametemp[sizeof(nametemp) - 1] = 0;
             name = nametemp;
@@ skipping 22 matching lines @@
                     occur = 1;
             } else
                 occur++;
 
         } else if (cur->type == XML_ATTRIBUTE_NODE) {
             sep = "/@";
             name = (const char *) (((xmlAttrPtr) cur)->name);
             if (cur->ns) {
                 if (cur->ns->prefix != NULL)
                     snprintf(nametemp, sizeof(nametemp) - 1, "%s:%s",
-                        (char *)cur->ns->prefix, (char *)cur->name);
+                        (char *)cur->ns->prefix, (char *)cur->name);
                 else
                     snprintf(nametemp, sizeof(nametemp) - 1, "%s",
-                        (char *)cur->name);
+                        (char *)cur->name);
                 nametemp[sizeof(nametemp) - 1] = 0;
                 name = nametemp;
             }
             next = ((xmlAttrPtr) cur)->parent;
         } else {
             next = cur->parent;
         }
 
         /*
          * Make sure there is enough room
@@ skipping 47 matching lines @@
 
     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 ...).
  *
@@ skipping 21 matching lines @@
             doc->last = root;
         } else {
             xmlAddSibling(doc->children, root);
         }
     } else {
         xmlReplaceNode(old, root);
     }
     return(old);
 }
 #endif
- 
+
 #if defined(LIBXML_TREE_ENABLED)
 /**
  * xmlNodeSetLang:
  * @cur:  the node being changed
  * @lang:  the language description
  *
  * Set the language of a node, i.e. the values of the xml:lang
  * attribute.
  */
 void
@@ skipping 27 matching lines @@
         case XML_ELEMENT_NODE:
         case XML_ATTRIBUTE_NODE:
             break;
     }
     ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE);
     if (ns == NULL)
         return;
     xmlSetNsProp(cur, ns, BAD_CAST "lang", lang);
 }
 #endif /* LIBXML_TREE_ENABLED */
- 
+
 /**
  * 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) {
     xmlChar *lang;
 
     while (cur != NULL) {
         lang = xmlGetNsProp(cur, BAD_CAST "lang", XML_XML_NAMESPACE);
         if (lang != NULL)
             return(lang);
         cur = cur->parent;
     }
     return(NULL);
 }
- 
+
 
 #ifdef LIBXML_TREE_ENABLED
 /**
  * xmlNodeSetSpacePreserve:
  * @cur:  the node being changed
  * @val:  the xml:space value ("0": default, 1: "preserve")
  *
  * Set (or reset) the space preserving behaviour of a node, i.e. the
  * value of the xml:space attribute.
  */
@@ skipping 67 matching lines @@
             if (xmlStrEqual(space, BAD_CAST "default")) {
                 xmlFree(space);
                 return(0);
             }
             xmlFree(space);
         }
         cur = cur->parent;
     }
     return(-1);
 }
- 
+
 #ifdef LIBXML_TREE_ENABLED
 /**
  * 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) {
@@ skipping 37 matching lines @@
     if (dict != NULL) {
         if ((cur->name != NULL) && (!xmlDictOwns(dict, cur->name)))
             xmlFree((xmlChar *) cur->name);
         cur->name = xmlDictLookup(dict, name, -1);
     } else {
         if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
         cur->name = xmlStrdup(name);
     }
 }
 #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
  * xml:base attribute.
  */
 void
 xmlNodeSetBase(xmlNodePtr cur, const xmlChar* uri) {
     xmlNsPtr ns;
-    const xmlChar* fixed;
+    xmlChar* fixed;
 
     if (cur == 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:
         case XML_DTD_NODE:
@@ skipping 19 matching lines @@
 
             if (doc->URL != NULL)
                 xmlFree((xmlChar *) doc->URL);
             if (uri == NULL)
                 doc->URL = NULL;
             else
                 doc->URL = xmlPathToURI(uri);
             return;
         }
     }
-    
+
     ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE);
     if (ns == NULL)
         return;
     fixed = xmlPathToURI(uri);
     if (fixed != NULL) {
         xmlSetNsProp(cur, ns, BAD_CAST "base", fixed);
-        xmlFree((xmlChar *)fixed);
+        xmlFree(fixed);
     } else {
         xmlSetNsProp(cur, ns, BAD_CAST "base", uri);
     }
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 /**
  * xmlNodeGetBase:
  * @doc:  the document the node pertains to
  * @cur:  the node being checked
  *
  * 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
- * xmlDocumentGetBase() for this
+ * 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) {
     xmlChar *oldbase = NULL;
     xmlChar *base, *newbase;
 
-    if ((cur == NULL) && (doc == NULL)) 
+    if ((cur == NULL) && (doc == NULL))
         return(NULL);
-    if (doc == NULL) doc = cur->doc;    
+    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;
                 continue;
@@ skipping 41 matching lines @@
     }
     if ((doc != NULL) && (doc->URL != NULL)) {
         if (oldbase == NULL)
             return(xmlStrdup(doc->URL));
         newbase = xmlBuildURI(oldbase, doc->URL);
         xmlFree(oldbase);
         return(newbase);
     }
     return(oldbase);
 }
- 
+
 /**
  * xmlNodeBufGetContent:
  * @buffer:  a buffer
  * @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 @buffer with this value
- * 
+ *
  * Returns 0 in case of success and -1 in case of error.
  */
 int
 xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr cur)
 {
     if ((cur == NULL) || (buffer == NULL)) return(-1);
     switch (cur->type) {
         case XML_CDATA_SECTION_NODE:
         case XML_TEXT_NODE:
             xmlBufferCat(buffer, cur->content);
@@ skipping 258 matching lines @@
         case XML_CDATA_SECTION_NODE:
         case XML_ENTITY_REF_NODE:
         case XML_ENTITY_NODE:
         case XML_PI_NODE:
         case XML_COMMENT_NODE:
             if ((cur->content != NULL) &&
                 (cur->content != (xmlChar *) &(cur->properties))) {
                 if (!((cur->doc != NULL) && (cur->doc->dict != NULL) &&
                     (xmlDictOwns(cur->doc->dict, cur->content))))
                     xmlFree(cur->content);
-            }   
+            }
             if (cur->children != NULL) xmlFreeNodeList(cur->children);
             cur->last = cur->children = NULL;
             if (content != NULL) {
                 cur->content = xmlStrdup(content);
-            } else 
+            } else
                 cur->content = NULL;
             cur->properties = NULL;
             cur->nsDef = NULL;
             break;
         case XML_DOCUMENT_NODE:
         case XML_HTML_DOCUMENT_NODE:
         case XML_DOCUMENT_TYPE_NODE:
         case XML_XINCLUDE_START:
         case XML_XINCLUDE_END:
 #ifdef LIBXML_DOCB_ENABLED
@@ skipping 52 matching lines @@
         case XML_ENTITY_REF_NODE:
         case XML_ENTITY_NODE:
         case XML_PI_NODE:
         case XML_COMMENT_NODE:
         case XML_NOTATION_NODE:
             if ((cur->content != NULL) &&
                 (cur->content != (xmlChar *) &(cur->properties))) {
                 if (!((cur->doc != NULL) && (cur->doc->dict != NULL) &&
                     (xmlDictOwns(cur->doc->dict, cur->content))))
                     xmlFree(cur->content);
-            }   
+            }
             if (cur->children != NULL) xmlFreeNodeList(cur->children);
             cur->children = cur->last = NULL;
             if (content != NULL) {
                 cur->content = xmlStrndup(content, len);
-            } else 
+            } else
                 cur->content = NULL;
             cur->properties = NULL;
             cur->nsDef = NULL;
             break;
         case XML_DOCUMENT_NODE:
         case XML_DTD_NODE:
         case XML_HTML_DOCUMENT_NODE:
         case XML_DOCUMENT_TYPE_NODE:
         case XML_NAMESPACE_DECL:
         case XML_XINCLUDE_START:
@@ skipping 13 matching lines @@
             break;
     }
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 /**
  * xmlNodeAddContentLen:
  * @cur:  the node being modified
  * @content:  extra content
  * @len:  the size of @content
- * 
+ *
  * 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.
  */
 void
 xmlNodeAddContentLen(xmlNodePtr cur, const xmlChar *content, int len) {
     if (cur == NULL) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
@@ skipping 54 matching lines @@
         case XML_ATTRIBUTE_DECL:
         case XML_ENTITY_DECL:
             break;
     }
 }
 
 /**
  * xmlNodeAddContent:
  * @cur:  the node being modified
  * @content:  extra content
- * 
+ *
  * 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.
  */
 void
 xmlNodeAddContent(xmlNodePtr cur, const xmlChar *content) {
     int len;
 
     if (cur == NULL) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlNodeAddContent : node == NULL\n");
 #endif
         return;
     }
     if (content == NULL) return;
     len = xmlStrlen(content);
     xmlNodeAddContentLen(cur, content, len);
 }
 
 /**
  * xmlTextMerge:
  * @first:  the first text node
  * @second:  the second text node being merged
- * 
+ *
  * Merge two text nodes into one
  * Returns the first text node augmented
  */
 xmlNodePtr
 xmlTextMerge(xmlNodePtr first, xmlNodePtr second) {
     if (first == NULL) return(second);
     if (second == NULL) return(first);
     if (first->type != XML_TEXT_NODE) return(first);
     if (second->type != XML_TEXT_NODE) return(first);
     if (second->name != first->name)
@@ skipping 64 matching lines @@
         }
         node = node->parent;
     }
     return (ret);
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 /*
 * xmlTreeEnsureXMLDecl:
 * @doc: the doc
-* 
+*
 * Ensures that there is an XML namespace declaration on the doc.
-* 
+*
 * Returns the XML ns-struct or NULL on API and internal errors.
 */
 static xmlNsPtr
 xmlTreeEnsureXMLDecl(xmlDocPtr doc)
 {
     if (doc == NULL)
         return (NULL);
     if (doc->oldNs != NULL)
         return (doc->oldNs);
     {
         xmlNsPtr ns;
         ns = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
         if (ns == NULL) {
             xmlTreeErrMemory(
                 "allocating the XML namespace");
             return (NULL);
         }
         memset(ns, 0, sizeof(xmlNs));
         ns->type = XML_LOCAL_NAMESPACE;
-        ns->href = xmlStrdup(XML_XML_NAMESPACE); 
+        ns->href = xmlStrdup(XML_XML_NAMESPACE);
         ns->prefix = xmlStrdup((const xmlChar *)"xml");
         doc->oldNs = ns;
         return (ns);
     }
 }
 
 /**
  * xmlSearchNs:
  * @doc:  the document
  * @node:  the current node
  * @nameSpace:  the namespace prefix
  *
  * 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.
  *
  * Returns the namespace pointer or NULL.
  */
 xmlNsPtr
 xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace) {
-        
+
     xmlNsPtr cur;
     xmlNodePtr orig = node;
 
     if (node == NULL) 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) {
                 xmlTreeErrMemory("searching namespace");
                 return(NULL);
             }
             memset(cur, 0, sizeof(xmlNs));
             cur->type = XML_LOCAL_NAMESPACE;
-            cur->href = xmlStrdup(XML_XML_NAMESPACE); 
-            cur->prefix = xmlStrdup((const xmlChar *)"xml"); 
+            cur->href = xmlStrdup(XML_XML_NAMESPACE);
+            cur->prefix = xmlStrdup((const xmlChar *)"xml");
             cur->next = node->nsDef;
             node->nsDef = cur;
             return(cur);
         }
         if (doc == NULL) {
             doc = node->doc;
             if (doc == NULL)
                 return(NULL);
         }
         /*
@@ skipping 14 matching lines @@
             while (cur != NULL) {
                 if ((cur->prefix == NULL) && (nameSpace == NULL) &&
                     (cur->href != NULL))
                     return(cur);
                 if ((cur->prefix != NULL) && (nameSpace != NULL) &&
                     (cur->href != NULL) &&
                     (xmlStrEqual(cur->prefix, nameSpace)))
                     return(cur);
                 cur = cur->next;
             }
-            if (orig != node) { 
+            if (orig != node) {
                 cur = node->ns;
                 if (cur != NULL) {
                     if ((cur->prefix == NULL) && (nameSpace == NULL) &&
                         (cur->href != NULL))
                         return(cur);
                     if ((cur->prefix != NULL) && (nameSpace != NULL) &&
                         (cur->href != NULL) &&
                         (xmlStrEqual(cur->prefix, nameSpace)))
                         return(cur);
                 }
-            }    
+            }
         }
         node = node->parent;
     }
     return(NULL);
 }
 
 /**
  * xmlNsInScope:
  * @doc:  the document
  * @node:  the current node
  * @ancestor:  the ancestor carrying the namespace
  * @prefix:  the namespace prefix
  *
  * Verify that the given namespace held on @ancestor is still in scope
  * on node.
- * 
+ *
  * Returns 1 if true, 0 if false and -1 in case of error.
  */
 static int
 xmlNsInScope(xmlDocPtr doc ATTRIBUTE_UNUSED, xmlNodePtr node,
              xmlNodePtr ancestor, const xmlChar * prefix)
 {
     xmlNsPtr tst;
 
     while ((node != NULL) && (node != ancestor)) {
         if ((node->type == XML_ENTITY_REF_NODE) ||
@@ skipping 12 matching lines @@
                     return (0);
                 tst = tst->next;
             }
         }
         node = node->parent;
     }
     if (node != ancestor)
         return (-1);
     return (1);
 }
-                  
+
 /**
  * xmlSearchNsByHref:
  * @doc:  the document
  * @node:  the current node
  * @href:  the namespace value
  *
  * Search a Ns aliasing a given URI. Recurse on the parents until it finds
  * the defined namespace or return NULL otherwise.
  * Returns the namespace pointer or NULL.
  */
@@ skipping 33 matching lines @@
             doc = node->doc;
             if (doc == NULL)
                 return(NULL);
         }
         /*
         * Return the XML namespace declaration held by the doc.
         */
         if (doc->oldNs == NULL)
             return(xmlTreeEnsureXMLDecl(doc));
         else
-            return(doc->oldNs);        
+            return(doc->oldNs);
     }
     is_attr = (node->type == XML_ATTRIBUTE_NODE);
     while (node != NULL) {
         if ((node->type == XML_ENTITY_REF_NODE) ||
             (node->type == XML_ENTITY_NODE) ||
             (node->type == XML_ENTITY_DECL))
             return (NULL);
         if (node->type == XML_ELEMENT_NODE) {
             cur = node->nsDef;
             while (cur != NULL) {
                 if ((cur->href != NULL) && (href != NULL) &&
                     (xmlStrEqual(cur->href, href))) {
                     if (((!is_attr) || (cur->prefix != NULL)) &&
                         (xmlNsInScope(doc, orig, node, cur->prefix) == 1))
                         return (cur);
                 }
                 cur = cur->next;
             }
             if (orig != node) {
                 cur = node->ns;
                 if (cur != NULL) {
                     if ((cur->href != NULL) && (href != NULL) &&
                         (xmlStrEqual(cur->href, href))) {
                         if (((!is_attr) || (cur->prefix != NULL)) &&
                             (xmlNsInScope(doc, orig, node, cur->prefix) == 1))
                             return (cur);
                     }
                 }
-            }    
+            }
         }
         node = node->parent;
     }
     return (NULL);
 }
 
 /**
  * xmlNewReconciliedNs:
  * @doc:  the document
  * @tree:  a node expected to hold the new namespace
  * @ns:  the original namespace
  *
  * This function tries to locate a namespace definition in a tree
  * ancestors, or create a new namespace definition node similar to
  * @ns trying to reuse the same prefix. However if the given prefix is
  * 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
  */
-xmlNsPtr
+static xmlNsPtr
 xmlNewReconciliedNs(xmlDocPtr doc, xmlNodePtr tree, xmlNsPtr ns) {
     xmlNsPtr def;
     xmlChar prefix[50];
     int counter = 1;
 
     if (tree == NULL) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                 "xmlNewReconciliedNs : tree == NULL\n");
 #endif
@@ skipping 22 matching lines @@
     else
         snprintf((char *) prefix, sizeof(prefix), "%.20s", (char *)ns->prefix);
 
     def = xmlSearchNs(doc, tree, prefix);
     while (def != NULL) {
         if (counter > 1000) return(NULL);
         if (ns->prefix == NULL)
             snprintf((char *) prefix, sizeof(prefix), "default%d", counter++);
         else
             snprintf((char *) prefix, sizeof(prefix), "%.20s%d",
-                (char *)ns->prefix, counter++);
+                (char *)ns->prefix, counter++);
         def = xmlSearchNs(doc, tree, prefix);
     }
 
     /*
      * OK, now we are ready to create a new one.
      */
     def = xmlNewNs(tree, ns->href, prefix);
     return(def);
 }
 
@@ skipping 174 matching lines @@
                 if ((node != tree) && (node->next != NULL)) {
                     node = node->next;
                     break;
                 }
                 if (node->parent == NULL) {
                     node = NULL;
                     break;
                 }
             }
             /* exit condition */
-            if (node == tree) 
+            if (node == tree)
                 node = NULL;
         } else
             break;
     }
     if (oldNs != NULL)
         xmlFree(oldNs);
     if (newNs != NULL)
         xmlFree(newNs);
     return(ret);
 }
@@ skipping 35 matching lines @@
             } while (prop != NULL);
         }
     }
 
 #ifdef LIBXML_TREE_ENABLED
     if (! useDTD)
         return(NULL);
     /*
      * Check if there is a default/fixed attribute declaration in
      * the internal or external subset.
-     */    
+     */
     if ((node->doc != NULL) && (node->doc->intSubset != NULL)) {
         xmlDocPtr doc = node->doc;
         xmlAttributePtr attrDecl = NULL;
         xmlChar *elemQName, *tmpstr = NULL;
 
         /*
-        * We need the QName of the element for the DTD-lookup.  
+        * We need the QName of the element for the DTD-lookup.
         */
         if ((node->ns != NULL) && (node->ns->prefix != NULL)) {
             tmpstr = xmlStrdup(node->ns->prefix);
             tmpstr = xmlStrcat(tmpstr, BAD_CAST ":");
             tmpstr = xmlStrcat(tmpstr, node->name);
             if (tmpstr == NULL)
                 return(NULL);
             elemQName = tmpstr;
         } else
             elemQName = (xmlChar *) node->name;
@@ skipping 30 matching lines @@
                     if (doc->extSubset != NULL) {
                         attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, elemQName,
                             name, (*cur)->prefix);
                         if (attrDecl)
                             break;
                     }
                 }
                 cur++;
             }
             xmlFree(nsList);
-        }       
+        }
         if (tmpstr != NULL)
             xmlFree(tmpstr);
         /*
         * Only default/fixed attrs are relevant.
         */
         if ((attrDecl != NULL) && (attrDecl->defaultValue != NULL))
             return((xmlAttrPtr) attrDecl);
     }
 #endif /* LIBXML_TREE_ENABLED */
     return(NULL);
@@ skipping 23 matching lines @@
 
                 ret = xmlNodeListGetString(prop->doc, prop->children, 1);
                 if (ret != NULL)
                     return(ret);
             }
         }
         return(xmlStrdup((xmlChar *)""));
     } else if (prop->type == XML_ATTRIBUTE_DECL) {
         return(xmlStrdup(((xmlAttributePtr)prop)->defaultValue));
     }
-    return(NULL); 
+    return(NULL);
 }
 
 /**
  * xmlHasProp:
  * @node:  the node
  * @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 
+ * Returns the attribute or the attribute declaration or NULL if
  *         neither was found.
  */
 xmlAttrPtr
 xmlHasProp(xmlNodePtr node, const xmlChar *name) {
     xmlAttrPtr prop;
     xmlDocPtr doc;
 
     if ((node == NULL) || (node->type != XML_ELEMENT_NODE) || (name == NULL))
         return(NULL);
     /*
@@ skipping 61 matching lines @@
  * 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) {
-    xmlAttrPtr prop;    
+    xmlAttrPtr prop;
 
     prop = xmlHasProp(node, name);
     if (prop == NULL)
         return(NULL);
-    return(xmlGetPropNodeValueInternal(prop));     
+    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) {
     xmlAttrPtr prop;
-    
+
     prop = xmlGetPropNodeInternal(node, name, NULL, xmlCheckDTD);
     if (prop == NULL)
         return(NULL);
     return(xmlGetPropNodeValueInternal(prop));
 }
 
 /**
  * xmlGetNsProp:
  * @node:  the node
  * @name:  the attribute name
@@ skipping 45 matching lines @@
  * @node:  the node
  * @ns:  the namespace definition
  * @name:  the attribute name
  *
  * Remove an attribute carried by a node.
  * Returns 0 if successful, -1 if not found
  */
 int
 xmlUnsetNsProp(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name) {
     xmlAttrPtr prop;
-    
+
     prop = xmlGetPropNodeInternal(node, name, (ns != NULL) ? ns->href : NULL, 0);
     if (prop == NULL)
         return(-1);
     xmlUnlinkNode((xmlNodePtr) prop);
     xmlFreeProp(prop);
     return(0);
 }
 #endif
 
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
 /**
  * xmlSetProp:
  * @node:  the node
  * @name:  the attribute name (a QName)
  * @value:  the attribute value
  *
  * Set (or reset) an attribute 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.
  * Returns the attribute pointer.
- * 
+ *
  */
 xmlAttrPtr
 xmlSetProp(xmlNodePtr node, const xmlChar *name, const xmlChar *value) {
     int len;
     const xmlChar *nqname;
 
     if ((node == NULL) || (name == NULL) || (node->type != XML_ELEMENT_NODE))
         return(NULL);
 
     /*
@@ skipping 22 matching lines @@
  * Set (or reset) an attribute carried by a node.
  * The ns structure must be in scope, this is not checked
  *
  * Returns the attribute pointer.
  */
 xmlAttrPtr
 xmlSetNsProp(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name,
              const xmlChar *value)
 {
     xmlAttrPtr prop;
-    
+
     if (ns && (ns->href == NULL))
         return(NULL);
     prop = xmlGetPropNodeInternal(node, name, (ns != NULL) ? ns->href : NULL, 0);
     if (prop != NULL) {
         /*
         * Modify the attribute's value.
         */
         if (prop->atype == XML_ATTRIBUTE_ID) {
             xmlRemoveID(node->doc, prop);
             prop->atype = XML_ATTRIBUTE_ID;
         }
-        if (prop->children != NULL) 
+        if (prop->children != NULL)
             xmlFreeNodeList(prop->children);
         prop->children = NULL;
         prop->last = NULL;
         prop->ns = ns;
         if (value != NULL) {
             xmlNodePtr tmp;
-            
+
             if(!xmlCheckUTF8(value)) {
                 xmlTreeErr(XML_TREE_NOT_UTF8, (xmlNodePtr) node->doc,
                            NULL);
                 if (node->doc != NULL)
                     node->doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
             }
             prop->children = xmlNewDocText(node->doc, value);
             prop->last = NULL;
             tmp = prop->children;
             while (tmp != NULL) {
@@ skipping 11 matching lines @@
     * No equal attr found; create a new one.
     */
     return(xmlNewPropInternal(node, ns, name, value, 0));
 }
 
 #endif /* LIBXML_TREE_ENABLED */
 
 /**
  * xmlNodeIsText:
  * @node:  the node
- * 
+ *
  * Is this node a Text node ?
  * Returns 1 yes, 0 no
  */
 int
 xmlNodeIsText(xmlNodePtr 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) {
     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);
         cur++;
     }
 
     return(1);
 }
 
 /**
  * xmlTextConcat:
  * @node:  the node
  * @content:  the content
  * @len:  @content length
- * 
+ *
  * Concat the given string at the end of the existing node content
  *
  * Returns -1 in case of error, 0 otherwise
  */
 
 int
 xmlTextConcat(xmlNodePtr node, const xmlChar *content, int len) {
     if (node == NULL) return(-1);
 
     if ((node->type != XML_TEXT_NODE) &&
@@ skipping 44 matching lines @@
     ret->use = 0;
     ret->size = xmlDefaultBufferSize;
     ret->alloc = xmlBufferAllocScheme;
     ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
     if (ret->content == NULL) {
         xmlTreeErrMemory("creating buffer");
         xmlFree(ret);
         return(NULL);
     }
     ret->content[0] = 0;
+    ret->contentIO = NULL;
     return(ret);
 }
 
 /**
  * xmlBufferCreateSize:
  * @size: initial size of buffer
  *
  * routine to create an XML buffer.
  * returns the new structure.
  */
@@ skipping 12 matching lines @@
     if (ret->size){
         ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
         if (ret->content == NULL) {
             xmlTreeErrMemory("creating buffer");
             xmlFree(ret);
             return(NULL);
         }
         ret->content[0] = 0;
     } else
         ret->content = NULL;
+    ret->contentIO = NULL;
     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
@@ skipping 21 matching lines @@
 }
 
 /**
  * xmlBufferSetAllocationScheme:
  * @buf:  the buffer to tune
  * @scheme:  allocation scheme to use
  *
  * Sets the allocation scheme for this buffer
  */
 void
-xmlBufferSetAllocationScheme(xmlBufferPtr buf, 
+xmlBufferSetAllocationScheme(xmlBufferPtr buf,
                              xmlBufferAllocationScheme scheme) {
     if (buf == NULL) {
 #ifdef DEBUG_BUFFER
         xmlGenericError(xmlGenericErrorContext,
                 "xmlBufferSetAllocationScheme: buf == NULL\n");
 #endif
         return;
     }
-    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
-
-    buf->alloc = scheme;
+    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_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.
  */
 void
 xmlBufferFree(xmlBufferPtr buf) {
     if (buf == NULL) {
 #ifdef DEBUG_BUFFER
         xmlGenericError(xmlGenericErrorContext,
                 "xmlBufferFree: buf == NULL\n");
 #endif
         return;
     }
 
-    if ((buf->content != NULL) &&
+    if ((buf->alloc == XML_BUFFER_ALLOC_IO) &&
+        (buf->contentIO != NULL)) {
+        xmlFree(buf->contentIO);
+    } else if ((buf->content != NULL) &&
         (buf->alloc != XML_BUFFER_ALLOC_IMMUTABLE)) {
         xmlFree(buf->content);
     }
     xmlFree(buf);
 }
 
 /**
  * xmlBufferEmpty:
  * @buf:  the buffer
  *
  * empty a buffer.
  */
 void
 xmlBufferEmpty(xmlBufferPtr buf) {
     if (buf == NULL) return;
     if (buf->content == NULL) return;
     buf->use = 0;
     if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) {
         buf->content = BAD_CAST "";
+    } else if ((buf->alloc == XML_BUFFER_ALLOC_IO) &&
+               (buf->contentIO != NULL)) {
+        size_t start_buf = buf->content - buf->contentIO;
+
+        buf->size += start_buf;
+        buf->content = buf->contentIO;
+        buf->content[0] = 0;
     } else {
-        memset(buf->content, 0, buf->size);
+        buf->content[0] = 0;
     }
 }
 
 /**
  * xmlBufferShrink:
  * @buf:  the buffer to dump
  * @len:  the number of xmlChar to remove
  *
  * Remove the beginning of an XML buffer.
  *
  * Returns the number of #xmlChar removed, or -1 in case of failure.
  */
 int
 xmlBufferShrink(xmlBufferPtr buf, unsigned int len) {
     if (buf == NULL) return(-1);
     if (len == 0) return(0);
     if (len > buf->use) return(-1);
 
     buf->use -= len;
-    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) {
+    if ((buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) ||
+        ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL))) {
+        /*
+         * we just move the content pointer, but also make sure
+         * the perceived buffer size has shrinked accordingly
+         */
         buf->content += len;
+        buf->size -= len;
+
+        /*
+         * sometimes though it maybe be better to really shrink
+         * on IO buffers
+         */
+        if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) {
+            size_t start_buf = buf->content - buf->contentIO;
+            if (start_buf >= buf->size) {
+                memmove(buf->contentIO, &buf->content[0], buf->use);
+                buf->content = buf->contentIO;
+                buf->content[buf->use] = 0;
+                buf->size += start_buf;
+            }
+        }
     } else {
-        memmove(buf->content, &buf->content[len], buf->use * sizeof(xmlChar));
+        memmove(buf->content, &buf->content[len], buf->use);
         buf->content[buf->use] = 0;
     }
     return(len);
 }
 
 /**
  * xmlBufferGrow:
  * @buf:  the buffer
  * @len:  the minimum free size to allocate
  *
  * Grow the available space of an XML buffer.
  *
  * Returns the new available space or -1 in case of error
  */
 int
 xmlBufferGrow(xmlBufferPtr buf, unsigned int len) {
     int size;
     xmlChar *newbuf;
 
     if (buf == NULL) return(-1);
 
     if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return(0);
     if (len + buf->use < buf->size) return(0);
 
-/*
- * Windows has a BIG problem on realloc timing, so we try to double
- * the buffer size (if that's enough) (bug 146697)
- */
-#ifdef WIN32
+    /*
+     * Windows has a BIG problem on realloc timing, so we try to double
+     * the buffer size (if that's enough) (bug 146697)
+     * Apparently BSD too, and it's probably best for linux too
+     * On an embedded system this may be something to change
+     */
+#if 1
     if (buf->size > len)
         size = buf->size * 2;
     else
         size = buf->use + len + 100;
 #else
     size = buf->use + len + 100;
 #endif
 
-    newbuf = (xmlChar *) xmlRealloc(buf->content, size);
-    if (newbuf == NULL) {
-        xmlTreeErrMemory("growing buffer");
-        return(-1);
+    if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) {
+        size_t start_buf = buf->content - buf->contentIO;
+
+        newbuf = (xmlChar *) xmlRealloc(buf->contentIO, start_buf + size);
+        if (newbuf == NULL) {
+            xmlTreeErrMemory("growing buffer");
+            return(-1);
+        }
+        buf->contentIO = newbuf;
+        buf->content = newbuf + start_buf;
+    } else {
+        newbuf = (xmlChar *) xmlRealloc(buf->content, size);
+        if (newbuf == NULL) {
+            xmlTreeErrMemory("growing buffer");
+            return(-1);
+        }
+        buf->content = newbuf;
     }
-    buf->content = newbuf;
     buf->size = size;
     return(buf->size - buf->use);
 }
 
 /**
  * xmlBufferDump:
  * @file:  the file output
  * @buf:  the buffer to dump
  *
  * Dumps an XML buffer to  a FILE *.
@@ skipping 36 matching lines @@
 xmlBufferContent(const xmlBufferPtr buf)
 {
     if(!buf)
         return NULL;
 
     return buf->content;
 }
 
 /**
  * xmlBufferLength:
- * @buf:  the buffer 
+ * @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)
 {
     if(!buf)
         return 0;
 
     return buf->use;
 }
 
 /**
  * xmlBufferResize:
  * @buf:  the buffer to resize
  * @size:  the desired size
  *
  * Resize a buffer to accommodate minimum size of @size.
  *
  * Returns  0 in case of problems, 1 otherwise
  */
 int
 xmlBufferResize(xmlBufferPtr buf, unsigned int size)
 {
     unsigned int newSize;
     xmlChar* rebuf = NULL;
+    size_t start_buf;
 
     if (buf == NULL)
         return(0);
 
     if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return(0);
 
     /* Don't resize if we don't have to */
     if (size < buf->size)
         return 1;
 
     /* figure out new size */
     switch (buf->alloc){
-    case XML_BUFFER_ALLOC_DOUBLEIT:
-        /*take care of empty case*/
-        newSize = (buf->size ? buf->size*2 : size + 10);
-        while (size > newSize) newSize *= 2;
-        break;
-    case XML_BUFFER_ALLOC_EXACT:
-        newSize = size+10;
-        break;
-    default:
-        newSize = size+10;
-        break;
+        case XML_BUFFER_ALLOC_IO:
+        case XML_BUFFER_ALLOC_DOUBLEIT:
+            /*take care of empty case*/
+            newSize = (buf->size ? buf->size*2 : size + 10);
+            while (size > newSize) {
+                if (newSize > UINT_MAX / 2) {
+                    xmlTreeErrMemory("growing buffer");
+                    return 0;
+                }
+                newSize *= 2;
+            }
+            break;
+        case XML_BUFFER_ALLOC_EXACT:
+            newSize = size+10;
+            break;
+        default:
+            newSize = size+10;
+            break;
     }
 
-    if (buf->content == NULL)
-        rebuf = (xmlChar *) xmlMallocAtomic(newSize * sizeof(xmlChar));
-    else if (buf->size - buf->use < 100) {
-        rebuf = (xmlChar *) xmlRealloc(buf->content, 
-                                       newSize * sizeof(xmlChar));
-   } else {
-        /*
-         * if we are reallocating a buffer far from being full, it's
-         * better to make a new allocation and copy only the used range
-         * and free the old one.
-         */
-        rebuf = (xmlChar *) xmlMallocAtomic(newSize * sizeof(xmlChar));
-        if (rebuf != NULL) {
-            memcpy(rebuf, buf->content, buf->use);
-            xmlFree(buf->content);
-            rebuf[buf->use] = 0;
+    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 */
+            memmove(buf->contentIO, buf->content, buf->use);
+            buf->content = buf->contentIO;
+            buf->content[buf->use] = 0;
+            buf->size += start_buf;
+        } else {
+            rebuf = (xmlChar *) xmlRealloc(buf->contentIO, start_buf + newSize);
+            if (rebuf == NULL) {
+                xmlTreeErrMemory("growing buffer");
+                return 0;
+            }
+            buf->contentIO = rebuf;
+            buf->content = rebuf + start_buf;
         }
+    } else {
+        if (buf->content == NULL) {
+            rebuf = (xmlChar *) xmlMallocAtomic(newSize);
+        } else if (buf->size - buf->use < 100) {
+            rebuf = (xmlChar *) xmlRealloc(buf->content, newSize);
+        } else {
+            /*
+             * if we are reallocating a buffer far from being full, it's
+             * better to make a new allocation and copy only the used range
+             * and free the old one.
+             */
+            rebuf = (xmlChar *) xmlMallocAtomic(newSize);
+            if (rebuf != NULL) {
+                memcpy(rebuf, buf->content, buf->use);
+                xmlFree(buf->content);
+                rebuf[buf->use] = 0;
+            }
+        }
+        if (rebuf == NULL) {
+            xmlTreeErrMemory("growing buffer");
+            return 0;
+        }
+        buf->content = rebuf;
     }
-    if (rebuf == NULL) {
-        xmlTreeErrMemory("growing buffer");
-        return 0;
-    }
-    buf->content = rebuf;
     buf->size = newSize;
 
     return 1;
 }
 
 /**
  * xmlBufferAdd:
  * @buf:  the buffer to dump
  * @str:  the #xmlChar string
  * @len:  the number of #xmlChar to add
@@ skipping 74 matching lines @@
 #endif
         return -1;
     }
     if (len == 0) return 0;
 
     if (len < 0)
         len = xmlStrlen(str);
 
     if (len <= 0) return -1;
 
+    if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) {
+        size_t start_buf = buf->content - buf->contentIO;
+
+        if (start_buf > (unsigned int) len) {
+            /*
+             * We can add it in the space previously shrinked
+             */
+            buf->content -= len;
+            memmove(&buf->content[0], str, len);
+            buf->use += len;
+            buf->size += len;
+            return(0);
+        }
+    }
     needSize = buf->use + len + 2;
     if (needSize > buf->size){
         if (!xmlBufferResize(buf, needSize)){
             xmlTreeErrMemory("growing buffer");
             return XML_ERR_NO_MEMORY;
         }
     }
 
-    memmove(&buf->content[len], &buf->content[0], buf->use * sizeof(xmlChar));
-    memmove(&buf->content[0], str, len * sizeof(xmlChar));
+    memmove(&buf->content[len], &buf->content[0], buf->use);
+    memmove(&buf->content[0], str, len);
     buf->use += len;
     buf->content[buf->use] = 0;
     return 0;
 }
 
 /**
  * xmlBufferCat:
  * @buf:  the buffer to add to
  * @str:  the #xmlChar string
  *
@@ skipping 226 matching lines @@
     if ((m)->last == NULL) \
         (m)->first = NULL; \
     else \
         (m)->last->next = NULL; \
     (i)->next = (m)->pool; \
     (m)->pool = i;
 
 /*
 * xmlDOMWrapNsMapFree:
 * @map: the ns-map
-* 
+*
 * Frees the ns-map
 */
 static void
 xmlDOMWrapNsMapFree(xmlNsMapPtr nsmap)
 {
     xmlNsMapItemPtr cur, tmp;
 
     if (nsmap == NULL)
         return;
     cur = nsmap->pool;
@@ skipping 10 matching lines @@
     }
     xmlFree(nsmap);
 }
 
 /*
 * xmlDOMWrapNsMapAddItem:
 * @map: the ns-map
 * @oldNs: the old ns-struct
 * @newNs: the new ns-struct
 * @depth: depth and ns-kind information
-* 
+*
 * Adds an ns-mapping item.
 */
 static xmlNsMapItemPtr
 xmlDOMWrapNsMapAddItem(xmlNsMapPtr *nsmap, int position,
                        xmlNsPtr oldNs, xmlNsPtr newNs, int depth)
 {
     xmlNsMapItemPtr ret;
     xmlNsMapPtr map;
 
     if (nsmap == NULL)
         return(NULL);
     if ((position != -1) && (position != 0))
         return(NULL);
     map = *nsmap;
 
     if (map == NULL) {
         /*
         * Create the ns-map.
         */
         map = (xmlNsMapPtr) xmlMalloc(sizeof(struct xmlNsMap));
         if (map == NULL) {
             xmlTreeErrMemory("allocating namespace map");
             return (NULL);
         }
         memset(map, 0, sizeof(struct xmlNsMap));
         *nsmap = map;
     }
-    
+
     if (map->pool != NULL) {
         /*
         * Reuse an item from the pool.
         */
         ret = map->pool;
         map->pool = ret->next;
         memset(ret, 0, sizeof(struct xmlNsMapItem));
     } else {
         /*
         * Create a new item.
         */
         ret = (xmlNsMapItemPtr) xmlMalloc(sizeof(struct xmlNsMapItem));
         if (ret == NULL) {
             xmlTreeErrMemory("allocating namespace map item");
             return (NULL);
         }
         memset(ret, 0, sizeof(struct xmlNsMapItem));
     }
-    
+
     if (map->first == NULL) {
         /*
         * First ever.
-        */       
+        */
         map->first = ret;
         map->last = ret;
     } else if (position == -1) {
         /*
         * Append.
         */
         ret->prev = map->last;
         map->last->next = ret;
-        map->last = ret;                
+        map->last = ret;
     } else if (position == 0) {
         /*
         * Set on first position.
         */
         map->first->prev = ret;
-        ret->next = map->first;         
-        map->first = 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:
 * @doc: the doc
 * @nsName: the namespace name
 * @prefix: the prefix
-* 
+*
 * Creates or reuses an xmlNs struct on doc->oldNs with
 * the given prefix and namespace name.
-* 
+*
 * Returns the aquired ns struct or NULL in case of an API
 *         or internal error.
 */
 static xmlNsPtr
 xmlDOMWrapStoreNs(xmlDocPtr doc,
                    const xmlChar *nsName,
                    const xmlChar *prefix)
 {
     xmlNsPtr ns;
 
@@ skipping 10 matching lines @@
                 xmlStrEqual(ns->prefix, prefix)) &&
                 xmlStrEqual(ns->href, nsName)) {
                 return (ns);
             }
             if (ns->next == NULL)
                 break;
             ns = ns->next;
         }
     }
     /* Create. */
-    ns->next = xmlNewNs(NULL, nsName, prefix);
-    return (ns->next);
+    if (ns != NULL) {
+        ns->next = xmlNewNs(NULL, nsName, prefix);
+        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 errror.
 */
 xmlDOMWrapCtxtPtr
 xmlDOMWrapNewCtxt(void)
 {
     xmlDOMWrapCtxtPtr ret;
 
     ret = xmlMalloc(sizeof(xmlDOMWrapCtxt));
     if (ret == NULL) {
         xmlTreeErrMemory("allocating DOM-wrapper context");
         return (NULL);
@@ skipping 18 matching lines @@
     /*
     * TODO: Store the namespace map in the context.
     */
     xmlFree(ctxt);
 }
 
 /*
 * xmlTreeLookupNsListByPrefix:
 * @nsList: a list of ns-structs
 * @prefix: the searched prefix
-* 
+*
 * Searches for a ns-decl with the given prefix in @nsList.
-* 
+*
 * Returns the ns-decl if found, NULL if not found and on
 *         API errors.
 */
 static xmlNsPtr
 xmlTreeNSListLookupByPrefix(xmlNsPtr nsList, const xmlChar *prefix)
 {
     if (nsList == NULL)
         return (NULL);
     {
         xmlNsPtr ns;
         ns = nsList;
         do {
             if ((prefix == ns->prefix) ||
                 xmlStrEqual(prefix, ns->prefix)) {
                 return (ns);
             }
             ns = ns->next;
         } while (ns != NULL);
     }
     return (NULL);
 }
 
 /*
 *
 * xmlDOMWrapNSNormGatherInScopeNs:
 * @map: the namespace map
 * @node: the node to start with
-* 
+*
 * Puts in-scope namespaces into the ns-map.
-* 
+*
 * Returns 0 on success, -1 on API or internal errors.
 */
 static int
 xmlDOMWrapNSNormGatherInScopeNs(xmlNsMapPtr *map,
                                 xmlNodePtr node)
 {
     xmlNodePtr cur;
     xmlNsPtr ns;
     xmlNsMapItemPtr mi;
     int shadowed;
@@ skipping 71 matching lines @@
                 xmlDictLookup(destDoc->dict, cur->content, -1); \
         else \
             cur->content = xmlStrdup(BAD_CAST cur->content); \
     }
 
 /*
 * xmlDOMWrapNSNormAddNsMapItem2:
 *
 * For internal use. Adds a ns-decl mapping.
 *
-* Returns 0 on success, -1 on internal errors. 
+* Returns 0 on success, -1 on internal errors.
 */
 static int
 xmlDOMWrapNSNormAddNsMapItem2(xmlNsPtr **list, int *size, int *number,
                         xmlNsPtr oldNs, xmlNsPtr newNs)
 {
     if (*list == NULL) {
         *list = (xmlNsPtr *) xmlMalloc(6 * sizeof(xmlNsPtr));
         if (*list == NULL) {
             xmlTreeErrMemory("alloc ns map item");
             return(-1);
@@ skipping 23 matching lines @@
 * @options: set of options, unused at the moment
 *
 * 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.
 *
 * Returns 0 on success, 1 if the node is not supported,
-*         -1 on API and internal errors. 
+*         -1 on API and internal errors.
 */
 int
 xmlDOMWrapRemoveNode(xmlDOMWrapCtxtPtr ctxt, xmlDocPtr doc,
                      xmlNodePtr node, int options ATTRIBUTE_UNUSED)
 {
     xmlNsPtr *list = NULL;
     int sizeList, nbList, i, j;
     xmlNsPtr ns;
 
     if ((node == NULL) || (doc == NULL) || (node->doc != doc))
         return (-1);
 
     /* TODO: 0 or -1 ? */
     if (node->parent == NULL)
         return (0);
 
-    switch (node->type) {       
+    switch (node->type) {
         case XML_TEXT_NODE:
         case XML_CDATA_SECTION_NODE:
         case XML_ENTITY_REF_NODE:
         case XML_PI_NODE:
         case XML_COMMENT_NODE:
             xmlUnlinkNode(node);
             return (0);
-        case XML_ELEMENT_NODE:      
+        case XML_ELEMENT_NODE:
         case XML_ATTRIBUTE_NODE:
             break;
         default:
             return (1);
     }
     xmlUnlinkNode(node);
     /*
     * Save out-of-scope ns-references in doc->oldNs.
     */
     do {
         switch (node->type) {
             case XML_ELEMENT_NODE:
                 if ((ctxt == NULL) && (node->nsDef != NULL)) {
                     ns = node->nsDef;
                     do {
                         if (xmlDOMWrapNSNormAddNsMapItem2(&list, &sizeList,
                             &nbList, ns, ns) == -1)
                             goto internal_error;
                         ns = ns->next;
                     } while (ns != NULL);
                 }
                 /* No break on purpose. */
             case XML_ATTRIBUTE_NODE:
-                if (node->ns != NULL) {             
+                if (node->ns != NULL) {
                     /*
                     * Find a mapping.
                     */
                     if (list != NULL) {
                         for (i = 0, j = 0; i < nbList; i++, j += 2) {
                             if (node->ns == list[j]) {
                                 node->ns = list[++j];
                                 goto next_node;
                             }
                         }
@@ skipping 23 matching lines @@
                     node->ns = ns;
                 }
                 if ((node->type == XML_ELEMENT_NODE) &&
                     (node->properties != NULL)) {
                     node = (xmlNodePtr) node->properties;
                     continue;
                 }
                 break;
             default:
                 goto next_sibling;
-        }       
-next_node:       
+        }
+next_node:
         if ((node->type == XML_ELEMENT_NODE) &&
             (node->children != NULL)) {
             node = node->children;
             continue;
         }
-next_sibling:   
+next_sibling:
         if (node == NULL)
             break;
         if (node->next != NULL)
             node = node->next;
         else {
             node = node->parent;
             goto next_sibling;
         }
     } while (node != NULL);
 
@@ skipping 72 matching lines @@
                     */
                     if ((nsName == ns->href) ||
                         xmlStrEqual(nsName, ns->href)) {
                         /*
                         * At this point the prefix can only be shadowed,
                         * if we are the the (at least) 3rd level of
                         * ns-decls.
                         */
                         if (out) {
                             int ret;
-                            
+
                             ret = xmlNsInScope(doc, node, prev, ns->prefix);
                             if (ret < 0)
                                 return (-1);
                             /*
                             * TODO: Should we try to find a matching ns-name
                             * only once? This here keeps on searching.
                             * I think we should try further since, there might
                             * be an other matching ns-decl with an unshadowed
                             * prefix.
                             */
@@ skipping 47 matching lines @@
             if (*retNs == NULL)
                 return (-1);
         }
         return (1);
     }
     cur = node;
     do {
         if (cur->type == XML_ELEMENT_NODE) {
             if (cur->nsDef != NULL) {
                 ns = cur->nsDef;
-                do {            
+                do {
                     if ((prefix == ns->prefix) ||
                         xmlStrEqual(prefix, ns->prefix))
                     {
                         /*
                         * Disabled namespaces, e.g. xmlns:abc="".
                         */
                         if (ns->href == NULL)
                             return(0);
                         if (retNs)
                             *retNs = ns;
                         return (1);
                     }
                     ns = ns->next;
-                } while (ns != NULL);   
+                } while (ns != NULL);
             }
         } else if ((cur->type == XML_ENTITY_NODE) ||
             (cur->type == XML_ENTITY_DECL))
             return (0);
         cur = cur->parent;
     } while ((cur != NULL) && (cur->doc != (xmlDocPtr) cur));
     return (0);
 }
 
 /*
@@ skipping 86 matching lines @@
 * change the prefix or the new ns-decl.
 *
 * Returns 0 if succeeded, -1 otherwise and on API/internal errors.
 */
 static int
 xmlDOMWrapNSNormAquireNormalizedNs(xmlDocPtr doc,
                                    xmlNodePtr elem,
                                    xmlNsPtr ns,
                                    xmlNsPtr *retNs,
                                    xmlNsMapPtr *nsMap,
-                                   
+
                                    int depth,
                                    int ancestorsOnly,
                                    int prefixed)
 {
-    xmlNsMapItemPtr mi;    
+    xmlNsMapItemPtr mi;
 
     if ((doc == NULL) || (ns == NULL) || (retNs == NULL) ||
         (nsMap == NULL))
         return (-1);
 
     *retNs = NULL;
     /*
     * Handle XML namespace.
     */
     if (IS_STR_XML(ns->prefix)) {
         /*
         * Insert XML namespace mapping.
         */
         *retNs = xmlTreeEnsureXMLDecl(doc);
         if (*retNs == NULL)
             return (-1);
         return (0);
     }
     /*
     * If the search should be done in ancestors only and no
     * @elem (the first ancestor) was specified, then skip the search.
     */
     if ((XML_NSMAP_NOTEMPTY(*nsMap)) &&
         (! (ancestorsOnly && (elem == NULL))))
-    {   
+    {
         /*
         * Try to find an equal ns-name in in-scope ns-decls.
         */
         XML_NSMAP_FOREACH(*nsMap, mi) {
-            if ((mi->depth >= XML_TREE_NSMAP_PARENT) &&                                 
-                /* 
+            if ((mi->depth >= XML_TREE_NSMAP_PARENT) &&
+                /*
                 * ancestorsOnly: This should be turned on to gain speed,
                 * if one knows that the branch itself was already
                 * ns-wellformed and no stale references existed.
                 * I.e. it searches in the ancestor axis only.
                 */
                 ((! ancestorsOnly) || (mi->depth == XML_TREE_NSMAP_PARENT)) &&
                 /* Skip shadowed prefixes. */
-                (mi->shadowDepth == -1) &&              
+                (mi->shadowDepth == -1) &&
                 /* Skip xmlns="" or xmlns:foo="". */
                 ((mi->newNs->href != NULL) &&
-                (mi->newNs->href[0] != 0)) &&           
+                (mi->newNs->href[0] != 0)) &&
                 /* Ensure a prefix if wanted. */
                 ((! prefixed) || (mi->newNs->prefix != NULL)) &&
                 /* Equal ns name */
                 ((mi->newNs->href == ns->href) ||
                 xmlStrEqual(mi->newNs->href, ns->href))) {
                 /* Set the mapping. */
                 mi->oldNs = ns;
                 *retNs = mi->newNs;
                 return (0);
             }
         }
     }
     /*
     * No luck, the namespace is out of scope or shadowed.
     */
     if (elem == NULL) {
         xmlNsPtr tmpns;
 
         /*
         * Store ns-decls in "oldNs" of the document-node.
         */
         tmpns = xmlDOMWrapStoreNs(doc, ns->href, ns->prefix);
         if (tmpns == NULL)
             return (-1);
         /*
         * Insert mapping.
-        */      
+        */
         if (xmlDOMWrapNsMapAddItem(nsMap, -1, ns,
                 tmpns, XML_TREE_NSMAP_DOC) == NULL) {
             xmlFreeNs(tmpns);
             return (-1);
         }
         *retNs = tmpns;
     } else {
         xmlNsPtr tmpns;
 
         tmpns = xmlDOMWrapNSNormDeclareNsForced(doc, elem, ns->href,
@@ skipping 21 matching lines @@
         if (xmlDOMWrapNsMapAddItem(nsMap, -1, ns, tmpns, depth) == NULL) {
             xmlFreeNs(tmpns);
             return (-1);
         }
         *retNs = tmpns;
     }
     return (0);
 }
 
 typedef enum {
-    XML_DOM_RECONNS_REMOVEREDUND = 1<<0    
+    XML_DOM_RECONNS_REMOVEREDUND = 1<<0
 } xmlDOMReconcileNSOptions;
 
 /*
 * xmlDOMWrapReconcileNamespaces:
 * @ctxt: DOM wrapper context, unused at the moment
 * @elem: the element-node
 * @options: option flags
 *
 * 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
 * attribute values or element content.
 *
 * NOTE: This function was not intensively tested.
 *
 * Returns 0 if succeeded, -1 otherwise and on API/internal errors.
-*/   
+*/
 
 int
 xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt ATTRIBUTE_UNUSED,
                               xmlNodePtr elem,
                               int options)
 {
     int depth = -1, adoptns = 0, parnsdone = 0;
     xmlNsPtr ns, prevns;
     xmlDocPtr doc;
     xmlNodePtr cur, curElem = NULL;
     xmlNsMapPtr nsMap = NULL;
     xmlNsMapItemPtr /* topmi = NULL, */ mi;
     /* @ancestorsOnly should be set by an option flag. */
     int ancestorsOnly = 0;
-    int optRemoveRedundantNS = 
+    int optRemoveRedundantNS =
         ((xmlDOMReconcileNSOptions) options & XML_DOM_RECONNS_REMOVEREDUND) ? 1 : 0;
     xmlNsPtr *listRedund = NULL;
     int sizeRedund = 0, nbRedund = 0, ret, i, j;
 
     if ((elem == NULL) || (elem->doc == NULL) ||
         (elem->type != XML_ELEMENT_NODE))
         return (-1);
 
     doc = elem->doc;
     cur = elem;
@@ skipping 15 matching lines @@
                                 ((xmlNodePtr) elem->parent->doc != elem->parent)) {
                                 /*
                                 * Gather ancestor in-scope ns-decls.
                                 */
                                 if (xmlDOMWrapNSNormGatherInScopeNs(&nsMap,
                                     elem->parent) == -1)
                                     goto internal_error;
                             }
                             parnsdone = 1;
                         }
-                        
+
                         /*
                         * Lookup the ns ancestor-axis for equal ns-decls in scope.
                         */
                         if (optRemoveRedundantNS && XML_NSMAP_NOTEMPTY(nsMap)) {
                             XML_NSMAP_FOREACH(nsMap, mi) {
                                 if ((mi->depth >= XML_TREE_NSMAP_PARENT) &&
                                     (mi->shadowDepth == -1) &&
                                     ((ns->prefix == mi->newNs->prefix) ||
                                       xmlStrEqual(ns->prefix, mi->newNs->prefix)) &&
                                     ((ns->href == mi->newNs->href) ||
                                       xmlStrEqual(ns->href, mi->newNs->href)))
-                                {                                   
+                                {
                                     /*
                                     * A redundant ns-decl was found.
                                     * Add it to the list of redundant ns-decls.
                                     */
                                     if (xmlDOMWrapNSNormAddNsMapItem2(&listRedund,
                                         &sizeRedund, &nbRedund, ns, mi->newNs) == -1)
                                         goto internal_error;
                                     /*
                                     * Remove the ns-decl from the element-node.
-                                    */                              
+                                    */
                                     if (prevns)
                                         prevns->next = ns->next;
                                     else
-                                        cur->nsDef = ns->next;                                                              
+                                        cur->nsDef = ns->next;
                                     goto next_ns_decl;
                                 }
                             }
                         }
 
                         /*
                         * Skip ns-references handling if the referenced
                         * ns-decl is declared on the same element.
                         */
                         if ((cur->ns != NULL) && adoptns && (cur->ns == ns))
-                            adoptns = 0;                                                
+                            adoptns = 0;
                         /*
                         * Does it shadow any ns-decl?
                         */
                         if (XML_NSMAP_NOTEMPTY(nsMap)) {
                             XML_NSMAP_FOREACH(nsMap, mi) {
                                 if ((mi->depth >= XML_TREE_NSMAP_PARENT) &&
                                     (mi->shadowDepth == -1) &&
                                     ((ns->prefix == mi->newNs->prefix) ||
                                     xmlStrEqual(ns->prefix, mi->newNs->prefix))) {
-                                    
+
                                     mi->shadowDepth = depth;
                                 }
                             }
                         }
                         /*
                         * Push mapping.
                         */
                         if (xmlDOMWrapNsMapAddItem(&nsMap, -1, ns, ns,
                             depth) == NULL)
-                            goto internal_error;                        
+                            goto internal_error;
 
                         prevns = ns;
 next_ns_decl:
-                        ns = ns->next;                  
+                        ns = ns->next;
                     }
                 }
                 if (! adoptns)
                     goto ns_end;
                 /* No break on purpose. */
             case XML_ATTRIBUTE_NODE:
                 /* No ns, no fun. */
                 if (cur->ns == NULL)
                     goto ns_end;
-                
+
                 if (! parnsdone) {
                     if ((elem->parent) &&
                         ((xmlNodePtr) elem->parent->doc != elem->parent)) {
                         if (xmlDOMWrapNSNormGatherInScopeNs(&nsMap,
                                 elem->parent) == -1)
                             goto internal_error;
                     }
                     parnsdone = 1;
                 }
                 /*
                 * Adjust the reference if this was a redundant ns-decl.
                 */
                 if (listRedund) {
                    for (i = 0, j = 0; i < nbRedund; i++, j += 2) {
                        if (cur->ns == listRedund[j]) {
                            cur->ns = listRedund[++j];
                            break;
                        }
-                   } 
+                   }
                 }
                 /*
                 * Adopt ns-references.
                 */
                 if (XML_NSMAP_NOTEMPTY(nsMap)) {
                     /*
                     * Search for a mapping.
                     */
                     XML_NSMAP_FOREACH(nsMap, mi) {
                         if ((mi->shadowDepth == -1) &&
@@ skipping 17 matching lines @@
 
 ns_end:
                 if ((cur->type == XML_ELEMENT_NODE) &&
                     (cur->properties != NULL)) {
                     /*
                     * Process attributes.
                     */
                     cur = (xmlNodePtr) cur->properties;
                     continue;
                 }
-                break;          
+                break;
             default:
                 goto next_sibling;
         }
 into_content:
         if ((cur->type == XML_ELEMENT_NODE) &&
             (cur->children != NULL)) {
             /*
             * Process content of element-nodes only.
             */
             cur = cur->children;
             continue;
         }
-next_sibling:   
+next_sibling:
         if (cur == elem)
             break;
         if (cur->type == XML_ELEMENT_NODE) {
-            if (XML_NSMAP_NOTEMPTY(nsMap)) {        
+            if (XML_NSMAP_NOTEMPTY(nsMap)) {
                 /*
                 * Pop mappings.
                 */
                 while ((nsMap->last != NULL) &&
                     (nsMap->last->depth >= depth))
                 {
-                    XML_NSMAP_POP(nsMap, mi)                
+                    XML_NSMAP_POP(nsMap, mi)
                 }
                 /*
                 * Unshadow.
                 */
                 XML_NSMAP_FOREACH(nsMap, mi) {
                     if (mi->shadowDepth >= depth)
                         mi->shadowDepth = -1;
                 }
-            }       
+            }
             depth--;
         }
         if (cur->next != NULL)
             cur = cur->next;
         else {
             if (cur->type == XML_ATTRIBUTE_NODE) {
                 cur = cur->parent;
                 goto into_content;
             }
             cur = cur->parent;
             goto next_sibling;
         }
     } while (cur != NULL);
-    
+
     ret = 0;
     goto exit;
 internal_error:
     ret = -1;
 exit:
-    if (listRedund) {   
+    if (listRedund) {
         for (i = 0, j = 0; i < nbRedund; i++, j += 2) {
             xmlFreeNs(listRedund[j]);
         }
         xmlFree(listRedund);
     }
     if (nsMap != NULL)
         xmlDOMWrapNsMapFree(nsMap);
     return (ret);
 }
 
@@ skipping 30 matching lines @@
     int ret = 0;
     xmlNodePtr cur, curElem = NULL;
     xmlNsMapPtr nsMap = NULL;
     xmlNsMapItemPtr mi;
     xmlNsPtr ns = NULL;
     int depth = -1, adoptStr = 1;
     /* gather @parent's ns-decls. */
     int parnsdone;
     /* @ancestorsOnly should be set per option. */
     int ancestorsOnly = 0;
-    
+
     /*
     * Optimize string adoption for equal or none dicts.
     */
     if ((sourceDoc != NULL) &&
         (sourceDoc->dict == destDoc->dict))
         adoptStr = 0;
     else
         adoptStr = 1;
 
     /*
@@ skipping 33 matching lines @@
                 if ((cur->type == XML_XINCLUDE_END) ||
                     (cur->doc == node->doc))
                     break;
             } while (cur->next != NULL);
 
             if (cur->doc != node->doc)
                 goto leave_node;
         }
         cur->doc = destDoc;
         switch (cur->type) {
-            case XML_XINCLUDE_START:            
+            case XML_XINCLUDE_START:
             case XML_XINCLUDE_END:
                 /*
                 * TODO
                 */
                 return (-1);
-            case XML_ELEMENT_NODE:      
+            case XML_ELEMENT_NODE:
                 curElem = cur;
                 depth++;
                 /*
-                * Namespace declarations.               
+                * Namespace declarations.
                 * - ns->href and ns->prefix are never in the dict, so
                 *   we need not move the values over to the destination dict.
                 * - Note that for custom handling of ns-references,
                 *   the ns-decls need not be stored in the ns-map,
                 *   since they won't be referenced by node->ns.
                 */
                 if ((cur->nsDef) &&
                     ((ctxt == NULL) || (ctxt->getNsForNodeFunc == NULL)))
                 {
                     if (! parnsdone) {
                         /*
                         * Gather @parent's in-scope ns-decls.
                         */
                         if (xmlDOMWrapNSNormGatherInScopeNs(&nsMap,
                             destParent) == -1)
                             goto internal_error;
                         parnsdone = 1;
                     }
                     for (ns = cur->nsDef; ns != NULL; ns = ns->next) {
                         /*
                         * NOTE: ns->prefix and ns->href are never in the dict.
                         * XML_TREE_ADOPT_STR(ns->prefix)
                         * XML_TREE_ADOPT_STR(ns->href)
-                        */                      
+                        */
                         /*
                         * Does it shadow any ns-decl?
-                        */                      
+                        */
                         if (XML_NSMAP_NOTEMPTY(nsMap)) {
                             XML_NSMAP_FOREACH(nsMap, mi) {
                                 if ((mi->depth >= XML_TREE_NSMAP_PARENT) &&
                                     (mi->shadowDepth == -1) &&
                                     ((ns->prefix == mi->newNs->prefix) ||
                                     xmlStrEqual(ns->prefix,
                                     mi->newNs->prefix))) {
-                                    
+
                                     mi->shadowDepth = depth;
                                 }
                             }
                         }
                         /*
                         * Push mapping.
                         */
                         if (xmlDOMWrapNsMapAddItem(&nsMap, -1,
                             ns, ns, depth) == NULL)
                             goto internal_error;
@@ skipping 42 matching lines @@
                     */
                     if (xmlDOMWrapNsMapAddItem(&nsMap, -1,
                             cur->ns, ns, XML_TREE_NSMAP_CUSTOM) == NULL)
                         goto internal_error;
                     cur->ns = ns;
                 } else {
                     /*
                     * Aquire a normalized ns-decl and add it to the map.
                     */
                     if (xmlDOMWrapNSNormAquireNormalizedNs(destDoc,
-                        /* ns-decls on curElem or on destDoc->oldNs */                  
+                        /* ns-decls on curElem or on destDoc->oldNs */
                         destParent ? curElem : NULL,
                         cur->ns, &ns,
                         &nsMap, depth,
                         ancestorsOnly,
                         /* ns-decls must be prefixed for attributes. */
                         (cur->type == XML_ATTRIBUTE_NODE) ? 1 : 0) == -1)
                         goto internal_error;
                     cur->ns = ns;
                 }
 ns_end:
@@ skipping 15 matching lines @@
                         */
                         cur = (xmlNodePtr) cur->properties;
                         continue;
                     }
                 } else {
                     /*
                     * Attributes.
                     */
                     if ((sourceDoc != NULL) &&
                         (((xmlAttrPtr) cur)->atype == XML_ATTRIBUTE_ID))
-                    {                   
+                    {
                         xmlRemoveID(sourceDoc, (xmlAttrPtr) cur);
                     }
                     ((xmlAttrPtr) cur)->atype = 0;
                     ((xmlAttrPtr) cur)->psvi = NULL;
                 }
                 break;
             case XML_TEXT_NODE:
-            case XML_CDATA_SECTION_NODE:                
+            case XML_CDATA_SECTION_NODE:
                 /*
                 * This puts the content in the dest dict, only if
                 * it was previously in the source dict.
                 */
-                XML_TREE_ADOPT_STR_2(cur->content)              
-                goto leave_node;           
+                XML_TREE_ADOPT_STR_2(cur->content)
+                goto leave_node;
             case XML_ENTITY_REF_NODE:
                 /*
                 * Remove reference to the entitity-node.
                 */
                 cur->content = NULL;
                 cur->children = NULL;
                 cur->last = NULL;
                 if ((destDoc->intSubset) || (destDoc->extSubset)) {
                     xmlEntityPtr ent;
                     /*
                     * Assign new entity-node if available.
                     */
                     ent = xmlGetDocEntity(destDoc, cur->name);
                     if (ent != NULL) {
                         cur->content = ent->content;
                         cur->children = (xmlNodePtr) ent;
                         cur->last = (xmlNodePtr) ent;
                     }
                 }
                 goto leave_node;
             case XML_PI_NODE:
                 XML_TREE_ADOPT_STR(cur->name)
                 XML_TREE_ADOPT_STR_2(cur->content)
                 break;
-            case XML_COMMENT_NODE:          
+            case XML_COMMENT_NODE:
                 break;
             default:
                 goto internal_error;
         }
         /*
         * Walk the tree.
         */
         if (cur->children != NULL) {
             cur = cur->children;
             continue;
         }
 
 leave_node:
         if (cur == node)
             break;
         if ((cur->type == XML_ELEMENT_NODE) ||
             (cur->type == XML_XINCLUDE_START) ||
             (cur->type == XML_XINCLUDE_END))
         {
             /*
             * TODO: Do we expect nsDefs on XML_XINCLUDE_START?
             */
-            if (XML_NSMAP_NOTEMPTY(nsMap)) {        
+            if (XML_NSMAP_NOTEMPTY(nsMap)) {
                 /*
                 * Pop mappings.
                 */
                 while ((nsMap->last != NULL) &&
                     (nsMap->last->depth >= depth))
                 {
-                    XML_NSMAP_POP(nsMap, mi)                
-                }               
+                    XML_NSMAP_POP(nsMap, mi)
+                }
                 /*
                 * Unshadow.
                 */
                 XML_NSMAP_FOREACH(nsMap, mi) {
                     if (mi->shadowDepth >= depth)
                         mi->shadowDepth = -1;
                 }
             }
             depth--;
         }
         if (cur->next != NULL)
             cur = cur->next;
         else if ((cur->type == XML_ATTRIBUTE_NODE) &&
             (cur->parent->children != NULL))
         {
             cur = cur->parent->children;
         } else {
             cur = cur->parent;
             goto leave_node;
         }
     }
-    
+
     goto exit;
 
-internal_error:    
+internal_error:
     ret = -1;
 
 exit:
     /*
     * Cleanup.
     */
     if (nsMap != NULL) {
         if ((ctxt) && (ctxt->namespaceMap == nsMap)) {
             /*
             * Just cleanup the map but don't free.
             */
             if (nsMap->first) {
                 if (nsMap->pool)
                     nsMap->last->next = nsMap->pool;
                 nsMap->pool = nsMap->first;
                 nsMap->first = NULL;
             }
-        } else    
+        } else
             xmlDOMWrapNsMapFree(nsMap);
     }
     return(ret);
 }
 
 /*
 * xmlDOMWrapCloneNode:
 * @ctxt: the optional context for custom processing
 * @sourceDoc: the optional sourceDoc
 * @node: the node to start with
 * @resNode: the clone of the given @node
 * @destDoc: the destination doc
 * @destParent: the optional new parent of @node in @destDoc
 * @deep: descend into child if set
 * @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 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 attribute
 * values or element content.
 * TODO:
 *   1) What to do with XInclude? Currently this returns an error for XInclude.
 *
 * Returns 0 if the operation succeeded,
 *         1 if a node of unsupported (or not yet supported) type was given,
@@ skipping 13 matching lines @@
     int ret = 0;
     xmlNodePtr cur, curElem = NULL;
     xmlNsMapPtr nsMap = NULL;
     xmlNsMapItemPtr mi;
     xmlNsPtr ns;
     int depth = -1;
     /* int adoptStr = 1; */
     /* gather @parent's ns-decls. */
     int parnsdone = 0;
     /*
-    * @ancestorsOnly: 
+    * @ancestorsOnly:
     * TODO: @ancestorsOnly should be set per option.
     *
     */
     int ancestorsOnly = 0;
     xmlNodePtr resultClone = NULL, clone = NULL, parentClone = NULL, prevClone = NULL;
     xmlNsPtr cloneNs = NULL, *cloneNsDefSlot = NULL;
     xmlDictPtr dict; /* The destination dict */
 
     if ((node == NULL) || (resNode == NULL) || (destDoc == NULL))
         return(-1);
     /*
     * TODO: Initially we support only element-nodes.
     */
     if (node->type != XML_ELEMENT_NODE)
         return(1);
     /*
     * Check node->doc sanity.
     */
     if ((node->doc != NULL) && (sourceDoc != NULL) &&
         (node->doc != sourceDoc)) {
         /*
         * Might be an XIncluded node.
         */
         return (-1);
     }
     if (sourceDoc == NULL)
-        sourceDoc = node->doc;    
+        sourceDoc = node->doc;
     if (sourceDoc == NULL)
         return (-1);
 
     dict = destDoc->dict;
     /*
     * Reuse the namespace map of the context.
     */
     if (ctxt)
         nsMap = (xmlNsMapPtr) ctxt->namespaceMap;
 
     *resNode = NULL;
-   
+
     cur = node;
     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;        
+            goto internal_error;
         }
         /*
         * Create a new node.
         */
         switch (cur->type) {
             case XML_XINCLUDE_START:
             case XML_XINCLUDE_END:
                 /*
                 * TODO: What to do with XInclude?
                 */
                 goto internal_error;
                 break;
             case XML_ELEMENT_NODE:
             case XML_TEXT_NODE:
-            case XML_CDATA_SECTION_NODE:            
+            case XML_CDATA_SECTION_NODE:
             case XML_COMMENT_NODE:
-            case XML_PI_NODE:       
+            case XML_PI_NODE:
             case XML_DOCUMENT_FRAG_NODE:
             case XML_ENTITY_REF_NODE:
             case XML_ENTITY_NODE:
                 /*
                 * Nodes of xmlNode structure.
                 */
                 clone = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
                 if (clone == NULL) {
                     xmlTreeErrMemory("xmlDOMWrapCloneNode(): allocating a node");
                     goto internal_error;
                 }
-                memset(clone, 0, sizeof(xmlNode));              
+                memset(clone, 0, sizeof(xmlNode));
                 /*
                 * Set hierachical links.
                 */
-                if (resultClone != NULL) {          
+                if (resultClone != NULL) {
                     clone->parent = parentClone;
                     if (prevClone) {
                         prevClone->next = clone;
                         clone->prev = prevClone;
-                    } else 
+                    } else
                         parentClone->children = clone;
                 } else
                     resultClone = clone;
-                
+
                 break;
             case XML_ATTRIBUTE_NODE:
                 /*
                 * Attributes (xmlAttr).
                 */
                 clone = (xmlNodePtr) xmlMalloc(sizeof(xmlAttr));
                 if (clone == NULL) {
                     xmlTreeErrMemory("xmlDOMWrapCloneNode(): allocating an attr-node");
                     goto internal_error;
                 }
-                memset(clone, 0, sizeof(xmlAttr));              
+                memset(clone, 0, sizeof(xmlAttr));
                 /*
                 * Set hierachical links.
                 * TODO: Change this to add to the end of attributes.
                 */
                 if (resultClone != NULL) {
                     clone->parent = parentClone;
                     if (prevClone) {
                         prevClone->next = clone;
                         clone->prev = prevClone;
-                    } else 
+                    } else
                         parentClone->properties = (xmlAttrPtr) clone;
                 } else
                     resultClone = clone;
                 break;
             default:
                 /*
                 * TODO QUESTION: Any other nodes expected?
                 */
                 goto internal_error;
         }
 
         clone->type = cur->type;
-        clone->doc = destDoc;   
-                
+        clone->doc = destDoc;
+
         /*
         * Clone the name of the node if any.
         */
         if (cur->name == xmlStringText)
             clone->name = xmlStringText;
         else if (cur->name == xmlStringTextNoenc)
             /*
             * NOTE: Although xmlStringTextNoenc is never assigned to a node
             *   in tree.c, it might be set in Libxslt via
-            *   "xsl:disable-output-escaping".     
+            *   "xsl:disable-output-escaping".
             */
             clone->name = xmlStringTextNoenc;
         else if (cur->name == xmlStringComment)
             clone->name = xmlStringComment;
         else if (cur->name != NULL) {
             DICT_CONST_COPY(cur->name, clone->name);
-        }                                   
+        }
 
         switch (cur->type) {
             case XML_XINCLUDE_START:
             case XML_XINCLUDE_END:
                 /*
                 * TODO
                 */
                 return (-1);
             case XML_ELEMENT_NODE:
                 curElem = cur;
                 depth++;
                 /*
                 * Namespace declarations.
                 */
                 if (cur->nsDef != NULL) {
                     if (! parnsdone) {
                         if (destParent && (ctxt == NULL)) {
                             /*
                             * Gather @parent's in-scope ns-decls.
                             */
                             if (xmlDOMWrapNSNormGatherInScopeNs(&nsMap,
                                 destParent) == -1)
-                                goto internal_error;                        
+                                goto internal_error;
                         }
                         parnsdone = 1;
                     }
                     /*
                     * Clone namespace declarations.
                     */
                     cloneNsDefSlot = &(clone->nsDef);
                     for (ns = cur->nsDef; ns != NULL; ns = ns->next) {
                         /*
                         * Create a new xmlNs.
                         */
                         cloneNs = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
                         if (cloneNs == NULL) {
                             xmlTreeErrMemory("xmlDOMWrapCloneNode(): "
                                 "allocating namespace");
                             return(-1);
                         }
                         memset(cloneNs, 0, sizeof(xmlNs));
                         cloneNs->type = XML_LOCAL_NAMESPACE;
-                        
+
                         if (ns->href != NULL)
                             cloneNs->href = xmlStrdup(ns->href);
                         if (ns->prefix != NULL)
                             cloneNs->prefix = xmlStrdup(ns->prefix);
 
                         *cloneNsDefSlot = cloneNs;
                         cloneNsDefSlot = &(cloneNs->next);
 
                         /*
                         * Note that for custom handling of ns-references,
                         * the ns-decls need not be stored in the ns-map,
                         * since they won't be referenced by node->ns.
                         */
                         if ((ctxt == NULL) ||
                             (ctxt->getNsForNodeFunc == NULL))
                         {
                             /*
                             * Does it shadow any ns-decl?
                             */
                             if (XML_NSMAP_NOTEMPTY(nsMap)) {
-                                XML_NSMAP_FOREACH(nsMap, mi) {                          
+                                XML_NSMAP_FOREACH(nsMap, mi) {
                                     if ((mi->depth >= XML_TREE_NSMAP_PARENT) &&
                                         (mi->shadowDepth == -1) &&
                                         ((ns->prefix == mi->newNs->prefix) ||
                                         xmlStrEqual(ns->prefix,
                                         mi->newNs->prefix))) {
                                         /*
                                         * Mark as shadowed at the current
                                         * depth.
                                         */
                                         mi->shadowDepth = depth;
                                     }
                                 }
                             }
                             /*
                             * Push mapping.
                             */
                             if (xmlDOMWrapNsMapAddItem(&nsMap, -1,
                                 ns, cloneNs, depth) == NULL)
                                 goto internal_error;
                         }
                     }
                 }
                 /* cur->ns will be processed further down. */
                 break;
-            case XML_ATTRIBUTE_NODE:                            
+            case XML_ATTRIBUTE_NODE:
                 /* IDs will be processed further down. */
                 /* cur->ns will be processed further down. */
                 break;
             case XML_TEXT_NODE:
             case XML_CDATA_SECTION_NODE:
                 /*
                 * Note that this will also cover the values of attributes.
                 */
-                DICT_COPY(cur->content, clone->content);                
+                DICT_COPY(cur->content, clone->content);
                 goto leave_node;
             case XML_ENTITY_NODE:
                 /* TODO: What to do here? */
                 goto leave_node;
-            case XML_ENTITY_REF_NODE:           
+            case XML_ENTITY_REF_NODE:
                 if (sourceDoc != destDoc) {
                     if ((destDoc->intSubset) || (destDoc->extSubset)) {
                         xmlEntityPtr ent;
                         /*
                         * Different doc: Assign new entity-node if available.
                         */
                         ent = xmlGetDocEntity(destDoc, cur->name);
                         if (ent != NULL) {
                             clone->content = ent->content;
                             clone->children = (xmlNodePtr) ent;
@@ skipping 19 matching lines @@
             default:
                 goto internal_error;
         }
 
         if (cur->ns == NULL)
             goto end_ns_reference;
 
 /* handle_ns_reference: */
         /*
         ** The following will take care of references to ns-decls ********
-        ** and is intended only for element- and attribute-nodes.       
+        ** and is intended only for element- and attribute-nodes.
         **
         */
         if (! parnsdone) {
             if (destParent && (ctxt == NULL)) {
                 if (xmlDOMWrapNSNormGatherInScopeNs(&nsMap, destParent) == -1)
-                    goto internal_error;                
+                    goto internal_error;
             }
             parnsdone = 1;
         }
         /*
         * Adopt ns-references.
         */
         if (XML_NSMAP_NOTEMPTY(nsMap)) {
             /*
             * Search for a mapping.
             */
-            XML_NSMAP_FOREACH(nsMap, mi) {          
+            XML_NSMAP_FOREACH(nsMap, mi) {
                 if ((mi->shadowDepth == -1) &&
                     (cur->ns == mi->oldNs)) {
                     /*
                     * This is the nice case: a mapping was found.
                     */
                     clone->ns = mi->newNs;
                     goto end_ns_reference;
                 }
             }
         }
@@ skipping 11 matching lines @@
             */
             if (xmlDOMWrapNsMapAddItem(&nsMap, -1,
                 cur->ns, ns, XML_TREE_NSMAP_CUSTOM) == NULL)
                 goto internal_error;
             clone->ns = ns;
         } else {
             /*
             * Aquire a normalized ns-decl and add it to the map.
             */
             if (xmlDOMWrapNSNormAquireNormalizedNs(destDoc,
-                /* ns-decls on curElem or on destDoc->oldNs */                  
+                /* ns-decls on curElem or on destDoc->oldNs */
                 destParent ? curElem : NULL,
                 cur->ns, &ns,
                 &nsMap, depth,
                 /* if we need to search only in the ancestor-axis */
                 ancestorsOnly,
                 /* ns-decls must be prefixed for attributes. */
                 (cur->type == XML_ATTRIBUTE_NODE) ? 1 : 0) == -1)
                 goto internal_error;
             clone->ns = ns;
         }
 
 end_ns_reference:
 
         /*
         * Some post-processing.
         *
         * Handle ID attributes.
         */
         if ((clone->type == XML_ATTRIBUTE_NODE) &&
             (clone->parent != NULL))
         {
             if (xmlIsID(destDoc, clone->parent, (xmlAttrPtr) clone)) {
-           
+
                 xmlChar *idVal;
-                
+
                 idVal = xmlNodeListGetString(cur->doc, cur->children, 1);
                 if (idVal != NULL) {
                     if (xmlAddID(NULL, destDoc, idVal, (xmlAttrPtr) cur) == NULL) {
                         /* TODO: error message. */
                         xmlFree(idVal);
                         goto internal_error;
                     }
                     xmlFree(idVal);
                 }
             }
         }
         /*
         **
         ** The following will traverse the tree **************************
         **
-        *       
+        *
         * Walk the element's attributes before descending into child-nodes.
         */
         if ((cur->type == XML_ELEMENT_NODE) && (cur->properties != NULL)) {
             prevClone = NULL;
-            parentClone = clone;            
+            parentClone = clone;
             cur = (xmlNodePtr) cur->properties;
             continue;
         }
 into_content:
         /*
         * Descend into child-nodes.
         */
         if (cur->children != NULL) {
             if (deep || (cur->type == XML_ATTRIBUTE_NODE)) {
                 prevClone = NULL;
                 parentClone = clone;
                 cur = cur->children;
                 continue;
             }
         }
 
 leave_node:
         /*
         * At this point we are done with the node, its content
         * and an element-nodes's attribute-nodes.
         */
         if (cur == node)
             break;
         if ((cur->type == XML_ELEMENT_NODE) ||
             (cur->type == XML_XINCLUDE_START) ||
             (cur->type == XML_XINCLUDE_END)) {
             /*
             * TODO: Do we expect nsDefs on XML_XINCLUDE_START?
             */
-            if (XML_NSMAP_NOTEMPTY(nsMap)) {        
+            if (XML_NSMAP_NOTEMPTY(nsMap)) {
                 /*
                 * Pop mappings.
                 */
                 while ((nsMap->last != NULL) &&
                     (nsMap->last->depth >= depth))
                 {
-                    XML_NSMAP_POP(nsMap, mi)                
+                    XML_NSMAP_POP(nsMap, mi)
                 }
                 /*
                 * Unshadow.
                 */
                 XML_NSMAP_FOREACH(nsMap, mi) {
                     if (mi->shadowDepth >= depth)
                         mi->shadowDepth = -1;
                 }
-            }       
+            }
             depth--;
         }
         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; 
+            parentClone = clone->parent;
             /*
             * Process parent --> next;
             */
             cur = cur->parent;
             goto leave_node;
         } else {
             /* This is for attributes only. */
             clone = clone->parent;
-            parentClone = clone->parent; 
+            parentClone = clone->parent;
             /*
             * Process parent-element --> children.
             */
             cur = cur->parent;
-            goto into_content;      
+            goto into_content;
         }
-    }        
+    }
     goto exit;
 
 internal_error:
     ret = -1;
 
 exit:
     /*
     * Cleanup.
     */
     if (nsMap != NULL) {
         if ((ctxt) && (ctxt->namespaceMap == nsMap)) {
             /*
             * Just cleanup the map but don't free.
             */
             if (nsMap->first) {
                 if (nsMap->pool)
                     nsMap->last->next = nsMap->pool;
                 nsMap->pool = nsMap->first;
                 nsMap->first = NULL;
             }
-        } else    
+        } else
             xmlDOMWrapNsMapFree(nsMap);
     }
     /*
     * TODO: Should we try a cleanup of the cloned node in case of a
     * fatal error?
     */
     *resNode = resultClone;
     return (ret);
 }
 
@@ skipping 19 matching lines @@
                     xmlAttrPtr attr,
                     xmlDocPtr destDoc,
                     xmlNodePtr destParent,
                     int options ATTRIBUTE_UNUSED)
 {
     xmlNodePtr cur;
     int adoptStr = 1;
 
     if ((attr == NULL) || (destDoc == NULL))
         return (-1);
-    
+
     attr->doc = destDoc;
     if (attr->ns != NULL) {
         xmlNsPtr ns = NULL;
 
         if (ctxt != NULL) {
             /* TODO: User defined. */
         }
         /* XML Namespace. */
         if (IS_STR_XML(attr->ns->prefix)) {
             ns = xmlTreeEnsureXMLDecl(destDoc);
         } else if (destParent == NULL) {
             /*
             * Store in @destDoc->oldNs.
             */
             ns = xmlDOMWrapStoreNs(destDoc, attr->ns->href, attr->ns->prefix);
         } else {
             /*
             * Declare on @destParent.
             */
             if (xmlSearchNsByNamespaceStrict(destDoc, destParent, attr->ns->href,
                 &ns, 1) == -1)
                 goto internal_error;
             if (ns == NULL) {
                 ns = xmlDOMWrapNSNormDeclareNsForced(destDoc, destParent,
                     attr->ns->href, attr->ns->prefix, 1);
             }
-        }           
+        }
         if (ns == NULL)
             goto internal_error;
         attr->ns = ns;
-    }   
-    
-    XML_TREE_ADOPT_STR(attr->name);    
+    }
+
+    XML_TREE_ADOPT_STR(attr->name);
     attr->atype = 0;
     attr->psvi = NULL;
     /*
     * Walk content.
     */
     if (attr->children == NULL)
         return (0);
     cur = attr->children;
     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;     
+                break;
             case XML_ENTITY_REF_NODE:
                 /*
                 * Remove reference to the entitity-node.
                 */
                 cur->content = NULL;
                 cur->children = NULL;
                 cur->last = NULL;
                 if ((destDoc->intSubset) || (destDoc->extSubset)) {
                     xmlEntityPtr ent;
                     /*
                     * Assign new entity-node if available.
                     */
                     ent = xmlGetDocEntity(destDoc, cur->name);
                     if (ent != NULL) {
                         cur->content = ent->content;
                         cur->children = (xmlNodePtr) ent;
                         cur->last = (xmlNodePtr) ent;
-                    }                           
+                    }
                 }
                 break;
             default:
                 break;
         }
         if (cur->children != NULL) {
             cur = cur->children;
             continue;
         }
 next_sibling:
@@ skipping 17 matching lines @@
 * @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
-*    to the context of 
-* 
+*    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,              
+                    xmlDocPtr destDoc,
                     xmlNodePtr destParent,
                     int options)
 {
     if ((node == NULL) || (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.
         */
         return (-1);
     }
     if (sourceDoc == NULL)
         sourceDoc = node->doc;
     if (sourceDoc == destDoc)
         return (-1);
     switch (node->type) {
-        case XML_ELEMENT_NODE:      
+        case XML_ELEMENT_NODE:
         case XML_ATTRIBUTE_NODE:
         case XML_TEXT_NODE:
         case XML_CDATA_SECTION_NODE:
         case XML_ENTITY_REF_NODE:
         case XML_PI_NODE:
         case XML_COMMENT_NODE:
             break;
         case XML_DOCUMENT_FRAG_NODE:
             /* TODO: Support document-fragment-nodes. */
             return (2);
         default:
             return (1);
     }
     /*
     * Unlink only if @node was not already added to @destParent.
     */
     if ((node->parent != NULL) && (destParent != node->parent))
         xmlUnlinkNode(node);
 
     if (node->type == XML_ELEMENT_NODE) {
             return (xmlDOMWrapAdoptBranch(ctxt, sourceDoc, node,
                     destDoc, destParent, options));
     } else if (node->type == XML_ATTRIBUTE_NODE) {
             return (xmlDOMWrapAdoptAttr(ctxt, sourceDoc,
                 (xmlAttrPtr) node, destDoc, destParent, options));
-    } else {    
+    } else {
         xmlNodePtr cur = node;
         int adoptStr = 1;
 
         cur->doc = destDoc;
         /*
         * Optimize string adoption.
         */
         if ((sourceDoc != NULL) &&
             (sourceDoc->dict == destDoc->dict))
                 adoptStr = 0;
         switch (node->type) {
-            case XML_TEXT_NODE:     
+            case XML_TEXT_NODE:
             case XML_CDATA_SECTION_NODE:
                 XML_TREE_ADOPT_STR_2(node->content)
                     break;
             case XML_ENTITY_REF_NODE:
                 /*
                 * Remove reference to the entitity-node.
                 */
                 node->content = NULL;
                 node->children = NULL;
                 node->last = NULL;
@@ skipping 12 matching lines @@
                 XML_TREE_ADOPT_STR(node->name)
                 break;
             case XML_PI_NODE: {
                 XML_TREE_ADOPT_STR(node->name)
                 XML_TREE_ADOPT_STR_2(node->content)
                 break;
             }
             default:
                 break;
         }
-    }   
+    }
     return (0);
 }
 
 #define bottom_tree
 #include "elfgcchack.h"