Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

1 files changed, 1091 insertions, 1091 deletions

diff --git a/contrib/libs/libxml/entities.c b/contrib/libs/libxml/entities.c
index 26020a59903..d575e9d177b 100644
--- a/contrib/libs/libxml/entities.c
+++ b/contrib/libs/libxml/entities.c
@@ -1,1111 +1,1111 @@
-/* 
- * entities.c : implementation for the XML entities handling 
- * 
- * See Copyright for the status of this software. 
- * 
- * [email protected] 
- */ 
- 
+/*
+ * entities.c : implementation for the XML entities handling
+ *
+ * See Copyright for the status of this software.
+ *
+ * [email protected]
+ */
+
 /* To avoid EBCDIC trouble when parsing on zOS */
 #if defined(__MVS__)
 #pragma convert("ISO8859-1")
 #endif
 
-#define IN_LIBXML 
-#include "libxml.h" 
- 
-#include <string.h> 
-#ifdef HAVE_STDLIB_H 
-#include <stdlib.h> 
-#endif 
-#include <libxml/xmlmemory.h> 
-#include <libxml/hash.h> 
-#include <libxml/entities.h> 
-#include <libxml/parser.h> 
-#include <libxml/parserInternals.h> 
-#include <libxml/xmlerror.h> 
-#include <libxml/globals.h> 
-#include <libxml/dict.h> 
- 
-#include "save.h" 
- 
-/* 
- * The XML predefined entities. 
- */ 
- 
-static xmlEntity xmlEntityLt = { 
-    NULL, XML_ENTITY_DECL, BAD_CAST "lt", 
-    NULL, NULL, NULL, NULL, NULL, NULL, 
-    BAD_CAST "<", BAD_CAST "<", 1, 
-    XML_INTERNAL_PREDEFINED_ENTITY, 
-    NULL, NULL, NULL, NULL, 0, 1 
-}; 
-static xmlEntity xmlEntityGt = { 
-    NULL, XML_ENTITY_DECL, BAD_CAST "gt", 
-    NULL, NULL, NULL, NULL, NULL, NULL, 
-    BAD_CAST ">", BAD_CAST ">", 1, 
-    XML_INTERNAL_PREDEFINED_ENTITY, 
-    NULL, NULL, NULL, NULL, 0, 1 
-}; 
-static xmlEntity xmlEntityAmp = { 
-    NULL, XML_ENTITY_DECL, BAD_CAST "amp", 
-    NULL, NULL, NULL, NULL, NULL, NULL, 
-    BAD_CAST "&", BAD_CAST "&", 1, 
-    XML_INTERNAL_PREDEFINED_ENTITY, 
-    NULL, NULL, NULL, NULL, 0, 1 
-}; 
-static xmlEntity xmlEntityQuot = { 
-    NULL, XML_ENTITY_DECL, BAD_CAST "quot", 
-    NULL, NULL, NULL, NULL, NULL, NULL, 
-    BAD_CAST "\"", BAD_CAST "\"", 1, 
-    XML_INTERNAL_PREDEFINED_ENTITY, 
-    NULL, NULL, NULL, NULL, 0, 1 
-}; 
-static xmlEntity xmlEntityApos = { 
-    NULL, XML_ENTITY_DECL, BAD_CAST "apos", 
-    NULL, NULL, NULL, NULL, NULL, NULL, 
-    BAD_CAST "'", BAD_CAST "'", 1, 
-    XML_INTERNAL_PREDEFINED_ENTITY, 
-    NULL, NULL, NULL, NULL, 0, 1 
-}; 
- 
-/** 
- * xmlEntitiesErrMemory: 
- * @extra:  extra informations 
- * 
- * Handle an out of memory condition 
- */ 
-static void 
-xmlEntitiesErrMemory(const char *extra) 
-{ 
-    __xmlSimpleError(XML_FROM_TREE, XML_ERR_NO_MEMORY, NULL, NULL, extra); 
-} 
- 
-/** 
- * xmlEntitiesErr: 
- * @code:  the error code 
- * @msg:  the message 
- * 
- * Handle an out of memory condition 
- */ 
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#include <libxml/xmlmemory.h>
+#include <libxml/hash.h>
+#include <libxml/entities.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xmlerror.h>
+#include <libxml/globals.h>
+#include <libxml/dict.h>
+
+#include "save.h"
+
+/*
+ * The XML predefined entities.
+ */
+
+static xmlEntity xmlEntityLt = {
+    NULL, XML_ENTITY_DECL, BAD_CAST "lt",
+    NULL, NULL, NULL, NULL, NULL, NULL,
+    BAD_CAST "<", BAD_CAST "<", 1,
+    XML_INTERNAL_PREDEFINED_ENTITY,
+    NULL, NULL, NULL, NULL, 0, 1
+};
+static xmlEntity xmlEntityGt = {
+    NULL, XML_ENTITY_DECL, BAD_CAST "gt",
+    NULL, NULL, NULL, NULL, NULL, NULL,
+    BAD_CAST ">", BAD_CAST ">", 1,
+    XML_INTERNAL_PREDEFINED_ENTITY,
+    NULL, NULL, NULL, NULL, 0, 1
+};
+static xmlEntity xmlEntityAmp = {
+    NULL, XML_ENTITY_DECL, BAD_CAST "amp",
+    NULL, NULL, NULL, NULL, NULL, NULL,
+    BAD_CAST "&", BAD_CAST "&", 1,
+    XML_INTERNAL_PREDEFINED_ENTITY,
+    NULL, NULL, NULL, NULL, 0, 1
+};
+static xmlEntity xmlEntityQuot = {
+    NULL, XML_ENTITY_DECL, BAD_CAST "quot",
+    NULL, NULL, NULL, NULL, NULL, NULL,
+    BAD_CAST "\"", BAD_CAST "\"", 1,
+    XML_INTERNAL_PREDEFINED_ENTITY,
+    NULL, NULL, NULL, NULL, 0, 1
+};
+static xmlEntity xmlEntityApos = {
+    NULL, XML_ENTITY_DECL, BAD_CAST "apos",
+    NULL, NULL, NULL, NULL, NULL, NULL,
+    BAD_CAST "'", BAD_CAST "'", 1,
+    XML_INTERNAL_PREDEFINED_ENTITY,
+    NULL, NULL, NULL, NULL, 0, 1
+};
+
+/**
+ * xmlEntitiesErrMemory:
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlEntitiesErrMemory(const char *extra)
+{
+    __xmlSimpleError(XML_FROM_TREE, XML_ERR_NO_MEMORY, NULL, NULL, extra);
+}
+
+/**
+ * xmlEntitiesErr:
+ * @code:  the error code
+ * @msg:  the message
+ *
+ * Handle an out of memory condition
+ */
 static void LIBXML_ATTR_FORMAT(2,0)
