Update libxml to 2.7.7.

third_party/libxml/entities.c

 /*
  * entities.c : implementation for the XML entities handling
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
 
 #define IN_LIBXML
 #include "libxml.h"
@@ skipping 121 matching lines @@
             xmlFree((char *) entity->URI);
         if (entity->content != NULL)
             xmlFree((char *) entity->content);
         if (entity->orig != NULL)
             xmlFree((char *) entity->orig);
     }
     xmlFree(entity);
 }
 
 /*
- * xmlAddEntity : register a new entity for an entities table.
+ * xmlCreateEntity:
+ *
+ * internal routine doing the entity node strutures allocations
  */
 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;
+xmlCreateEntity(xmlDictPtr dict, const xmlChar *name, int type,
+                const xmlChar *ExternalID, const xmlChar *SystemID,
+                const xmlChar *content) {
     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 = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
     if (ret == NULL) {
-        xmlEntitiesErrMemory("xmlAddEntity:: malloc failed");
+        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;
@@ skipping 18 matching lines @@
         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);
@@ skipping 127 matching lines @@
         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 responsability
+ * 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.
  */
@@ skipping 251 matching lines @@
         } 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;
+    *out = 0;
     return(buffer);
 }
 
 /**
  * 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.
@@ skipping 61 matching lines @@
             *out++ = ';';
         } else {
             /*
              * Works because on UTF-8, all extended sequences cannot
              * result in bytes in the ASCII range.
              */
             *out++ = *cur;
         }
         cur++;
     }
-    *out++ = 0;
+    *out = 0;
     return(buffer);
 }
 
 /**
  * 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.
@@ skipping 227 matching lines @@
  *
  * This will dump the content of the entity table as an XML DTD definition
  */
 void
 xmlDumpEntitiesTable(xmlBufferPtr buf, xmlEntitiesTablePtr table) {
     xmlHashScan(table, (xmlHashScanner)xmlDumpEntityDeclScan, buf);
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 #define bottom_entities
 #include "elfgcchack.h"