entities.c

Go to the documentation of this file.

/*
 * entities.c : implementation for the XML entities handling
 *
 * See Copyright for the status of this software.
 *
 * daniel@veillard.com
 */
 
/* 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>
#include <stdlib.h>
 
#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/dict.h>
 
#include "private/entities.h"
#include "private/error.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, 0, 0
};
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, 0, 0
};
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, 0, 0
};
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, 0, 0
};
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, 0, 0
};
 
static void
xmlEntitiesErrMemory(const char *extra)
{
    __xmlSimpleError(XML_FROM_TREE, XML_ERR_NO_MEMORY, NULL, NULL, extra);
}
 
static void LIBXML_ATTR_FORMAT(2,0)
xmlEntitiesErr(xmlParserErrors code, const char *msg)
{
    __xmlSimpleError(XML_FROM_TREE, code, NULL, msg, NULL);
}
 
static void LIBXML_ATTR_FORMAT(2,0)
xmlEntitiesWarn(xmlParserErrors code, const char *msg, const xmlChar *str1)
{
    __xmlRaiseError(NULL, NULL, NULL,
                NULL, NULL, XML_FROM_TREE, code,
                XML_ERR_WARNING, NULL, 0,
                (const char *)str1, NULL, NULL, 0, 0,
                msg, (const char *)str1, NULL);
}
 
/*
 * xmlFreeEntity : clean-up an entity record.
 */
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 ((entity->name != NULL) &&
        ((dict == NULL) || (!xmlDictOwns(dict, entity->name))))
        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;
 
    /*
     * 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);
    ret->ExternalID = xmlStrdup(ExternalID);
    ret->SystemID = xmlStrdup(SystemID);
    }
    if (content != NULL) {
        ret->length = xmlStrlen(content);
    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, predef;
 
    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:
            predef = xmlGetPredefinedEntity(name);
            if (predef != NULL) {
                int valid = 0;
 
                /* 4.6 Predefined Entities */
                if ((type == XML_INTERNAL_GENERAL_ENTITY) &&
                    (content != NULL)) {
                    int c = predef->content[0];
 
                    if (((content[0] == c) && (content[1] == 0)) &&
                        ((c == '>') || (c == '\'') || (c == '"'))) {
                        valid = 1;
                    } else if ((content[0] == '&') && (content[1] == '#')) {
                        if (content[2] == 'x') {
                            xmlChar *hex = BAD_CAST "0123456789ABCDEF";
                            xmlChar ref[] = "00;";
 
                            ref[0] = hex[c / 16 % 16];
                            ref[1] = hex[c % 16];
                            if (xmlStrcasecmp(&content[3], ref) == 0)
                                valid = 1;
                        } else {
                            xmlChar ref[] = "00;";
 
                            ref[0] = '0' + c / 10 % 10;
                            ref[1] = '0' + c % 10;
                            if (xmlStrEqual(&content[2], ref))
                                valid = 1;
                        }
                    }
                }
                if (!valid) {
                    xmlEntitiesWarn(XML_ERR_ENTITY_PROCESSING,
                            "xmlAddEntity: invalid redeclaration of predefined"
                            " entity '%s'", name);
                    return(NULL);
                }
            }
        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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
static xmlEntityPtr
xmlGetEntityFromTable(xmlEntitiesTablePtr table, const xmlChar *name) {
    return((xmlEntityPtr) xmlHashLookup(table, name));
}
 
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);
}
 
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);
}
 
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;                     \
}
 
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);
    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 <br@sseusa.com> 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.
         * It must match either:
         *   110xxxxx 10xxxxxx
         *   1110xxxx 10xxxxxx 10xxxxxx
         *   11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
         * That is:
         *   cur[0] is 11xxxxxx
         *   cur[1] is 10xxxxxx
         *   cur[2] is 10xxxxxx if cur[0] is 111xxxxx
         *   cur[3] is 10xxxxxx if cur[0] is 1111xxxx
         *   cur[0] is not 11111xxx
         */
        char buf[11], *ptr;
        int val = 0, l = 1;
 
        if (((cur[0] & 0xC0) != 0xC0) ||
            ((cur[1] & 0xC0) != 0x80) ||
            (((cur[0] & 0xE0) == 0xE0) && ((cur[2] & 0xC0) != 0x80)) ||
            (((cur[0] & 0xF0) == 0xF0) && ((cur[3] & 0xC0) != 0x80)) ||
            (((cur[0] & 0xF8) == 0xF8))) {
            xmlEntitiesErr(XML_CHECK_NOT_UTF8,
                "xmlEncodeEntities: input not UTF-8");
            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");
            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);
}
 
xmlChar *
xmlEncodeAttributeEntities(xmlDocPtr doc, const xmlChar *input) {
    return xmlEncodeEntitiesInternal(doc, input, 1);
}
 
xmlChar *
xmlEncodeEntitiesReentrant(xmlDocPtr doc, const xmlChar *input) {
    return xmlEncodeEntitiesInternal(doc, input, 0);
}
 
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);
    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);
}
 
xmlEntitiesTablePtr
xmlCreateEntitiesTable(void) {
    return((xmlEntitiesTablePtr) xmlHashCreate(0));
}
 
static void
xmlFreeEntityWrapper(void *entity, const xmlChar *name ATTRIBUTE_UNUSED) {
    if (entity != NULL)
    xmlFreeEntity((xmlEntityPtr) entity);
}
 
void
xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
    xmlHashFree(table, xmlFreeEntityWrapper);
}
 
#ifdef LIBXML_TREE_ENABLED
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);
}
 
xmlEntitiesTablePtr
xmlCopyEntitiesTable(xmlEntitiesTablePtr table) {
    return(xmlHashCopy(table, xmlCopyEntity));
}
#endif /* LIBXML_TREE_ENABLED */
 
#ifdef LIBXML_OUTPUT_ENABLED
 
static void
xmlDumpEntityContent(xmlBufferPtr buf, const xmlChar *content) {
    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);
    }
}
 
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");
    }
}
 
static void
xmlDumpEntityDeclScan(void *ent, void *buf,
                      const xmlChar *name ATTRIBUTE_UNUSED) {
    xmlDumpEntityDecl((xmlBufferPtr) buf, (xmlEntityPtr) ent);
}
 
void
xmlDumpEntitiesTable(xmlBufferPtr buf, xmlEntitiesTablePtr table) {
    xmlHashScan(table, xmlDumpEntityDeclScan, buf);
}
#endif /* LIBXML_OUTPUT_ENABLED */