-xmlEntitiesErr(xmlParserErrors code, const char *msg) 
-{ 
-    __xmlSimpleError(XML_FROM_TREE, code, NULL, msg, NULL); 
-} 
- 
-/* 
- * xmlFreeEntity : clean-up an entity record. 
- */ 
-static void 
-xmlFreeEntity(xmlEntityPtr entity) 
-{ 
-    xmlDictPtr dict = NULL; 
- 
-    if (entity == NULL) 
-        return; 
- 
-    if (entity->doc != NULL) 
-        dict = entity->doc->dict; 
- 
- 
-    if ((entity->children) && (entity->owner == 1) && 
-        (entity == (xmlEntityPtr) entity->children->parent)) 
-        xmlFreeNodeList(entity->children); 
-    if (dict != NULL) { 
-        if ((entity->name != NULL) && (!xmlDictOwns(dict, entity->name))) 
-            xmlFree((char *) entity->name); 
-        if ((entity->ExternalID != NULL) && 
-	    (!xmlDictOwns(dict, entity->ExternalID))) 
-            xmlFree((char *) entity->ExternalID); 
-        if ((entity->SystemID != NULL) && 
-	    (!xmlDictOwns(dict, entity->SystemID))) 
-            xmlFree((char *) entity->SystemID); 
-        if ((entity->URI != NULL) && (!xmlDictOwns(dict, entity->URI))) 
-            xmlFree((char *) entity->URI); 
-        if ((entity->content != NULL) 
-            && (!xmlDictOwns(dict, entity->content))) 
-            xmlFree((char *) entity->content); 
-        if ((entity->orig != NULL) && (!xmlDictOwns(dict, entity->orig))) 
-            xmlFree((char *) entity->orig); 
-    } else { 
-        if (entity->name != NULL) 
-            xmlFree((char *) entity->name); 
-        if (entity->ExternalID != NULL) 
-            xmlFree((char *) entity->ExternalID); 
-        if (entity->SystemID != NULL) 
-            xmlFree((char *) entity->SystemID); 
-        if (entity->URI != NULL) 
-            xmlFree((char *) entity->URI); 
-        if (entity->content != NULL) 
-            xmlFree((char *) entity->content); 
-        if (entity->orig != NULL) 
-            xmlFree((char *) entity->orig); 
-    } 
-    xmlFree(entity); 
-} 
- 
-/* 
- * xmlCreateEntity: 
- * 
+xmlEntitiesErr(xmlParserErrors code, const char *msg)
+{
+    __xmlSimpleError(XML_FROM_TREE, code, NULL, msg, NULL);
+}
+
+/*
+ * xmlFreeEntity : clean-up an entity record.
+ */
+static void
+xmlFreeEntity(xmlEntityPtr entity)
+{
+    xmlDictPtr dict = NULL;
+
+    if (entity == NULL)
+        return;
+
+    if (entity->doc != NULL)
+        dict = entity->doc->dict;
+
+
+    if ((entity->children) && (entity->owner == 1) &&
+        (entity == (xmlEntityPtr) entity->children->parent))
+        xmlFreeNodeList(entity->children);
+    if (dict != NULL) {
+        if ((entity->name != NULL) && (!xmlDictOwns(dict, entity->name)))
+            xmlFree((char *) entity->name);
+        if ((entity->ExternalID != NULL) &&
+	    (!xmlDictOwns(dict, entity->ExternalID)))
+            xmlFree((char *) entity->ExternalID);
+        if ((entity->SystemID != NULL) &&
+	    (!xmlDictOwns(dict, entity->SystemID)))
+            xmlFree((char *) entity->SystemID);
+        if ((entity->URI != NULL) && (!xmlDictOwns(dict, entity->URI)))
+            xmlFree((char *) entity->URI);
+        if ((entity->content != NULL)
+            && (!xmlDictOwns(dict, entity->content)))
+            xmlFree((char *) entity->content);
+        if ((entity->orig != NULL) && (!xmlDictOwns(dict, entity->orig)))
+            xmlFree((char *) entity->orig);
+    } else {
+        if (entity->name != NULL)
+            xmlFree((char *) entity->name);
+        if (entity->ExternalID != NULL)
+            xmlFree((char *) entity->ExternalID);
+        if (entity->SystemID != NULL)
+            xmlFree((char *) entity->SystemID);
+        if (entity->URI != NULL)
+            xmlFree((char *) entity->URI);
+        if (entity->content != NULL)
+            xmlFree((char *) entity->content);
+        if (entity->orig != NULL)
+            xmlFree((char *) entity->orig);
+    }
+    xmlFree(entity);
+}
+
+/*
+ * xmlCreateEntity:
+ *
  * internal routine doing the entity node structures allocations
- */ 
-static xmlEntityPtr 
-xmlCreateEntity(xmlDictPtr dict, const xmlChar *name, int type, 
-	        const xmlChar *ExternalID, const xmlChar *SystemID, 
-	        const xmlChar *content) { 
-    xmlEntityPtr ret; 
- 
-    ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity)); 
-    if (ret == NULL) { 
-        xmlEntitiesErrMemory("xmlCreateEntity: malloc failed"); 
-	return(NULL); 
-    } 
-    memset(ret, 0, sizeof(xmlEntity)); 
-    ret->type = XML_ENTITY_DECL; 
-    ret->checked = 0; 
- 
-    /* 
-     * fill the structure. 
-     */ 
-    ret->etype = (xmlEntityType) type; 
-    if (dict == NULL) { 
-	ret->name = xmlStrdup(name); 
-	if (ExternalID != NULL) 
-	    ret->ExternalID = xmlStrdup(ExternalID); 
-	if (SystemID != NULL) 
-	    ret->SystemID = xmlStrdup(SystemID); 
-    } else { 
-        ret->name = xmlDictLookup(dict, name, -1); 
-	if (ExternalID != NULL) 
-	    ret->ExternalID = xmlDictLookup(dict, ExternalID, -1); 
-	if (SystemID != NULL) 
-	    ret->SystemID = xmlDictLookup(dict, SystemID, -1); 
-    } 
-    if (content != NULL) { 
-        ret->length = xmlStrlen(content); 
-	if ((dict != NULL) && (ret->length < 5)) 
-	    ret->content = (xmlChar *) 
-	                   xmlDictLookup(dict, content, ret->length); 
-	else 
-	    ret->content = xmlStrndup(content, ret->length); 
-     } else { 
-        ret->length = 0; 
-        ret->content = NULL; 
-    } 
-    ret->URI = NULL; /* to be computed by the layer knowing 
-			the defining entity */ 
-    ret->orig = NULL; 
-    ret->owner = 0; 
- 
-    return(ret); 
-} 
- 
-/* 
- * xmlAddEntity : register a new entity for an entities table. 
- */ 
-static xmlEntityPtr 
-xmlAddEntity(xmlDtdPtr dtd, const xmlChar *name, int type, 
-	  const xmlChar *ExternalID, const xmlChar *SystemID, 
-	  const xmlChar *content) { 
-    xmlDictPtr dict = NULL; 
-    xmlEntitiesTablePtr table = NULL; 
-    xmlEntityPtr ret; 
- 
-    if (name == NULL) 
-	return(NULL); 
-    if (dtd == NULL) 
-	return(NULL); 
-    if (dtd->doc != NULL) 
-        dict = dtd->doc->dict; 
- 
-    switch (type) { 
-        case XML_INTERNAL_GENERAL_ENTITY: 
-        case XML_EXTERNAL_GENERAL_PARSED_ENTITY: 
-        case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY: 
-	    if (dtd->entities == NULL) 
-		dtd->entities = xmlHashCreateDict(0, dict); 
-	    table = dtd->entities; 
-	    break; 
-        case XML_INTERNAL_PARAMETER_ENTITY: 
-        case XML_EXTERNAL_PARAMETER_ENTITY: 
-	    if (dtd->pentities == NULL) 
-		dtd->pentities = xmlHashCreateDict(0, dict); 
-	    table = dtd->pentities; 
-	    break; 
-        case XML_INTERNAL_PREDEFINED_ENTITY: 
-	    return(NULL); 
-    } 
-    if (table == NULL) 
-	return(NULL); 
-    ret = xmlCreateEntity(dict, name, type, ExternalID, SystemID, content); 
-    if (ret == NULL) 
-        return(NULL); 
-    ret->doc = dtd->doc; 
- 
-    if (xmlHashAddEntry(table, name, ret)) { 
-	/* 
-	 * entity was already defined at another level. 
-	 */ 
-        xmlFreeEntity(ret); 
-	return(NULL); 
-    } 
-    return(ret); 
-} 
- 
-/** 
- * xmlGetPredefinedEntity: 
- * @name:  the entity name 
- * 
- * Check whether this name is an predefined entity. 
- * 
- * Returns NULL if not, otherwise the entity 
- */ 
-xmlEntityPtr 
-xmlGetPredefinedEntity(const xmlChar *name) { 
-    if (name == NULL) return(NULL); 
-    switch (name[0]) { 
-        case 'l': 
-	    if (xmlStrEqual(name, BAD_CAST "lt")) 
-	        return(&xmlEntityLt); 
-	    break; 
-        case 'g': 
-	    if (xmlStrEqual(name, BAD_CAST "gt")) 
-	        return(&xmlEntityGt); 
-	    break; 
-        case 'a': 
-	    if (xmlStrEqual(name, BAD_CAST "amp")) 
-	        return(&xmlEntityAmp); 
-	    if (xmlStrEqual(name, BAD_CAST "apos")) 
-	        return(&xmlEntityApos); 
-	    break; 
-        case 'q': 
-	    if (xmlStrEqual(name, BAD_CAST "quot")) 
-	        return(&xmlEntityQuot); 
-	    break; 
-	default: 
-	    break; 
-    } 
-    return(NULL); 
-} 
- 
-/** 
- * xmlAddDtdEntity: 
- * @doc:  the document 
- * @name:  the entity name 
- * @type:  the entity type XML_xxx_yyy_ENTITY 
- * @ExternalID:  the entity external ID if available 
- * @SystemID:  the entity system ID if available 
- * @content:  the entity content 
- * 
- * Register a new entity for this document DTD external subset. 
- * 
- * Returns a pointer to the entity or NULL in case of error 
- */ 
-xmlEntityPtr 
-xmlAddDtdEntity(xmlDocPtr doc, const xmlChar *name, int type, 
-	        const xmlChar *ExternalID, const xmlChar *SystemID, 
-		const xmlChar *content) { 
-    xmlEntityPtr ret; 
-    xmlDtdPtr dtd; 
- 
-    if (doc == NULL) { 
-	xmlEntitiesErr(XML_DTD_NO_DOC, 
-	        "xmlAddDtdEntity: document is NULL"); 
-	return(NULL); 
-    } 
-    if (doc->extSubset == NULL) { 
-	xmlEntitiesErr(XML_DTD_NO_DTD, 
-	        "xmlAddDtdEntity: document without external subset"); 
-	return(NULL); 
-    } 
-    dtd = doc->extSubset; 
-    ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content); 
-    if (ret == NULL) return(NULL); 
- 
-    /* 
-     * Link it to the DTD 
-     */ 
-    ret->parent = dtd; 
-    ret->doc = dtd->doc; 
-    if (dtd->last == NULL) { 
-	dtd->children = dtd->last = (xmlNodePtr) ret; 
-    } else { 
-        dtd->last->next = (xmlNodePtr) ret; 
-	ret->prev = dtd->last; 
-	dtd->last = (xmlNodePtr) ret; 
-    } 
-    return(ret); 
-} 
- 
-/** 
- * xmlAddDocEntity: 
- * @doc:  the document 
- * @name:  the entity name 
- * @type:  the entity type XML_xxx_yyy_ENTITY 
- * @ExternalID:  the entity external ID if available 
- * @SystemID:  the entity system ID if available 
- * @content:  the entity content 
- * 
- * Register a new entity for this document. 
- * 
- * Returns a pointer to the entity or NULL in case of error 
- */ 
-xmlEntityPtr 
-xmlAddDocEntity(xmlDocPtr doc, const xmlChar *name, int type, 
-	        const xmlChar *ExternalID, const xmlChar *SystemID, 
-	        const xmlChar *content) { 
-    xmlEntityPtr ret; 
-    xmlDtdPtr dtd; 
- 
-    if (doc == NULL) { 
-	xmlEntitiesErr(XML_DTD_NO_DOC, 
-	        "xmlAddDocEntity: document is NULL"); 
-	return(NULL); 
-    } 
-    if (doc->intSubset == NULL) { 
-	xmlEntitiesErr(XML_DTD_NO_DTD, 
-	        "xmlAddDocEntity: document without internal subset"); 
-	return(NULL); 
-    } 
-    dtd = doc->intSubset; 
-    ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content); 
-    if (ret == NULL) return(NULL); 
- 
-    /* 
-     * Link it to the DTD 
-     */ 
-    ret->parent = dtd; 
-    ret->doc = dtd->doc; 
-    if (dtd->last == NULL) { 
-	dtd->children = dtd->last = (xmlNodePtr) ret; 
-    } else { 
-	dtd->last->next = (xmlNodePtr) ret; 
-	ret->prev = dtd->last; 
-	dtd->last = (xmlNodePtr) ret; 
-    } 
-    return(ret); 
-} 
- 
-/** 
- * xmlNewEntity: 
- * @doc:  the document 
- * @name:  the entity name 
- * @type:  the entity type XML_xxx_yyy_ENTITY 
- * @ExternalID:  the entity external ID if available 
- * @SystemID:  the entity system ID if available 
- * @content:  the entity content 
- * 
- * Create a new entity, this differs from xmlAddDocEntity() that if 
- * the document is NULL or has no internal subset defined, then an 
+ */
+static xmlEntityPtr
+xmlCreateEntity(xmlDictPtr dict, const xmlChar *name, int type,
+	        const xmlChar *ExternalID, const xmlChar *SystemID,
+	        const xmlChar *content) {
+    xmlEntityPtr ret;
+
+    ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
+    if (ret == NULL) {
+        xmlEntitiesErrMemory("xmlCreateEntity: malloc failed");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlEntity));
+    ret->type = XML_ENTITY_DECL;
+    ret->checked = 0;
+
+    /*
+     * fill the structure.
+     */
+    ret->etype = (xmlEntityType) type;
+    if (dict == NULL) {
+	ret->name = xmlStrdup(name);
+	if (ExternalID != NULL)
+	    ret->ExternalID = xmlStrdup(ExternalID);
+	if (SystemID != NULL)
+	    ret->SystemID = xmlStrdup(SystemID);
+    } else {
+        ret->name = xmlDictLookup(dict, name, -1);
+	if (ExternalID != NULL)
+	    ret->ExternalID = xmlDictLookup(dict, ExternalID, -1);
+	if (SystemID != NULL)
+	    ret->SystemID = xmlDictLookup(dict, SystemID, -1);
+    }
+    if (content != NULL) {
+        ret->length = xmlStrlen(content);
+	if ((dict != NULL) && (ret->length < 5))
+	    ret->content = (xmlChar *)
+	                   xmlDictLookup(dict, content, ret->length);
+	else
+	    ret->content = xmlStrndup(content, ret->length);
+     } else {
+        ret->length = 0;
+        ret->content = NULL;
+    }
+    ret->URI = NULL; /* to be computed by the layer knowing
+			the defining entity */
+    ret->orig = NULL;
+    ret->owner = 0;
+
+    return(ret);
+}
+
+/*
+ * xmlAddEntity : register a new entity for an entities table.
+ */
+static xmlEntityPtr
+xmlAddEntity(xmlDtdPtr dtd, const xmlChar *name, int type,
+	  const xmlChar *ExternalID, const xmlChar *SystemID,
+	  const xmlChar *content) {
+    xmlDictPtr dict = NULL;
+    xmlEntitiesTablePtr table = NULL;
+    xmlEntityPtr ret;
+
+    if (name == NULL)
+	return(NULL);
+    if (dtd == NULL)
+	return(NULL);
+    if (dtd->doc != NULL)
+        dict = dtd->doc->dict;
+
+    switch (type) {
+        case XML_INTERNAL_GENERAL_ENTITY:
+        case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
+        case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
+	    if (dtd->entities == NULL)
+		dtd->entities = xmlHashCreateDict(0, dict);
+	    table = dtd->entities;
+	    break;
+        case XML_INTERNAL_PARAMETER_ENTITY:
+        case XML_EXTERNAL_PARAMETER_ENTITY:
+	    if (dtd->pentities == NULL)
+		dtd->pentities = xmlHashCreateDict(0, dict);
+	    table = dtd->pentities;
+	    break;
+        case XML_INTERNAL_PREDEFINED_ENTITY:
+	    return(NULL);
+    }
+    if (table == NULL)
+	return(NULL);
+    ret = xmlCreateEntity(dict, name, type, ExternalID, SystemID, content);
+    if (ret == NULL)
+        return(NULL);
+    ret->doc = dtd->doc;
+
+    if (xmlHashAddEntry(table, name, ret)) {
+	/*
+	 * entity was already defined at another level.
+	 */
+        xmlFreeEntity(ret);
+	return(NULL);
+    }
+    return(ret);
+}
+
+/**
+ * xmlGetPredefinedEntity:
+ * @name:  the entity name
+ *
+ * Check whether this name is an predefined entity.
+ *
+ * Returns NULL if not, otherwise the entity
+ */
+xmlEntityPtr
+xmlGetPredefinedEntity(const xmlChar *name) {
+    if (name == NULL) return(NULL);
+    switch (name[0]) {
+        case 'l':
+	    if (xmlStrEqual(name, BAD_CAST "lt"))
+	        return(&xmlEntityLt);
+	    break;
+        case 'g':
+	    if (xmlStrEqual(name, BAD_CAST "gt"))
+	        return(&xmlEntityGt);
+	    break;
+        case 'a':
+	    if (xmlStrEqual(name, BAD_CAST "amp"))
+	        return(&xmlEntityAmp);
+	    if (xmlStrEqual(name, BAD_CAST "apos"))
+	        return(&xmlEntityApos);
+	    break;
+        case 'q':
+	    if (xmlStrEqual(name, BAD_CAST "quot"))
+	        return(&xmlEntityQuot);
+	    break;
+	default:
+	    break;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlAddDtdEntity:
+ * @doc:  the document
+ * @name:  the entity name
+ * @type:  the entity type XML_xxx_yyy_ENTITY
+ * @ExternalID:  the entity external ID if available
+ * @SystemID:  the entity system ID if available
+ * @content:  the entity content
+ *
+ * Register a new entity for this document DTD external subset.
+ *
+ * Returns a pointer to the entity or NULL in case of error
+ */
+xmlEntityPtr
+xmlAddDtdEntity(xmlDocPtr doc, const xmlChar *name, int type,
+	        const xmlChar *ExternalID, const xmlChar *SystemID,
+		const xmlChar *content) {
+    xmlEntityPtr ret;
+    xmlDtdPtr dtd;
+
+    if (doc == NULL) {
+	xmlEntitiesErr(XML_DTD_NO_DOC,
+	        "xmlAddDtdEntity: document is NULL");
+	return(NULL);
+    }
+    if (doc->extSubset == NULL) {
+	xmlEntitiesErr(XML_DTD_NO_DTD,
+	        "xmlAddDtdEntity: document without external subset");
+	return(NULL);
+    }
+    dtd = doc->extSubset;
+    ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content);
+    if (ret == NULL) return(NULL);
+
+    /*
+     * Link it to the DTD
+     */
+    ret->parent = dtd;
+    ret->doc = dtd->doc;
+    if (dtd->last == NULL) {
+	dtd->children = dtd->last = (xmlNodePtr) ret;
+    } else {
+        dtd->last->next = (xmlNodePtr) ret;
+	ret->prev = dtd->last;
+	dtd->last = (xmlNodePtr) ret;
+    }
+    return(ret);
+}
+
+/**
+ * xmlAddDocEntity:
+ * @doc:  the document
+ * @name:  the entity name
+ * @type:  the entity type XML_xxx_yyy_ENTITY
+ * @ExternalID:  the entity external ID if available
+ * @SystemID:  the entity system ID if available
+ * @content:  the entity content
+ *
+ * Register a new entity for this document.
+ *
+ * Returns a pointer to the entity or NULL in case of error
+ */
+xmlEntityPtr
+xmlAddDocEntity(xmlDocPtr doc, const xmlChar *name, int type,
+	        const xmlChar *ExternalID, const xmlChar *SystemID,
+	        const xmlChar *content) {
+    xmlEntityPtr ret;
+    xmlDtdPtr dtd;
+
+    if (doc == NULL) {
+	xmlEntitiesErr(XML_DTD_NO_DOC,
+	        "xmlAddDocEntity: document is NULL");
+	return(NULL);
+    }
+    if (doc->intSubset == NULL) {
+	xmlEntitiesErr(XML_DTD_NO_DTD,
+	        "xmlAddDocEntity: document without internal subset");
+	return(NULL);
+    }
+    dtd = doc->intSubset;
+    ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content);
+    if (ret == NULL) return(NULL);
+
+    /*
+     * Link it to the DTD
+     */
+    ret->parent = dtd;
+    ret->doc = dtd->doc;
+    if (dtd->last == NULL) {
+	dtd->children = dtd->last = (xmlNodePtr) ret;
+    } else {
+	dtd->last->next = (xmlNodePtr) ret;
+	ret->prev = dtd->last;
+	dtd->last = (xmlNodePtr) ret;
+    }
+    return(ret);
+}
+
+/**
+ * xmlNewEntity:
+ * @doc:  the document
+ * @name:  the entity name
+ * @type:  the entity type XML_xxx_yyy_ENTITY
+ * @ExternalID:  the entity external ID if available
+ * @SystemID:  the entity system ID if available
+ * @content:  the entity content
+ *
+ * Create a new entity, this differs from xmlAddDocEntity() that if
+ * the document is NULL or has no internal subset defined, then an
  * unlinked entity structure will be returned, it is then the responsibility
- * of the caller to link it to the document later or free it when not needed 
- * anymore. 
- * 
- * Returns a pointer to the entity or NULL in case of error 
- */ 
-xmlEntityPtr 
-xmlNewEntity(xmlDocPtr doc, const xmlChar *name, int type, 
-	     const xmlChar *ExternalID, const xmlChar *SystemID, 
-	     const xmlChar *content) { 
-    xmlEntityPtr ret; 
-    xmlDictPtr dict; 
- 
-    if ((doc != NULL) && (doc->intSubset != NULL)) { 
-	return(xmlAddDocEntity(doc, name, type, ExternalID, SystemID, content)); 
-    } 
-    if (doc != NULL) 
-        dict = doc->dict; 
-    else 
-        dict = NULL; 
-    ret = xmlCreateEntity(dict, name, type, ExternalID, SystemID, content); 
-    if (ret == NULL) 
-        return(NULL); 
-    ret->doc = doc; 
-    return(ret); 
-} 
- 
-/** 
- * xmlGetEntityFromTable: 
- * @table:  an entity table 
- * @name:  the entity name 
- * @parameter:  look for parameter entities 
- * 
- * Do an entity lookup in the table. 
- * returns the corresponding parameter entity, if found. 
- * 
- * Returns A pointer to the entity structure or NULL if not found. 
- */ 
-static xmlEntityPtr 
-xmlGetEntityFromTable(xmlEntitiesTablePtr table, const xmlChar *name) { 
-    return((xmlEntityPtr) xmlHashLookup(table, name)); 
-} 
- 
-/** 
- * xmlGetParameterEntity: 
- * @doc:  the document referencing the entity 
- * @name:  the entity name 
- * 
- * Do an entity lookup in the internal and external subsets and 
- * returns the corresponding parameter entity, if found. 
- * 
- * Returns A pointer to the entity structure or NULL if not found. 
- */ 
-xmlEntityPtr 
-xmlGetParameterEntity(xmlDocPtr doc, const xmlChar *name) { 
-    xmlEntitiesTablePtr table; 
-    xmlEntityPtr ret; 
- 
-    if (doc == NULL) 
-	return(NULL); 
-    if ((doc->intSubset != NULL) && (doc->intSubset->pentities != NULL)) { 
-	table = (xmlEntitiesTablePtr) doc->intSubset->pentities; 
-	ret = xmlGetEntityFromTable(table, name); 
-	if (ret != NULL) 
-	    return(ret); 
-    } 
-    if ((doc->extSubset != NULL) && (doc->extSubset->pentities != NULL)) { 
-	table = (xmlEntitiesTablePtr) doc->extSubset->pentities; 
-	return(xmlGetEntityFromTable(table, name)); 
-    } 
-    return(NULL); 
-} 
- 
-/** 
- * xmlGetDtdEntity: 
- * @doc:  the document referencing the entity 
- * @name:  the entity name 
- * 
- * Do an entity lookup in the DTD entity hash table and 
- * returns the corresponding entity, if found. 
- * Note: the first argument is the document node, not the DTD node. 
- * 
- * Returns A pointer to the entity structure or NULL if not found. 
- */ 
-xmlEntityPtr 
-xmlGetDtdEntity(xmlDocPtr doc, const xmlChar *name) { 
-    xmlEntitiesTablePtr table; 
- 
-    if (doc == NULL) 
-	return(NULL); 
-    if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) { 
-	table = (xmlEntitiesTablePtr) doc->extSubset->entities; 
-	return(xmlGetEntityFromTable(table, name)); 
-    } 
-    return(NULL); 
-} 
- 
-/** 
- * xmlGetDocEntity: 
- * @doc:  the document referencing the entity 
- * @name:  the entity name 
- * 
- * Do an entity lookup in the document entity hash table and 
- * returns the corresponding entity, otherwise a lookup is done 
- * in the predefined entities too. 
- * 
- * Returns A pointer to the entity structure or NULL if not found. 
- */ 
-xmlEntityPtr 
-xmlGetDocEntity(const xmlDoc *doc, const xmlChar *name) { 
-    xmlEntityPtr cur; 
-    xmlEntitiesTablePtr table; 
- 
-    if (doc != NULL) { 
-	if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) { 
-	    table = (xmlEntitiesTablePtr) doc->intSubset->entities; 
-	    cur = xmlGetEntityFromTable(table, name); 
-	    if (cur != NULL) 
-		return(cur); 
-	} 
-	if (doc->standalone != 1) { 
-	    if ((doc->extSubset != NULL) && 
-		(doc->extSubset->entities != NULL)) { 
-		table = (xmlEntitiesTablePtr) doc->extSubset->entities; 
-		cur = xmlGetEntityFromTable(table, name); 
-		if (cur != NULL) 
-		    return(cur); 
-	    } 
-	} 
-    } 
-    return(xmlGetPredefinedEntity(name)); 
-} 
- 
-/* 
- * Macro used to grow the current buffer. 
- */ 
-#define growBufferReentrant() {						\ 
-    xmlChar *tmp;                                                       \ 
-    size_t new_size = buffer_size * 2;                                  \ 
-    if (new_size < buffer_size) goto mem_error;                         \ 
-    tmp = (xmlChar *) xmlRealloc(buffer, new_size);	                \ 
-    if (tmp == NULL) goto mem_error;                                    \ 
-    buffer = tmp;							\ 
-    buffer_size = new_size;						\ 
-} 
- 
-/** 
- * xmlEncodeEntitiesInternal: 
- * @doc:  the document containing the string 
- * @input:  A string to convert to XML. 
+ * of the caller to link it to the document later or free it when not needed
+ * anymore.
+ *
+ * Returns a pointer to the entity or NULL in case of error
+ */
+xmlEntityPtr
+xmlNewEntity(xmlDocPtr doc, const xmlChar *name, int type,
+	     const xmlChar *ExternalID, const xmlChar *SystemID,
+	     const xmlChar *content) {
+    xmlEntityPtr ret;
+    xmlDictPtr dict;
+
+    if ((doc != NULL) && (doc->intSubset != NULL)) {
+	return(xmlAddDocEntity(doc, name, type, ExternalID, SystemID, content));
+    }
+    if (doc != NULL)
+        dict = doc->dict;
+    else
+        dict = NULL;
+    ret = xmlCreateEntity(dict, name, type, ExternalID, SystemID, content);
+    if (ret == NULL)
+        return(NULL);
+    ret->doc = doc;
+    return(ret);
+}
+
+/**
+ * xmlGetEntityFromTable:
+ * @table:  an entity table
+ * @name:  the entity name
+ * @parameter:  look for parameter entities
+ *
+ * Do an entity lookup in the table.
+ * returns the corresponding parameter entity, if found.
+ *
+ * Returns A pointer to the entity structure or NULL if not found.
+ */
+static xmlEntityPtr
+xmlGetEntityFromTable(xmlEntitiesTablePtr table, const xmlChar *name) {
+    return((xmlEntityPtr) xmlHashLookup(table, name));
+}
+
+/**
+ * xmlGetParameterEntity:
+ * @doc:  the document referencing the entity
+ * @name:  the entity name
+ *
+ * Do an entity lookup in the internal and external subsets and
+ * returns the corresponding parameter entity, if found.
+ *
+ * Returns A pointer to the entity structure or NULL if not found.
+ */
+xmlEntityPtr
+xmlGetParameterEntity(xmlDocPtr doc, const xmlChar *name) {
+    xmlEntitiesTablePtr table;
+    xmlEntityPtr ret;
+
+    if (doc == NULL)
+	return(NULL);
+    if ((doc->intSubset != NULL) && (doc->intSubset->pentities != NULL)) {
+	table = (xmlEntitiesTablePtr) doc->intSubset->pentities;
+	ret = xmlGetEntityFromTable(table, name);
+	if (ret != NULL)
+	    return(ret);
+    }
+    if ((doc->extSubset != NULL) && (doc->extSubset->pentities != NULL)) {
+	table = (xmlEntitiesTablePtr) doc->extSubset->pentities;
+	return(xmlGetEntityFromTable(table, name));
+    }
+    return(NULL);
+}
+
+/**
+ * xmlGetDtdEntity:
+ * @doc:  the document referencing the entity
+ * @name:  the entity name
+ *
+ * Do an entity lookup in the DTD entity hash table and
+ * returns the corresponding entity, if found.
+ * Note: the first argument is the document node, not the DTD node.
+ *
+ * Returns A pointer to the entity structure or NULL if not found.
+ */
+xmlEntityPtr
+xmlGetDtdEntity(xmlDocPtr doc, const xmlChar *name) {
+    xmlEntitiesTablePtr table;
+
+    if (doc == NULL)
+	return(NULL);
+    if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
+	table = (xmlEntitiesTablePtr) doc->extSubset->entities;
+	return(xmlGetEntityFromTable(table, name));
+    }
+    return(NULL);
+}
+
+/**
+ * xmlGetDocEntity:
+ * @doc:  the document referencing the entity
+ * @name:  the entity name
+ *
+ * Do an entity lookup in the document entity hash table and
+ * returns the corresponding entity, otherwise a lookup is done
+ * in the predefined entities too.
+ *
+ * Returns A pointer to the entity structure or NULL if not found.
+ */
+xmlEntityPtr
+xmlGetDocEntity(const xmlDoc *doc, const xmlChar *name) {
+    xmlEntityPtr cur;
+    xmlEntitiesTablePtr table;
+
+    if (doc != NULL) {
+	if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
+	    table = (xmlEntitiesTablePtr) doc->intSubset->entities;
+	    cur = xmlGetEntityFromTable(table, name);
+	    if (cur != NULL)
+		return(cur);
+	}
+	if (doc->standalone != 1) {
+	    if ((doc->extSubset != NULL) &&
+		(doc->extSubset->entities != NULL)) {
+		table = (xmlEntitiesTablePtr) doc->extSubset->entities;
+		cur = xmlGetEntityFromTable(table, name);
+		if (cur != NULL)
+		    return(cur);
+	    }
+	}
+    }
+    return(xmlGetPredefinedEntity(name));
+}
+
+/*
+ * Macro used to grow the current buffer.
+ */
+#define growBufferReentrant() {						\
+    xmlChar *tmp;                                                       \
+    size_t new_size = buffer_size * 2;                                  \
+    if (new_size < buffer_size) goto mem_error;                         \
+    tmp = (xmlChar *) xmlRealloc(buffer, new_size);	                \
+    if (tmp == NULL) goto mem_error;                                    \
+    buffer = tmp;							\
+    buffer_size = new_size;						\
+}
+
+/**
+ * xmlEncodeEntitiesInternal:
+ * @doc:  the document containing the string
+ * @input:  A string to convert to XML.
  * @attr: are we handling an attribute value
- * 
- * Do a global encoding of a string, replacing the predefined entities 
- * and non ASCII values with their entities and CharRef counterparts. 
- * Contrary to xmlEncodeEntities, this routine is reentrant, and result 
- * must be deallocated. 
- * 
- * Returns A newly allocated string with the substitution done. 
- */ 
-static xmlChar * 
-xmlEncodeEntitiesInternal(xmlDocPtr doc, const xmlChar *input, int attr) { 
-    const xmlChar *cur = input; 
-    xmlChar *buffer = NULL; 
-    xmlChar *out = NULL; 
-    size_t buffer_size = 0; 
-    int html = 0; 
- 
-    if (input == NULL) return(NULL); 
-    if (doc != NULL) 
-        html = (doc->type == XML_HTML_DOCUMENT_NODE); 
- 
-    /* 
-     * allocate an translation buffer. 
-     */ 
-    buffer_size = 1000; 
-    buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar)); 
-    if (buffer == NULL) { 
-        xmlEntitiesErrMemory("xmlEncodeEntities: malloc failed"); 
-	return(NULL); 
-    } 
-    out = buffer; 
- 
-    while (*cur != '\0') { 
-        size_t indx = out - buffer; 
-        if (indx + 100 > buffer_size) { 
- 
-	    growBufferReentrant(); 
-	    out = &buffer[indx]; 
-	} 
- 
-	/* 
-	 * By default one have to encode at least '<', '>', '"' and '&' ! 
-	 */ 
-	if (*cur == '<') { 
-	    const xmlChar *end; 
- 
-	    /* 
-	     * Special handling of server side include in HTML attributes 
-	     */ 
-	    if (html && attr && 
-	        (cur[1] == '!') && (cur[2] == '-') && (cur[3] == '-') && 
-	        ((end = xmlStrstr(cur, BAD_CAST "-->")) != NULL)) { 
-	        while (cur != end) { 
-		    *out++ = *cur++; 
-		    indx = out - buffer; 
-		    if (indx + 100 > buffer_size) { 
-			growBufferReentrant(); 
-			out = &buffer[indx]; 
-		    } 
-		} 
-		*out++ = *cur++; 
-		*out++ = *cur++; 
-		*out++ = *cur++; 
-		continue; 
-	    } 
-	    *out++ = '&'; 
-	    *out++ = 'l'; 
-	    *out++ = 't'; 
-	    *out++ = ';'; 
-	} else if (*cur == '>') { 
-	    *out++ = '&'; 
-	    *out++ = 'g'; 
-	    *out++ = 't'; 
-	    *out++ = ';'; 
-	} else if (*cur == '&') { 
-	    /* 
-	     * Special handling of &{...} construct from HTML 4, see 
-	     * http://www.w3.org/TR/html401/appendix/notes.html#h-B.7.1 
-	     */ 
-	    if (html && attr && (cur[1] == '{') && 
-	        (strchr((const char *) cur, '}'))) { 
-	        while (*cur != '}') { 
-		    *out++ = *cur++; 
-		    indx = out - buffer; 
-		    if (indx + 100 > buffer_size) { 
-			growBufferReentrant(); 
-			out = &buffer[indx]; 
-		    } 
-		} 
-		*out++ = *cur++; 
-		continue; 
-	    } 
-	    *out++ = '&'; 
-	    *out++ = 'a'; 
-	    *out++ = 'm'; 
-	    *out++ = 'p'; 
-	    *out++ = ';'; 
-	} else if (((*cur >= 0x20) && (*cur < 0x80)) || 
-	    (*cur == '\n') || (*cur == '\t') || ((html) && (*cur == '\r'))) { 
-	    /* 
-	     * default case, just copy ! 
-	     */ 
-	    *out++ = *cur; 
-	} else if (*cur >= 0x80) { 
-	    if (((doc != NULL) && (doc->encoding != NULL)) || (html)) { 
-		/* 
-		 * Bjørn Reese <[email protected]> provided the patch 
-	        xmlChar xc; 
-	        xc = (*cur & 0x3F) << 6; 
-	        if (cur[1] != 0) { 
-		    xc += *(++cur) & 0x3F; 
-		    *out++ = xc; 
-	        } else 
-		 */ 
-		*out++ = *cur; 
-	    } else { 
-		/* 
-		 * We assume we have UTF-8 input. 
-		 */ 
-		char buf[11], *ptr; 
-		int val = 0, l = 1; 
- 
-		if (*cur < 0xC0) { 
-		    xmlEntitiesErr(XML_CHECK_NOT_UTF8, 
-			    "xmlEncodeEntities: input not UTF-8"); 
-		    if (doc != NULL) 
-			doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1"); 
-		    snprintf(buf, sizeof(buf), "&#%d;", *cur); 
-		    buf[sizeof(buf) - 1] = 0; 
-		    ptr = buf; 
-		    while (*ptr != 0) *out++ = *ptr++; 
-		    cur++; 
-		    continue; 
-		} else if (*cur < 0xE0) { 
-                    val = (cur[0]) & 0x1F; 
-		    val <<= 6; 
-		    val |= (cur[1]) & 0x3F; 
-		    l = 2; 
-		} else if (*cur < 0xF0) { 
-                    val = (cur[0]) & 0x0F; 
-		    val <<= 6; 
-		    val |= (cur[1]) & 0x3F; 
-		    val <<= 6; 
-		    val |= (cur[2]) & 0x3F; 
-		    l = 3; 
-		} else if (*cur < 0xF8) { 
-                    val = (cur[0]) & 0x07; 
-		    val <<= 6; 
-		    val |= (cur[1]) & 0x3F; 
-		    val <<= 6; 
-		    val |= (cur[2]) & 0x3F; 
-		    val <<= 6; 
-		    val |= (cur[3]) & 0x3F; 
-		    l = 4; 
-		} 
-		if ((l == 1) || (!IS_CHAR(val))) { 
-		    xmlEntitiesErr(XML_ERR_INVALID_CHAR, 
-			"xmlEncodeEntities: char out of range\n"); 
-		    if (doc != NULL) 
-			doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1"); 
-		    snprintf(buf, sizeof(buf), "&#%d;", *cur); 
-		    buf[sizeof(buf) - 1] = 0; 
-		    ptr = buf; 
-		    while (*ptr != 0) *out++ = *ptr++; 
-		    cur++; 
-		    continue; 
-		} 
-		/* 
-		 * We could do multiple things here. Just save as a char ref 
-		 */ 
-		snprintf(buf, sizeof(buf), "&#x%X;", val); 
-		buf[sizeof(buf) - 1] = 0; 
-		ptr = buf; 
-		while (*ptr != 0) *out++ = *ptr++; 
-		cur += l; 
-		continue; 
-	    } 
-	} else if (IS_BYTE_CHAR(*cur)) { 
-	    char buf[11], *ptr; 
- 
-	    snprintf(buf, sizeof(buf), "&#%d;", *cur); 
-	    buf[sizeof(buf) - 1] = 0; 
-            ptr = buf; 
-	    while (*ptr != 0) *out++ = *ptr++; 
-	} 
-	cur++; 
-    } 
-    *out = 0; 
-    return(buffer); 
- 
-mem_error: 
-    xmlEntitiesErrMemory("xmlEncodeEntities: realloc failed"); 
-    xmlFree(buffer); 
-    return(NULL); 
-} 
- 
-/** 
- * xmlEncodeAttributeEntities: 
- * @doc:  the document containing the string 
- * @input:  A string to convert to XML. 
- * 
- * Do a global encoding of a string, replacing the predefined entities 
- * and non ASCII values with their entities and CharRef counterparts for 
- * attribute values. 
- * 
- * Returns A newly allocated string with the substitution done. 
- */ 
-xmlChar * 
-xmlEncodeAttributeEntities(xmlDocPtr doc, const xmlChar *input) { 
-    return xmlEncodeEntitiesInternal(doc, input, 1); 
-} 
- 
-/** 
- * xmlEncodeEntitiesReentrant: 
- * @doc:  the document containing the string 
- * @input:  A string to convert to XML. 
- * 
- * Do a global encoding of a string, replacing the predefined entities 
- * and non ASCII values with their entities and CharRef counterparts. 
- * Contrary to xmlEncodeEntities, this routine is reentrant, and result 
- * must be deallocated. 
- * 
- * Returns A newly allocated string with the substitution done. 
- */ 
-xmlChar * 
-xmlEncodeEntitiesReentrant(xmlDocPtr doc, const xmlChar *input) { 
-    return xmlEncodeEntitiesInternal(doc, input, 0); 
-} 
- 
-/** 
- * xmlEncodeSpecialChars: 
- * @doc:  the document containing the string 
- * @input:  A string to convert to XML. 
- * 
- * Do a global encoding of a string, replacing the predefined entities 
- * this routine is reentrant, and result must be deallocated. 
- * 
- * Returns A newly allocated string with the substitution done. 
- */ 
-xmlChar * 
-xmlEncodeSpecialChars(const xmlDoc *doc ATTRIBUTE_UNUSED, const xmlChar *input) { 
-    const xmlChar *cur = input; 
-    xmlChar *buffer = NULL; 
-    xmlChar *out = NULL; 
-    size_t buffer_size = 0; 
-    if (input == NULL) return(NULL); 
- 
-    /* 
-     * allocate an translation buffer. 
-     */ 
-    buffer_size = 1000; 
-    buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar)); 
-    if (buffer == NULL) { 
-        xmlEntitiesErrMemory("xmlEncodeSpecialChars: malloc failed"); 
-	return(NULL); 
-    } 
-    out = buffer; 
- 
-    while (*cur != '\0') { 
-        size_t indx = out - buffer; 
-        if (indx + 10 > buffer_size) { 
- 
-	    growBufferReentrant(); 
-	    out = &buffer[indx]; 
-	} 
- 
-	/* 
-	 * By default one have to encode at least '<', '>', '"' and '&' ! 
-	 */ 
-	if (*cur == '<') { 
-	    *out++ = '&'; 
-	    *out++ = 'l'; 
-	    *out++ = 't'; 
-	    *out++ = ';'; 
-	} else if (*cur == '>') { 
-	    *out++ = '&'; 
-	    *out++ = 'g'; 
-	    *out++ = 't'; 
-	    *out++ = ';'; 
-	} else if (*cur == '&') { 
-	    *out++ = '&'; 
-	    *out++ = 'a'; 
-	    *out++ = 'm'; 
-	    *out++ = 'p'; 
-	    *out++ = ';'; 
-	} else if (*cur == '"') { 
-	    *out++ = '&'; 
-	    *out++ = 'q'; 
-	    *out++ = 'u'; 
-	    *out++ = 'o'; 
-	    *out++ = 't'; 
-	    *out++ = ';'; 
-	} else if (*cur == '\r') { 
-	    *out++ = '&'; 
-	    *out++ = '#'; 
-	    *out++ = '1'; 
-	    *out++ = '3'; 
-	    *out++ = ';'; 
-	} else { 
-	    /* 
-	     * Works because on UTF-8, all extended sequences cannot 
-	     * result in bytes in the ASCII range. 
-	     */ 
-	    *out++ = *cur; 
-	} 
-	cur++; 
-    } 
-    *out = 0; 
-    return(buffer); 
- 
-mem_error: 
-    xmlEntitiesErrMemory("xmlEncodeSpecialChars: realloc failed"); 
-    xmlFree(buffer); 
-    return(NULL); 
-} 
- 
-/** 
- * xmlCreateEntitiesTable: 
- * 
- * create and initialize an empty entities hash table. 
- * This really doesn't make sense and should be deprecated 
- * 
- * Returns the xmlEntitiesTablePtr just created or NULL in case of error. 
- */ 
-xmlEntitiesTablePtr 
-xmlCreateEntitiesTable(void) { 
-    return((xmlEntitiesTablePtr) xmlHashCreate(0)); 
-} 
- 
-/** 
- * xmlFreeEntityWrapper: 
- * @entity:  An entity 
- * @name:  its name 
- * 
- * Deallocate the memory used by an entities in the hash table. 
- */ 
-static void 
+ *
+ * Do a global encoding of a string, replacing the predefined entities
+ * and non ASCII values with their entities and CharRef counterparts.
+ * Contrary to xmlEncodeEntities, this routine is reentrant, and result
+ * must be deallocated.
+ *
+ * Returns A newly allocated string with the substitution done.
+ */
+static xmlChar *
+xmlEncodeEntitiesInternal(xmlDocPtr doc, const xmlChar *input, int attr) {
+    const xmlChar *cur = input;
+    xmlChar *buffer = NULL;
+    xmlChar *out = NULL;
+    size_t buffer_size = 0;
+    int html = 0;
+
+    if (input == NULL) return(NULL);
+    if (doc != NULL)
+        html = (doc->type == XML_HTML_DOCUMENT_NODE);
+
+    /*
+     * allocate an translation buffer.
+     */
+    buffer_size = 1000;
+    buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
+    if (buffer == NULL) {
+        xmlEntitiesErrMemory("xmlEncodeEntities: malloc failed");
+	return(NULL);
+    }
+    out = buffer;
+
+    while (*cur != '\0') {
+        size_t indx = out - buffer;
+        if (indx + 100 > buffer_size) {
+
+	    growBufferReentrant();
+	    out = &buffer[indx];
+	}
+
+	/*
+	 * By default one have to encode at least '<', '>', '"' and '&' !
+	 */
+	if (*cur == '<') {
+	    const xmlChar *end;
+
+	    /*
+	     * Special handling of server side include in HTML attributes
+	     */
+	    if (html && attr &&
+	        (cur[1] == '!') && (cur[2] == '-') && (cur[3] == '-') &&
+	        ((end = xmlStrstr(cur, BAD_CAST "-->")) != NULL)) {
+	        while (cur != end) {
+		    *out++ = *cur++;
+		    indx = out - buffer;
+		    if (indx + 100 > buffer_size) {
+			growBufferReentrant();
+			out = &buffer[indx];
+		    }
+		}
+		*out++ = *cur++;
+		*out++ = *cur++;
+		*out++ = *cur++;
+		continue;
+	    }
+	    *out++ = '&';
+	    *out++ = 'l';
+	    *out++ = 't';
+	    *out++ = ';';
+	} else if (*cur == '>') {
+	    *out++ = '&';
+	    *out++ = 'g';
+	    *out++ = 't';
+	    *out++ = ';';
+	} else if (*cur == '&') {
+	    /*
+	     * Special handling of &{...} construct from HTML 4, see
+	     * http://www.w3.org/TR/html401/appendix/notes.html#h-B.7.1
+	     */
+	    if (html && attr && (cur[1] == '{') &&
+	        (strchr((const char *) cur, '}'))) {
+	        while (*cur != '}') {
+		    *out++ = *cur++;
+		    indx = out - buffer;
+		    if (indx + 100 > buffer_size) {
+			growBufferReentrant();
+			out = &buffer[indx];
+		    }
+		}
+		*out++ = *cur++;
+		continue;
+	    }
+	    *out++ = '&';
+	    *out++ = 'a';
+	    *out++ = 'm';
+	    *out++ = 'p';
+	    *out++ = ';';
+	} else if (((*cur >= 0x20) && (*cur < 0x80)) ||
+	    (*cur == '\n') || (*cur == '\t') || ((html) && (*cur == '\r'))) {
+	    /*
+	     * default case, just copy !
+	     */
+	    *out++ = *cur;
+	} else if (*cur >= 0x80) {
+	    if (((doc != NULL) && (doc->encoding != NULL)) || (html)) {
+		/*
+		 * Bjørn Reese <[email protected]> provided the patch
+	        xmlChar xc;
+	        xc = (*cur & 0x3F) << 6;
+	        if (cur[1] != 0) {
+		    xc += *(++cur) & 0x3F;
+		    *out++ = xc;
+	        } else
+		 */
+		*out++ = *cur;
+	    } else {
+		/*
+		 * We assume we have UTF-8 input.
+		 */
+		char buf[11], *ptr;
+		int val = 0, l = 1;
+
+		if (*cur < 0xC0) {
+		    xmlEntitiesErr(XML_CHECK_NOT_UTF8,
+			    "xmlEncodeEntities: input not UTF-8");
+		    if (doc != NULL)
+			doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
+		    snprintf(buf, sizeof(buf), "&#%d;", *cur);
+		    buf[sizeof(buf) - 1] = 0;
+		    ptr = buf;
+		    while (*ptr != 0) *out++ = *ptr++;
+		    cur++;
+		    continue;
+		} else if (*cur < 0xE0) {
+                    val = (cur[0]) & 0x1F;
+		    val <<= 6;
+		    val |= (cur[1]) & 0x3F;
+		    l = 2;
+		} else if (*cur < 0xF0) {
+                    val = (cur[0]) & 0x0F;
+		    val <<= 6;
+		    val |= (cur[1]) & 0x3F;
+		    val <<= 6;
+		    val |= (cur[2]) & 0x3F;
+		    l = 3;
+		} else if (*cur < 0xF8) {
+                    val = (cur[0]) & 0x07;
+		    val <<= 6;
+		    val |= (cur[1]) & 0x3F;
+		    val <<= 6;
+		    val |= (cur[2]) & 0x3F;
+		    val <<= 6;
+		    val |= (cur[3]) & 0x3F;
+		    l = 4;
+		}
+		if ((l == 1) || (!IS_CHAR(val))) {
+		    xmlEntitiesErr(XML_ERR_INVALID_CHAR,
+			"xmlEncodeEntities: char out of range\n");
+		    if (doc != NULL)
+			doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
+		    snprintf(buf, sizeof(buf), "&#%d;", *cur);
+		    buf[sizeof(buf) - 1] = 0;
+		    ptr = buf;
+		    while (*ptr != 0) *out++ = *ptr++;
+		    cur++;
+		    continue;
+		}
+		/*
+		 * We could do multiple things here. Just save as a char ref
+		 */
+		snprintf(buf, sizeof(buf), "&#x%X;", val);
+		buf[sizeof(buf) - 1] = 0;
+		ptr = buf;
+		while (*ptr != 0) *out++ = *ptr++;
+		cur += l;
+		continue;
+	    }
+	} else if (IS_BYTE_CHAR(*cur)) {
+	    char buf[11], *ptr;
+
+	    snprintf(buf, sizeof(buf), "&#%d;", *cur);
+	    buf[sizeof(buf) - 1] = 0;
+            ptr = buf;
+	    while (*ptr != 0) *out++ = *ptr++;
+	}
+	cur++;
+    }
+    *out = 0;
+    return(buffer);
+
+mem_error:
+    xmlEntitiesErrMemory("xmlEncodeEntities: realloc failed");
+    xmlFree(buffer);
+    return(NULL);
+}
+
+/**
+ * xmlEncodeAttributeEntities:
+ * @doc:  the document containing the string
+ * @input:  A string to convert to XML.
+ *
+ * Do a global encoding of a string, replacing the predefined entities
+ * and non ASCII values with their entities and CharRef counterparts for
+ * attribute values.
+ *
+ * Returns A newly allocated string with the substitution done.
+ */
+xmlChar *
+xmlEncodeAttributeEntities(xmlDocPtr doc, const xmlChar *input) {
+    return xmlEncodeEntitiesInternal(doc, input, 1);
+}
+
+/**
+ * xmlEncodeEntitiesReentrant:
+ * @doc:  the document containing the string
+ * @input:  A string to convert to XML.
+ *
+ * Do a global encoding of a string, replacing the predefined entities
+ * and non ASCII values with their entities and CharRef counterparts.
+ * Contrary to xmlEncodeEntities, this routine is reentrant, and result
+ * must be deallocated.
+ *
+ * Returns A newly allocated string with the substitution done.
+ */
+xmlChar *
+xmlEncodeEntitiesReentrant(xmlDocPtr doc, const xmlChar *input) {
+    return xmlEncodeEntitiesInternal(doc, input, 0);
+}
+
+/**
+ * xmlEncodeSpecialChars:
+ * @doc:  the document containing the string
+ * @input:  A string to convert to XML.
+ *
+ * Do a global encoding of a string, replacing the predefined entities
+ * this routine is reentrant, and result must be deallocated.
+ *
+ * Returns A newly allocated string with the substitution done.
+ */
+xmlChar *
+xmlEncodeSpecialChars(const xmlDoc *doc ATTRIBUTE_UNUSED, const xmlChar *input) {
+    const xmlChar *cur = input;
+    xmlChar *buffer = NULL;
+    xmlChar *out = NULL;
+    size_t buffer_size = 0;
+    if (input == NULL) return(NULL);
+
+    /*
+     * allocate an translation buffer.
+     */
+    buffer_size = 1000;
+    buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
+    if (buffer == NULL) {
+        xmlEntitiesErrMemory("xmlEncodeSpecialChars: malloc failed");
+	return(NULL);
+    }
+    out = buffer;
+
+    while (*cur != '\0') {
+        size_t indx = out - buffer;
+        if (indx + 10 > buffer_size) {
+
+	    growBufferReentrant();
+	    out = &buffer[indx];
+	}
+
+	/*
+	 * By default one have to encode at least '<', '>', '"' and '&' !
+	 */
+	if (*cur == '<') {
+	    *out++ = '&';
+	    *out++ = 'l';
+	    *out++ = 't';
+	    *out++ = ';';
+	} else if (*cur == '>') {
+	    *out++ = '&';
+	    *out++ = 'g';
+	    *out++ = 't';
+	    *out++ = ';';
+	} else if (*cur == '&') {
+	    *out++ = '&';
+	    *out++ = 'a';
+	    *out++ = 'm';
+	    *out++ = 'p';
+	    *out++ = ';';
+	} else if (*cur == '"') {
+	    *out++ = '&';
+	    *out++ = 'q';
+	    *out++ = 'u';
+	    *out++ = 'o';
+	    *out++ = 't';
+	    *out++ = ';';
+	} else if (*cur == '\r') {
+	    *out++ = '&';
+	    *out++ = '#';
+	    *out++ = '1';
+	    *out++ = '3';
+	    *out++ = ';';
+	} else {
+	    /*
+	     * Works because on UTF-8, all extended sequences cannot
+	     * result in bytes in the ASCII range.
+	     */
+	    *out++ = *cur;
+	}
+	cur++;
+    }
+    *out = 0;
+    return(buffer);
+
+mem_error:
+    xmlEntitiesErrMemory("xmlEncodeSpecialChars: realloc failed");
+    xmlFree(buffer);
+    return(NULL);
+}
+
+/**
+ * xmlCreateEntitiesTable:
+ *
+ * create and initialize an empty entities hash table.
+ * This really doesn't make sense and should be deprecated
+ *
+ * Returns the xmlEntitiesTablePtr just created or NULL in case of error.
+ */
+xmlEntitiesTablePtr
+xmlCreateEntitiesTable(void) {
+    return((xmlEntitiesTablePtr) xmlHashCreate(0));
+}
+
+/**
+ * xmlFreeEntityWrapper:
+ * @entity:  An entity
+ * @name:  its name
+ *
+ * Deallocate the memory used by an entities in the hash table.
+ */
+static void
 xmlFreeEntityWrapper(void *entity, const xmlChar *name ATTRIBUTE_UNUSED) {
-    if (entity != NULL) 
+    if (entity != NULL)
 	xmlFreeEntity((xmlEntityPtr) entity);
-} 
- 
-/** 
- * xmlFreeEntitiesTable: 
- * @table:  An entity table 
- * 
- * Deallocate the memory used by an entities hash table. 
- */ 
-void 
-xmlFreeEntitiesTable(xmlEntitiesTablePtr table) { 
+}
+
+/**
+ * xmlFreeEntitiesTable:
+ * @table:  An entity table
+ *
+ * Deallocate the memory used by an entities hash table.
+ */
+void
+xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
     xmlHashFree(table, xmlFreeEntityWrapper);
