shaba/libxml2
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/libxml2.git synced 2025-01-27 14:03:36 +03:00
Code
libxml2/entities.c
Daniel Veillard 8b5dd83f46 - configure.in: releasing 2.2.4 
- parser.[ch]: added xmlStrEqual()
- HTMLparser.c HTMLtree.c SAX.c debugXML.c entities.c parser.c
  tree.c valid.c xlink.c xpath.c: converted all !xmlStrcmp to
  use xmlStrEqual instead
- TODO: updated
- added an XPath test
Daniel
2000-10-01 20:28:44 +00:00

1393 lines
35 KiB
C
Raw Blame History

/*
* entities.c : implementation for the XML entities handking
*
* See Copyright for the status of this software.
*
* Daniel.Veillard@w3.org
*/
#ifdef WIN32
#include "win32config.h"
#else
#include "config.h"
#endif
#include <stdio.h>
#include <string.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#include <libxml/xmlmemory.h>
#include <libxml/entities.h>
#include <libxml/parser.h>
#define DEBUG_ENT_REF /* debugging of cross entities dependancies */
#define ENTITY_HASH_SIZE 256 /* modify xmlEntityComputeHash accordingly */
/*
* xmlEntityComputeHash:
*
* Computes the hash value for this given entity
*/
int
xmlEntityComputeHash(const xmlChar *name) {
register const unsigned char *cur = (const unsigned char *) name;
register unsigned char val = 0;
if (name == NULL)
return(val);
while (*cur) val += *cur++;
return(val);
}
/*
* The XML predefined entities.
*/
struct xmlPredefinedEntityValue {
const char *name;
const char *value;
};
struct xmlPredefinedEntityValue xmlPredefinedEntityValues[] = {
{ "lt", "<" },
{ "gt", ">" },
{ "apos", "'" },
{ "quot", "\"" },
{ "amp", "&" }
};
/*
* TODO: !!!!!!! This is GROSS, allocation of a 256 entry hash for
* a fixed number of 4 elements !
*/
xmlEntitiesTablePtr xmlPredefinedEntities = NULL;
/*
* xmlFreeEntity : clean-up an entity record.
*/
void xmlFreeEntity(xmlEntityPtr entity) {
if (entity == NULL) return;
if (entity->children)
xmlFreeNodeList(entity->children);
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);
#ifdef WITH_EXTRA_ENT_DETECT
if (entity->entTab != NULL) {
int i;
for (i = 0; i < entity->entNr; i++)
xmlFree(entity->entTab[i]);
xmlFree(entity->entTab);
}
#endif
memset(entity, -1, sizeof(xmlEntity));
xmlFree(entity);
}
/*
* xmlAddEntity : register a new entity for an entities table.
*/
static xmlEntityPtr
xmlAddEntity(xmlEntitiesTablePtr table, const xmlChar *name, int type,
const xmlChar *ExternalID, const xmlChar *SystemID,
const xmlChar *content) {
#ifndef ENTITY_HASH_SIZE
int i;
#endif
int hash;
xmlEntityPtr ret;
if (name == NULL)
return(NULL);
#ifdef ENTITY_HASH_SIZE
hash = xmlEntityComputeHash(name);
ret = table->table[hash];
while (ret != NULL) {
if (xmlStrEqual(ret->name, name)) {
/*
* The entity is already defined in this Dtd, the spec says to NOT
* override it ... Is it worth a Warning ??? !!!
* Not having a cprinting context this seems hard ...
*/
if (((type == XML_INTERNAL_PARAMETER_ENTITY) ||
(type == XML_EXTERNAL_PARAMETER_ENTITY)) &&
((ret->etype == XML_INTERNAL_PARAMETER_ENTITY) ||
(ret->etype == XML_EXTERNAL_PARAMETER_ENTITY)))
return(NULL);
else
if (((type != XML_INTERNAL_PARAMETER_ENTITY) &&
(type != XML_EXTERNAL_PARAMETER_ENTITY)) &&
((ret->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
(ret->etype != XML_EXTERNAL_PARAMETER_ENTITY)))
return(NULL);
}
ret = ret->nexte;
}
#else
for (i = 0;i < table->nb_entities;i++) {
ret = table->table[i];
if (xmlStrEqual(ret->name, name)) {
/*
* The entity is already defined in this Dtd, the spec says to NOT
* override it ... Is it worth a Warning ??? !!!
* Not having a cprinting context this seems hard ...
*/
if (((type == XML_INTERNAL_PARAMETER_ENTITY) ||
(type == XML_EXTERNAL_PARAMETER_ENTITY)) &&
((ret->etype == XML_INTERNAL_PARAMETER_ENTITY) ||
(ret->etype == XML_EXTERNAL_PARAMETER_ENTITY)))
return(NULL);
else
if (((type != XML_INTERNAL_PARAMETER_ENTITY) &&
(type != XML_EXTERNAL_PARAMETER_ENTITY)) &&
((ret->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
(ret->etype != XML_EXTERNAL_PARAMETER_ENTITY)))
return(NULL);
}
}
if (table->nb_entities >= table->max_entities) {
/*
* need more elements.
*/
table->max_entities *= 2;
table->table = (xmlEntityPtr *)
xmlRealloc(table->table,
table->max_entities * sizeof(xmlEntityPtr));
if (table->table == NULL) {
perror("realloc failed");
return(NULL);
}
}
#endif
ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
if (ret == NULL) {
fprintf(stderr, "xmlAddEntity: out of memory\n");
return(NULL);
}
memset(ret, 0, sizeof(xmlEntity));
ret->type = XML_ENTITY_DECL;
#ifdef ENTITY_HASH_SIZE
ret->nexte = table->table[hash];
table->table[hash] = ret;
#else
table->table[table->nb_entities] = ret;
#endif
/*
* fill the structure.
*/
ret->name = xmlStrdup(name);
ret->etype = (xmlEntityType) type;
if (ExternalID != NULL)
ret->ExternalID = xmlStrdup(ExternalID);
if (SystemID != NULL)
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;
table->nb_entities++;
return(ret);
}
/**
* xmlInitializePredefinedEntities:
*
* Set up the predefined entities.
*/
void xmlInitializePredefinedEntities(void) {
int i;
xmlChar name[50];
xmlChar value[50];
const char *in;
xmlChar *out;
if (xmlPredefinedEntities != NULL) return;
xmlPredefinedEntities = xmlCreateEntitiesTable();
for (i = 0;i < sizeof(xmlPredefinedEntityValues) /
sizeof(xmlPredefinedEntityValues[0]);i++) {
in = xmlPredefinedEntityValues[i].name;
out = &name[0];
for (;(*out++ = (xmlChar) *in);)in++;
in = xmlPredefinedEntityValues[i].value;
out = &value[0];
for (;(*out++ = (xmlChar) *in);)in++;
xmlAddEntity(xmlPredefinedEntities, (const xmlChar *) &name[0],
XML_INTERNAL_PREDEFINED_ENTITY, NULL, NULL,
&value[0]);
}
}
/**
* xmlCleanupPredefinedEntities:
*
* Cleanup up the predefined entities table.
*/
void xmlCleanupPredefinedEntities(void) {
if (xmlPredefinedEntities == NULL) return;
xmlFreeEntitiesTable(xmlPredefinedEntities);
xmlPredefinedEntities = NULL;
}
/**
* xmlGetPredefinedEntity:
* @name: the entity name
*
* Check whether this name is an predefined entity.
*
* Returns NULL if not, othervise the entity
*/
xmlEntityPtr
xmlGetPredefinedEntity(const xmlChar *name) {
int i;
xmlEntityPtr cur;
if (xmlPredefinedEntities == NULL)
xmlInitializePredefinedEntities();
#ifdef ENTITY_HASH_SIZE
i = xmlEntityComputeHash(name);
cur = xmlPredefinedEntities->table[i];
while (cur != NULL) {
if (xmlStrEqual(cur->name, name))
return(cur);
cur = cur->nexte;
}
#else
for (i = 0;i < xmlPredefinedEntities->nb_entities;i++) {
cur = xmlPredefinedEntities->table[i];
if (xmlStrEqual(cur->name, name)) return(cur);
}
#endif
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) {
xmlEntitiesTablePtr table;
xmlEntityPtr ret;
xmlDtdPtr dtd;
if (doc == NULL) {
fprintf(stderr,
"xmlAddDtdEntity: doc == NULL !\n");
return(NULL);
}
if (doc->extSubset == NULL) {
fprintf(stderr,
"xmlAddDtdEntity: document without external subset !\n");
return(NULL);
}
dtd = doc->extSubset;
table = (xmlEntitiesTablePtr) dtd->entities;
if (table == NULL) {
table = xmlCreateEntitiesTable();
dtd->entities = table;
}
ret = xmlAddEntity(table, 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) {
xmlEntitiesTablePtr table;
xmlEntityPtr ret;
xmlDtdPtr dtd;
if (doc == NULL) {
fprintf(stderr,
"xmlAddDocEntity: document is NULL !\n");
return(NULL);
}
if (doc->intSubset == NULL) {
fprintf(stderr,
"xmlAddDtdEntity: document without internal subset !\n");
return(NULL);
}
dtd = doc->intSubset;
table = (xmlEntitiesTablePtr) doc->intSubset->entities;
if (table == NULL) {
table = xmlCreateEntitiesTable();
doc->intSubset->entities = table;
}
ret = xmlAddEntity(table, 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);
}
#ifdef WITH_EXTRA_ENT_DETECT
/**
* xmlEntityCheckReference:
* @ent: an existing entity
* @to: the entity name it's referencing
*
* Function to keep track of references and detect cycles (well formedness
* errors !).
*
* Returns: 0 if Okay, -1 in case of general error, 1 in case of loop
* detection.
*/
int
xmlEntityCheckReference(xmlEntityPtr ent, const xmlChar *to) {
int i;
xmlDocPtr doc;
if (ent == NULL) return(-1);
if (to == NULL) return(-1);
doc = ent->doc;
if (doc == NULL) return(-1);
#ifdef DEBUG_ENT_REF
printf("xmlEntityCheckReference(%s to %s)\n", ent->name, to);
#endif
/*
* Do a recursive checking
*/
for (i = 0;i < ent->entNr;i++) {
xmlEntityPtr indir = NULL;
if (xmlStrEqual(to, ent->entTab[i]))
return(1);
switch (ent->etype) {
case XML_INTERNAL_GENERAL_ENTITY:
case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
indir = xmlGetDocEntity(doc, ent->entTab[i]);
break;
case XML_INTERNAL_PARAMETER_ENTITY:
case XML_EXTERNAL_PARAMETER_ENTITY:
indir = xmlGetDtdEntity(doc, ent->entTab[i]);
break;
case XML_INTERNAL_PREDEFINED_ENTITY:
case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
break;
}
if (xmlEntityCheckReference(indir, to) == 1)
return(1);
}
return(0);
}
/**
* xmlEntityAddReference:
* @ent: an existing entity
* @to: the entity name it's referencing
*
* Function to register reuse of an existing entity from a (new) one
* Used to keep track of references and detect cycles (well formedness
* errors !).
*
* Returns: 0 if Okay, -1 in case of general error, 1 in case of loop
* detection.
*/
int
xmlEntityAddReference(xmlEntityPtr ent, const xmlChar *to) {
int i;
xmlDocPtr doc;
xmlEntityPtr indir = NULL;
if (ent == NULL) return(-1);
if (to == NULL) return(-1);
doc = ent->doc;
if (doc == NULL) return(-1);
#ifdef DEBUG_ENT_REF
printf("xmlEntityAddReference(%s to %s)\n", ent->name, to);
#endif
if (ent->entTab == NULL) {
ent->entNr = 0;
ent->entMax = 5;
ent->entTab = (xmlChar **) xmlMalloc(ent->entMax * sizeof(xmlChar *));
if (ent->entTab == NULL) {
fprintf(stderr, "xmlEntityAddReference: out of memory !\n");
return(-1);
}
}
for (i = 0;i < ent->entNr;i++) {
if (xmlStrEqual(to, ent->entTab[i]))
return(0);
}
/*
* Do a recursive checking
*/
switch (ent->etype) {
case XML_INTERNAL_GENERAL_ENTITY:
case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
indir = xmlGetDocEntity(doc, to);
break;
case XML_INTERNAL_PARAMETER_ENTITY:
case XML_EXTERNAL_PARAMETER_ENTITY:
indir = xmlGetDtdEntity(doc, to);
break;
case XML_INTERNAL_PREDEFINED_ENTITY:
case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
break;
}
if ((indir != NULL) &&
(xmlEntityCheckReference(indir, ent->name) == 1))
return(1);
/*
* Add this to the list
*/
if (ent->entMax <= ent->entNr) {
ent->entMax *= 2;
ent->entTab = (xmlChar **) xmlRealloc(ent->entTab,
ent->entMax * sizeof(xmlChar *));
if (ent->entTab == NULL) {
fprintf(stderr, "xmlEntityAddReference: out of memory !\n");
return(-1);
}
}
ent->entTab[ent->entNr++] = xmlStrdup(to);
return(0);
}
#endif
/**
* 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.
*/
xmlEntityPtr
xmlGetEntityFromTable(xmlEntitiesTablePtr table, const xmlChar *name,
int parameter) {
xmlEntityPtr cur;
#ifdef ENTITY_HASH_SIZE
int hash;
hash = xmlEntityComputeHash(name);
cur = table->table[hash];
while (cur != NULL) {
switch (cur->etype) {
case XML_INTERNAL_PARAMETER_ENTITY:
case XML_EXTERNAL_PARAMETER_ENTITY:
if ((parameter) && (xmlStrEqual(cur->name, name)))
return(cur);
default:
if ((!parameter) && (xmlStrEqual(cur->name, name)))
return(cur);
}
cur = cur->nexte;
}
#else
int i;
for (i = 0;i < table->nb_entities;i++) {
cur = table->table[i];
switch (cur->etype) {
case XML_INTERNAL_PARAMETER_ENTITY:
case XML_EXTERNAL_PARAMETER_ENTITY:
if ((parameter) && (xmlStrEqual(cur->name, name)))
return(cur);
default:
if ((!parameter) && (xmlStrEqual(cur->name, name)))
return(cur);
}
}
#endif
return(NULL);
}
/**
* 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->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
table = (xmlEntitiesTablePtr) doc->intSubset->entities;
ret = xmlGetEntityFromTable(table, name, 1);
if (ret != NULL)
return(ret);
}
if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
table = (xmlEntitiesTablePtr) doc->extSubset->entities;
return(xmlGetEntityFromTable(table, name, 1));
}
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.
*
* Returns A pointer to the entity structure or NULL if not found.
*/
xmlEntityPtr
xmlGetDtdEntity(xmlDocPtr doc, const xmlChar *name) {
xmlEntitiesTablePtr table;
if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
table = (xmlEntitiesTablePtr) doc->extSubset->entities;
return(xmlGetEntityFromTable(table, name, 0));
}
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 corrsponding 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(xmlDocPtr 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, 0);
if (cur != NULL)
return(cur);
}
if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
table = (xmlEntitiesTablePtr) doc->extSubset->entities;
cur = xmlGetEntityFromTable(table, name, 0);
if (cur != NULL)
return(cur);
}
}
if (xmlPredefinedEntities == NULL)
xmlInitializePredefinedEntities();
table = xmlPredefinedEntities;
return(xmlGetEntityFromTable(table, name, 0));
}
/*
* [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
* | [#x10000-#x10FFFF]
* any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.
*/
#define IS_CHAR(c) \
(((c) == 0x09) || ((c) == 0x0a) || ((c) == 0x0d) || \
(((c) >= 0x20) && ((c) != 0xFFFE) && ((c) != 0xFFFF)))
/*
* A buffer used for converting entities to their equivalent and back.
*/
static int buffer_size = 0;
static xmlChar *buffer = NULL;
int growBuffer(void) {
buffer_size *= 2;
buffer = (xmlChar *) xmlRealloc(buffer, buffer_size * sizeof(xmlChar));
if (buffer == NULL) {
perror("realloc failed");
return(-1);
}
return(0);
}
/**
* xmlEncodeEntities:
* @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.
*
* TODO: remove xmlEncodeEntities, once we are not afraid of breaking binary
* compatibility
*
* People must migrate their code to xmlEncodeEntitiesReentrant !
* This routine will issue a warning when encountered.
*
* Returns A newly allocated string with the substitution done.
*/
const xmlChar *
xmlEncodeEntities(xmlDocPtr doc, const xmlChar *input) {
const xmlChar *cur = input;
xmlChar *out = buffer;
static int warning = 1;
int html = 0;
if (warning) {
fprintf(stderr, "Deprecated API xmlEncodeEntities() used\n");
fprintf(stderr, " change code to use xmlEncodeEntitiesReentrant()\n");
warning = 0;
}
if (input == NULL) return(NULL);
if (doc != NULL)
html = (doc->type == XML_HTML_DOCUMENT_NODE);
if (buffer == NULL) {
buffer_size = 1000;
buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
if (buffer == NULL) {
perror("malloc failed");
return(NULL);
}
out = buffer;
}
while (*cur != '\0') {
if (out - buffer > buffer_size - 100) {
int index = out - buffer;
growBuffer();
out = &buffer[index];
}
/*
* 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 == '\'') && (!html)) {
*out++ = '&';
*out++ = 'a';
*out++ = 'p';
*out++ = 'o';
*out++ = 's';
*out++ = ';';
} else if (((*cur >= 0x20) && (*cur < 0x80)) ||
(*cur == '\n') || (*cur == '\r') || (*cur == '\t')) {
/*
* default case, just copy !
*/
*out++ = *cur;
#ifndef USE_UTF_8
} else if ((sizeof(xmlChar) == 1) && (*cur >= 0x80)) {
char buf[10], *ptr;
#ifdef HAVE_SNPRINTF
snprintf(buf, sizeof(buf), "&#%d;", *cur);
#else
sprintf(buf, "&#%d;", *cur);
#endif
buf[sizeof(buf) - 1] = 0;
ptr = buf;
while (*ptr != 0) *out++ = *ptr++;
#endif
} else if (IS_CHAR(*cur)) {
char buf[10], *ptr;
#ifdef HAVE_SNPRINTF
snprintf(buf, sizeof(buf), "&#%d;", *cur);
#else
sprintf(buf, "&#%d;", *cur);
#endif
buf[sizeof(buf) - 1] = 0;
ptr = buf;
while (*ptr != 0) *out++ = *ptr++;
}
#if 0
else {
/*
* default case, this is not a valid char !
* Skip it...
*/
fprintf(stderr, "xmlEncodeEntities: invalid char %d\n", (int) *cur);
}
#endif
cur++;
}
*out++ = 0;
return(buffer);
}
/*
* Macro used to grow the current buffer.
*/
#define growBufferReentrant() { \
buffer_size *= 2; \
buffer = (xmlChar *) \
xmlRealloc(buffer, buffer_size * sizeof(xmlChar)); \
if (buffer == NULL) { \
perror("realloc failed"); \
return(NULL); \
} \
}
/**
* 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) {
const xmlChar *cur = input;
xmlChar *buffer = NULL;
xmlChar *out = NULL;
int 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) {
perror("malloc failed");
return(NULL);
}
out = buffer;
while (*cur != '\0') {
if (out - buffer > buffer_size - 100) {
int index = out - buffer;
growBufferReentrant();
out = &buffer[index];
}
/*
* 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++ = ';';
#if 0
} else if ((*cur == '\'') && (!html)) {
*out++ = '&';
*out++ = 'a';
*out++ = 'p';
*out++ = 'o';
*out++ = 's';
*out++ = ';';
#endif
} else if (((*cur >= 0x20) && (*cur < 0x80)) ||
(*cur == '\n') || (*cur == '\r') || (*cur == '\t')) {
/*
* default case, just copy !
*/
*out++ = *cur;
} else if (*cur >= 0x80) {
if ((doc->encoding != NULL) || (html)) {
/*
* Bj<42>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.
*/
char buf[10], *ptr;
int val = 0, l = 1;
if (*cur < 0xC0) {
fprintf(stderr,
"xmlEncodeEntitiesReentrant : input not UTF-8\n");
doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
#ifdef HAVE_SNPRINTF
snprintf(buf, sizeof(buf), "&#%d;", *cur);
#else
sprintf(buf, "&#%d;", *cur);
#endif
buf[sizeof(buf) - 1] = 0;
ptr = buf;
while (*ptr != 0) *out++ = *ptr++;
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))) {
fprintf(stderr,
"xmlEncodeEntitiesReentrant : char out of range\n");
doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
#ifdef HAVE_SNPRINTF
snprintf(buf, sizeof(buf), "&#%d;", *cur);
#else
sprintf(buf, "&#%d;", *cur);
#endif
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
*/
#ifdef HAVE_SNPRINTF
snprintf(buf, sizeof(buf), "&#x%X;", val);
#else
sprintf(buf, "&#x%X;", val);
#endif
buf[sizeof(buf) - 1] = 0;
ptr = buf;
while (*ptr != 0) *out++ = *ptr++;
cur += l;
continue;
}
} else if (IS_CHAR(*cur)) {
char buf[10], *ptr;
#ifdef HAVE_SNPRINTF
snprintf(buf, sizeof(buf), "&#%d;", *cur);
#else
sprintf(buf, "&#%d;", *cur);
#endif
buf[sizeof(buf) - 1] = 0;
ptr = buf;
while (*ptr != 0) *out++ = *ptr++;
}
#if 0
else {
/*
* default case, this is not a valid char !
* Skip it...
*/
fprintf(stderr, "xmlEncodeEntities: invalid char %d\n", (int) *cur);
}
#endif
cur++;
}
*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.
*
* Returns A newly allocated string with the substitution done.
*/
xmlChar *
xmlEncodeSpecialChars(xmlDocPtr doc, const xmlChar *input) {
const xmlChar *cur = input;
xmlChar *buffer = NULL;
xmlChar *out = NULL;
int 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) {
perror("malloc failed");
return(NULL);
}
out = buffer;
while (*cur != '\0') {
if (out - buffer > buffer_size - 10) {
int index = out - buffer;
growBufferReentrant();
out = &buffer[index];
}
/*
* 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 {
/*
* Works because on UTF-8, all extended sequences cannot
* result in bytes in the ASCII range.
*/
*out++ = *cur;
}
cur++;
}
*out++ = 0;
return(buffer);
}
/**
* xmlCreateEntitiesTable:
*
* create and initialize an empty entities hash table.
*
* Returns the xmlEntitiesTablePtr just created or NULL in case of error.
*/
xmlEntitiesTablePtr
xmlCreateEntitiesTable(void) {
xmlEntitiesTablePtr ret;
ret = (xmlEntitiesTablePtr)
xmlMalloc(sizeof(xmlEntitiesTable));
if (ret == NULL) {
fprintf(stderr, "xmlCreateEntitiesTable : xmlMalloc(%ld) failed\n",
(long)sizeof(xmlEntitiesTable));
return(NULL);
}
ret->nb_entities = 0;
#ifdef ENTITY_HASH_SIZE
ret->max_entities = ENTITY_HASH_SIZE;
ret->table = (xmlEntityPtr *)
xmlMalloc(ret->max_entities * sizeof(xmlEntityPtr));
if (ret == NULL) {
fprintf(stderr, "xmlCreateEntitiesTable : xmlMalloc(%ld) failed\n",
ret->max_entities * (long)sizeof(xmlEntityPtr));
xmlFree(ret);
return(NULL);
}
memset(ret->table, 0, ret->max_entities * sizeof(xmlEntityPtr));
#else
ret->max_entities = XML_MIN_ENTITIES_TABLE;
ret->table = (xmlEntityPtr *)
xmlMalloc(ret->max_entities * sizeof(xmlEntityPtr));
if (ret == NULL) {
fprintf(stderr, "xmlCreateEntitiesTable : xmlMalloc(%ld) failed\n",
ret->max_entities * (long)sizeof(xmlEntityPtr));
xmlFree(ret);
return(NULL);
}
#endif
return(ret);
}
/**
* xmlFreeEntitiesTable:
* @table: An entity table
*
* Deallocate the memory used by an entities hash table.
*/
void
xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
int i;
#ifdef ENTITY_HASH_SIZE
xmlEntityPtr cur, next;
#endif
if (table == NULL) return;
#ifdef ENTITY_HASH_SIZE
for (i = 0;i < ENTITY_HASH_SIZE;i++) {
cur = table->table[i];
while (cur != NULL) {
next = cur->nexte;
xmlFreeEntity(cur);
cur = next;
}
}
#else
for (i = 0;i < table->nb_entities;i++) {
xmlFreeEntity(table->table[i]);
}
#endif
xmlFree(table->table);
xmlFree(table);
}
/**
* xmlCopyEntity:
* @ent: An entity
*
* Build a copy of an entity
*
* Returns the new xmlEntitiesPtr or NULL in case of error.
*/
xmlEntityPtr
xmlCopyEntity(xmlEntityPtr ent) {
xmlEntityPtr cur;
cur = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
if (cur == NULL) {
fprintf(stderr, "xmlCopyEntity: out of memory !\n");
return(NULL);
}
memset(cur, 0, sizeof(xmlEntity));
cur->type = XML_ELEMENT_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);
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) {
xmlEntitiesTablePtr ret;
xmlEntityPtr cur, ent;
int i;
ret = (xmlEntitiesTablePtr) xmlMalloc(sizeof(xmlEntitiesTable));
if (ret == NULL) {
fprintf(stderr, "xmlCopyEntitiesTable: out of memory !\n");
return(NULL);
}
#ifdef ENTITY_HASH_SIZE
ret->table = (xmlEntityPtr *) xmlMalloc(ENTITY_HASH_SIZE *
sizeof(xmlEntityPtr));
if (ret->table == NULL) {
fprintf(stderr, "xmlCopyEntitiesTable: out of memory !\n");
xmlFree(ret);
return(NULL);
}
#else
ret->table = (xmlEntityPtr *) xmlMalloc(table->max_entities *
sizeof(xmlEntityPtr));
if (ret->table == NULL) {
fprintf(stderr, "xmlCopyEntitiesTable: out of memory !\n");
xmlFree(ret);
return(NULL);
}
#endif
ret->max_entities = table->max_entities;
ret->nb_entities = table->nb_entities;
for (i = 0;i < ret->nb_entities;i++) {
ent = table->table[i];
if (ent == NULL)
cur = NULL;
else
cur = xmlCopyEntity(ent);
ret->table[i] = cur;
#ifdef ENTITY_HASH_SIZE
ent = ent->nexte;
while ((ent != NULL) && (cur != NULL)) {
cur->nexte = xmlCopyEntity(ent);
cur = cur->nexte;
}
#endif
}
return(ret);
}
/**
* 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) {
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
xmlBufferWriteQuotedString(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)
xmlBufferWriteQuotedString(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:
fprintf(stderr,
"xmlDumpEntitiesTable: internal: unknown type %d\n",
ent->etype);
}
}
/**
* 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) {
int i;
xmlEntityPtr cur;
if (table == NULL) return;
#ifdef ENTITY_HASH_SIZE
for (i = 0;i < ENTITY_HASH_SIZE;i++) {
cur = table->table[i];
while (cur != NULL) {
xmlDumpEntityDecl(buf, cur);
cur = cur->nexte;
}
}
#else
for (i = 0;i < table->nb_entities;i++) {
cur = table->table[i];
xmlDumpEntityDecl(buf, cur);
}
#endif
}
View Git Blame Copy Permalink