-} 
- 
-#ifdef LIBXML_TREE_ENABLED 
-/** 
- * xmlCopyEntity: 
- * @ent:  An entity 
- * 
- * Build a copy of an entity 
- * 
- * Returns the new xmlEntitiesPtr or NULL in case of error. 
- */ 
+}
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlCopyEntity:
+ * @ent:  An entity
+ *
+ * Build a copy of an entity
+ *
+ * Returns the new xmlEntitiesPtr or NULL in case of error.
+ */
 static void *
 xmlCopyEntity(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) {
     xmlEntityPtr ent = (xmlEntityPtr) payload;
-    xmlEntityPtr cur; 
- 
-    cur = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity)); 
-    if (cur == NULL) { 
-        xmlEntitiesErrMemory("xmlCopyEntity:: malloc failed"); 
-	return(NULL); 
-    } 
-    memset(cur, 0, sizeof(xmlEntity)); 
-    cur->type = XML_ENTITY_DECL; 
- 
-    cur->etype = ent->etype; 
-    if (ent->name != NULL) 
-	cur->name = xmlStrdup(ent->name); 
-    if (ent->ExternalID != NULL) 
-	cur->ExternalID = xmlStrdup(ent->ExternalID); 
-    if (ent->SystemID != NULL) 
-	cur->SystemID = xmlStrdup(ent->SystemID); 
-    if (ent->content != NULL) 
-	cur->content = xmlStrdup(ent->content); 
-    if (ent->orig != NULL) 
-	cur->orig = xmlStrdup(ent->orig); 
-    if (ent->URI != NULL) 
-	cur->URI = xmlStrdup(ent->URI); 
-    return(cur); 
-} 
- 
-/** 
- * xmlCopyEntitiesTable: 
- * @table:  An entity table 
- * 
- * Build a copy of an entity table. 
- * 
- * Returns the new xmlEntitiesTablePtr or NULL in case of error. 
- */ 
-xmlEntitiesTablePtr 
-xmlCopyEntitiesTable(xmlEntitiesTablePtr table) { 
+    xmlEntityPtr cur;
+
+    cur = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
+    if (cur == NULL) {
+        xmlEntitiesErrMemory("xmlCopyEntity:: malloc failed");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlEntity));
+    cur->type = XML_ENTITY_DECL;
+
+    cur->etype = ent->etype;
+    if (ent->name != NULL)
+	cur->name = xmlStrdup(ent->name);
+    if (ent->ExternalID != NULL)
+	cur->ExternalID = xmlStrdup(ent->ExternalID);
+    if (ent->SystemID != NULL)
+	cur->SystemID = xmlStrdup(ent->SystemID);
+    if (ent->content != NULL)
+	cur->content = xmlStrdup(ent->content);
+    if (ent->orig != NULL)
+	cur->orig = xmlStrdup(ent->orig);
+    if (ent->URI != NULL)
+	cur->URI = xmlStrdup(ent->URI);
+    return(cur);
+}
+
+/**
+ * xmlCopyEntitiesTable:
+ * @table:  An entity table
+ *
+ * Build a copy of an entity table.
+ *
+ * Returns the new xmlEntitiesTablePtr or NULL in case of error.
+ */
+xmlEntitiesTablePtr
+xmlCopyEntitiesTable(xmlEntitiesTablePtr table) {
     return(xmlHashCopy(table, xmlCopyEntity));
-} 
-#endif /* LIBXML_TREE_ENABLED */ 
- 
-#ifdef LIBXML_OUTPUT_ENABLED 
- 
-/** 
- * xmlDumpEntityContent: 
- * @buf:  An XML buffer. 
- * @content:  The entity content. 
- * 
- * This will dump the quoted string value, taking care of the special 
- * treatment required by % 
- */ 
-static void 
-xmlDumpEntityContent(xmlBufferPtr buf, const xmlChar *content) { 
-    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return; 
-    if (xmlStrchr(content, '%')) { 
-        const xmlChar * base, *cur; 
- 
-	xmlBufferCCat(buf, "\""); 
-	base = cur = content; 
-	while (*cur != 0) { 
-	    if (*cur == '"') { 
-		if (base != cur) 
-		    xmlBufferAdd(buf, base, cur - base); 
-		xmlBufferAdd(buf, BAD_CAST "&quot;", 6); 
-		cur++; 
-		base = cur; 
-	    } else if (*cur == '%') { 
-		if (base != cur) 
-		    xmlBufferAdd(buf, base, cur - base); 
-		xmlBufferAdd(buf, BAD_CAST "&#x25;", 6); 
-		cur++; 
-		base = cur; 
-	    } else { 
-		cur++; 
-	    } 
-	} 
-	if (base != cur) 
-	    xmlBufferAdd(buf, base, cur - base); 
-	xmlBufferCCat(buf, "\""); 
-    } else { 
-        xmlBufferWriteQuotedString(buf, content); 
-    } 
-} 
- 
-/** 
- * xmlDumpEntityDecl: 
- * @buf:  An XML buffer. 
- * @ent:  An entity table 
- * 
- * This will dump the content of the entity table as an XML DTD definition 
- */ 
-void 
-xmlDumpEntityDecl(xmlBufferPtr buf, xmlEntityPtr ent) { 
-    if ((buf == NULL) || (ent == NULL)) return; 
-    switch (ent->etype) { 
-	case XML_INTERNAL_GENERAL_ENTITY: 
-	    xmlBufferWriteChar(buf, "<!ENTITY "); 
-	    xmlBufferWriteCHAR(buf, ent->name); 
-	    xmlBufferWriteChar(buf, " "); 
-	    if (ent->orig != NULL) 
-		xmlBufferWriteQuotedString(buf, ent->orig); 
-	    else 
-		xmlDumpEntityContent(buf, ent->content); 
-	    xmlBufferWriteChar(buf, ">\n"); 
-	    break; 
-	case XML_EXTERNAL_GENERAL_PARSED_ENTITY: 
-	    xmlBufferWriteChar(buf, "<!ENTITY "); 
-	    xmlBufferWriteCHAR(buf, ent->name); 
-	    if (ent->ExternalID != NULL) { 
-		 xmlBufferWriteChar(buf, " PUBLIC "); 
-		 xmlBufferWriteQuotedString(buf, ent->ExternalID); 
-		 xmlBufferWriteChar(buf, " "); 
-		 xmlBufferWriteQuotedString(buf, ent->SystemID); 
-	    } else { 
-		 xmlBufferWriteChar(buf, " SYSTEM "); 
-		 xmlBufferWriteQuotedString(buf, ent->SystemID); 
-	    } 
-	    xmlBufferWriteChar(buf, ">\n"); 
-	    break; 
-	case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY: 
-	    xmlBufferWriteChar(buf, "<!ENTITY "); 
-	    xmlBufferWriteCHAR(buf, ent->name); 
-	    if (ent->ExternalID != NULL) { 
-		 xmlBufferWriteChar(buf, " PUBLIC "); 
-		 xmlBufferWriteQuotedString(buf, ent->ExternalID); 
-		 xmlBufferWriteChar(buf, " "); 
-		 xmlBufferWriteQuotedString(buf, ent->SystemID); 
-	    } else { 
-		 xmlBufferWriteChar(buf, " SYSTEM "); 
-		 xmlBufferWriteQuotedString(buf, ent->SystemID); 
-	    } 
-	    if (ent->content != NULL) { /* Should be true ! */ 
-		xmlBufferWriteChar(buf, " NDATA "); 
-		if (ent->orig != NULL) 
-		    xmlBufferWriteCHAR(buf, ent->orig); 
-		else 
-		    xmlBufferWriteCHAR(buf, ent->content); 
-	    } 
-	    xmlBufferWriteChar(buf, ">\n"); 
-	    break; 
-	case XML_INTERNAL_PARAMETER_ENTITY: 
-	    xmlBufferWriteChar(buf, "<!ENTITY % "); 
-	    xmlBufferWriteCHAR(buf, ent->name); 
-	    xmlBufferWriteChar(buf, " "); 
-	    if (ent->orig == NULL) 
-		xmlDumpEntityContent(buf, ent->content); 
-	    else 
-		xmlBufferWriteQuotedString(buf, ent->orig); 
-	    xmlBufferWriteChar(buf, ">\n"); 
-	    break; 
-	case XML_EXTERNAL_PARAMETER_ENTITY: 
-	    xmlBufferWriteChar(buf, "<!ENTITY % "); 
-	    xmlBufferWriteCHAR(buf, ent->name); 
-	    if (ent->ExternalID != NULL) { 
-		 xmlBufferWriteChar(buf, " PUBLIC "); 
-		 xmlBufferWriteQuotedString(buf, ent->ExternalID); 
-		 xmlBufferWriteChar(buf, " "); 
-		 xmlBufferWriteQuotedString(buf, ent->SystemID); 
-	    } else { 
-		 xmlBufferWriteChar(buf, " SYSTEM "); 
-		 xmlBufferWriteQuotedString(buf, ent->SystemID); 
-	    } 
-	    xmlBufferWriteChar(buf, ">\n"); 
-	    break; 
-	default: 
-	    xmlEntitiesErr(XML_DTD_UNKNOWN_ENTITY, 
-		"xmlDumpEntitiesDecl: internal: unknown type entity type"); 
-    } 
-} 
- 
-/** 
- * xmlDumpEntityDeclScan: 
- * @ent:  An entity table 
- * @buf:  An XML buffer. 
- * 
- * When using the hash table scan function, arguments need to be reversed 
- */ 
-static void 
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+#ifdef LIBXML_OUTPUT_ENABLED
+
+/**
+ * xmlDumpEntityContent:
+ * @buf:  An XML buffer.
+ * @content:  The entity content.
+ *
+ * This will dump the quoted string value, taking care of the special
+ * treatment required by %
+ */
+static void
+xmlDumpEntityContent(xmlBufferPtr buf, const xmlChar *content) {
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
+    if (xmlStrchr(content, '%')) {
+        const xmlChar * base, *cur;
+
+	xmlBufferCCat(buf, "\"");
+	base = cur = content;
+	while (*cur != 0) {
+	    if (*cur == '"') {
+		if (base != cur)
+		    xmlBufferAdd(buf, base, cur - base);
+		xmlBufferAdd(buf, BAD_CAST "&quot;", 6);
+		cur++;
+		base = cur;
+	    } else if (*cur == '%') {
+		if (base != cur)
+		    xmlBufferAdd(buf, base, cur - base);
+		xmlBufferAdd(buf, BAD_CAST "&#x25;", 6);
+		cur++;
+		base = cur;
+	    } else {
+		cur++;
+	    }
+	}
+	if (base != cur)
+	    xmlBufferAdd(buf, base, cur - base);
+	xmlBufferCCat(buf, "\"");
+    } else {
+        xmlBufferWriteQuotedString(buf, content);
+    }
+}
+
+/**
+ * xmlDumpEntityDecl:
+ * @buf:  An XML buffer.
+ * @ent:  An entity table
+ *
+ * This will dump the content of the entity table as an XML DTD definition
+ */
+void
+xmlDumpEntityDecl(xmlBufferPtr buf, xmlEntityPtr ent) {
+    if ((buf == NULL) || (ent == NULL)) return;
+    switch (ent->etype) {
+	case XML_INTERNAL_GENERAL_ENTITY:
+	    xmlBufferWriteChar(buf, "<!ENTITY ");
+	    xmlBufferWriteCHAR(buf, ent->name);
+	    xmlBufferWriteChar(buf, " ");
+	    if (ent->orig != NULL)
+		xmlBufferWriteQuotedString(buf, ent->orig);
+	    else
+		xmlDumpEntityContent(buf, ent->content);
+	    xmlBufferWriteChar(buf, ">\n");
+	    break;
+	case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
+	    xmlBufferWriteChar(buf, "<!ENTITY ");
+	    xmlBufferWriteCHAR(buf, ent->name);
+	    if (ent->ExternalID != NULL) {
+		 xmlBufferWriteChar(buf, " PUBLIC ");
+		 xmlBufferWriteQuotedString(buf, ent->ExternalID);
+		 xmlBufferWriteChar(buf, " ");
+		 xmlBufferWriteQuotedString(buf, ent->SystemID);
+	    } else {
+		 xmlBufferWriteChar(buf, " SYSTEM ");
+		 xmlBufferWriteQuotedString(buf, ent->SystemID);
+	    }
+	    xmlBufferWriteChar(buf, ">\n");
+	    break;
+	case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
+	    xmlBufferWriteChar(buf, "<!ENTITY ");
+	    xmlBufferWriteCHAR(buf, ent->name);
+	    if (ent->ExternalID != NULL) {
+		 xmlBufferWriteChar(buf, " PUBLIC ");
+		 xmlBufferWriteQuotedString(buf, ent->ExternalID);
+		 xmlBufferWriteChar(buf, " ");
+		 xmlBufferWriteQuotedString(buf, ent->SystemID);
+	    } else {
+		 xmlBufferWriteChar(buf, " SYSTEM ");
+		 xmlBufferWriteQuotedString(buf, ent->SystemID);
+	    }
+	    if (ent->content != NULL) { /* Should be true ! */
+		xmlBufferWriteChar(buf, " NDATA ");
+		if (ent->orig != NULL)
+		    xmlBufferWriteCHAR(buf, ent->orig);
+		else
+		    xmlBufferWriteCHAR(buf, ent->content);
+	    }
+	    xmlBufferWriteChar(buf, ">\n");
+	    break;
+	case XML_INTERNAL_PARAMETER_ENTITY:
+	    xmlBufferWriteChar(buf, "<!ENTITY % ");
+	    xmlBufferWriteCHAR(buf, ent->name);
+	    xmlBufferWriteChar(buf, " ");
+	    if (ent->orig == NULL)
+		xmlDumpEntityContent(buf, ent->content);
+	    else
+		xmlBufferWriteQuotedString(buf, ent->orig);
+	    xmlBufferWriteChar(buf, ">\n");
+	    break;
+	case XML_EXTERNAL_PARAMETER_ENTITY:
+	    xmlBufferWriteChar(buf, "<!ENTITY % ");
+	    xmlBufferWriteCHAR(buf, ent->name);
+	    if (ent->ExternalID != NULL) {
+		 xmlBufferWriteChar(buf, " PUBLIC ");
+		 xmlBufferWriteQuotedString(buf, ent->ExternalID);
+		 xmlBufferWriteChar(buf, " ");
+		 xmlBufferWriteQuotedString(buf, ent->SystemID);
+	    } else {
+		 xmlBufferWriteChar(buf, " SYSTEM ");
+		 xmlBufferWriteQuotedString(buf, ent->SystemID);
+	    }
+	    xmlBufferWriteChar(buf, ">\n");
+	    break;
+	default:
+	    xmlEntitiesErr(XML_DTD_UNKNOWN_ENTITY,
+		"xmlDumpEntitiesDecl: internal: unknown type entity type");
+    }
+}
+
+/**
+ * xmlDumpEntityDeclScan:
+ * @ent:  An entity table
+ * @buf:  An XML buffer.
+ *
+ * When using the hash table scan function, arguments need to be reversed
+ */
+static void
 xmlDumpEntityDeclScan(void *ent, void *buf,
                       const xmlChar *name ATTRIBUTE_UNUSED) {
     xmlDumpEntityDecl((xmlBufferPtr) buf, (xmlEntityPtr) ent);
-} 
- 
-/** 
- * xmlDumpEntitiesTable: 
- * @buf:  An XML buffer. 
- * @table:  An entity table 
- * 
- * This will dump the content of the entity table as an XML DTD definition 
- */ 
-void 
-xmlDumpEntitiesTable(xmlBufferPtr buf, xmlEntitiesTablePtr table) { 
+}
+
+/**
+ * xmlDumpEntitiesTable:
+ * @buf:  An XML buffer.
+ * @table:  An entity table
+ *
+ * This will dump the content of the entity table as an XML DTD definition
+ */
+void
+xmlDumpEntitiesTable(xmlBufferPtr buf, xmlEntitiesTablePtr table) {
     xmlHashScan(table, xmlDumpEntityDeclScan, buf);
-} 
-#endif /* LIBXML_OUTPUT_ENABLED */ 
-#define bottom_entities 
-#include "elfgcchack.h" 
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+#define bottom_entities
+#include "elfgcchack.h"