Home | History | Annotate | Download | only in libxml2 
      1 /*
      2  * entities.c : implementation for the XML entities handling
      3  *
      4  * See Copyright for the status of this software.
      5  *
      6  * daniel (at) veillard.com
      7  */
      8 
      9 #define IN_LIBXML
     10 #include "libxml.h"
     11 
     12 #include <string.h>
     13 #ifdef HAVE_STDLIB_H
     14 #include <stdlib.h>
     15 #endif
     16 #include <libxml/xmlmemory.h>
     17 #include <libxml/hash.h>
     18 #include <libxml/entities.h>
     19 #include <libxml/parser.h>
     20 #include <libxml/parserInternals.h>
     21 #include <libxml/xmlerror.h>
     22 #include <libxml/globals.h>
     23 #include <libxml/dict.h>
     24 
     25 #include "save.h"
     26 
     27 /*
     28  * The XML predefined entities.
     29  */
     30 
     31 static xmlEntity xmlEntityLt = {
     32     NULL, XML_ENTITY_DECL, BAD_CAST "lt",
     33     NULL, NULL, NULL, NULL, NULL, NULL,
     34     BAD_CAST "<", BAD_CAST "<", 1,
     35     XML_INTERNAL_PREDEFINED_ENTITY,
     36     NULL, NULL, NULL, NULL, 0, 1
     37 };
     38 static xmlEntity xmlEntityGt = {
     39     NULL, XML_ENTITY_DECL, BAD_CAST "gt",
     40     NULL, NULL, NULL, NULL, NULL, NULL,
     41     BAD_CAST ">", BAD_CAST ">", 1,
     42     XML_INTERNAL_PREDEFINED_ENTITY,
     43     NULL, NULL, NULL, NULL, 0, 1
     44 };
     45 static xmlEntity xmlEntityAmp = {
     46     NULL, XML_ENTITY_DECL, BAD_CAST "amp",
     47     NULL, NULL, NULL, NULL, NULL, NULL,
     48     BAD_CAST "&", BAD_CAST "&", 1,
     49     XML_INTERNAL_PREDEFINED_ENTITY,
     50     NULL, NULL, NULL, NULL, 0, 1
     51 };
     52 static xmlEntity xmlEntityQuot = {
     53     NULL, XML_ENTITY_DECL, BAD_CAST "quot",
     54     NULL, NULL, NULL, NULL, NULL, NULL,
     55     BAD_CAST "\"", BAD_CAST "\"", 1,
     56     XML_INTERNAL_PREDEFINED_ENTITY,
     57     NULL, NULL, NULL, NULL, 0, 1
     58 };
     59 static xmlEntity xmlEntityApos = {
     60     NULL, XML_ENTITY_DECL, BAD_CAST "apos",
     61     NULL, NULL, NULL, NULL, NULL, NULL,
     62     BAD_CAST "'", BAD_CAST "'", 1,
     63     XML_INTERNAL_PREDEFINED_ENTITY,
     64     NULL, NULL, NULL, NULL, 0, 1
     65 };
     66 
     67 /**
     68  * xmlEntitiesErrMemory:
     69  * @extra:  extra informations
     70  *
     71  * Handle an out of memory condition
     72  */
     73 static void
     74 xmlEntitiesErrMemory(const char *extra)
     75 {
     76     __xmlSimpleError(XML_FROM_TREE, XML_ERR_NO_MEMORY, NULL, NULL, extra);
     77 }
     78 
     79 /**
     80  * xmlEntitiesErr:
     81  * @code:  the error code
     82  * @msg:  the message
     83  *
     84  * Handle an out of memory condition
     85  */
     86 static void LIBXML_ATTR_FORMAT(2,0)
     87 xmlEntitiesErr(xmlParserErrors code, const char *msg)
     88 {
     89     __xmlSimpleError(XML_FROM_TREE, code, NULL, msg, NULL);
     90 }
     91 
     92 /*
     93  * xmlFreeEntity : clean-up an entity record.
     94  */
     95 static void
     96 xmlFreeEntity(xmlEntityPtr entity)
     97 {
     98     xmlDictPtr dict = NULL;
     99 
    100     if (entity == NULL)
    101         return;
    102 
    103     if (entity->doc != NULL)
    104         dict = entity->doc->dict;
    105 
    106 
    107     if ((entity->children) && (entity->owner == 1) &&
    108         (entity == (xmlEntityPtr) entity->children->parent))
    109         xmlFreeNodeList(entity->children);
    110     if (dict != NULL) {
    111         if ((entity->name != NULL) && (!xmlDictOwns(dict, entity->name)))
    112             xmlFree((char *) entity->name);
    113         if ((entity->ExternalID != NULL) &&
    114 	    (!xmlDictOwns(dict, entity->ExternalID)))
    115             xmlFree((char *) entity->ExternalID);
    116         if ((entity->SystemID != NULL) &&
    117 	    (!xmlDictOwns(dict, entity->SystemID)))
    118             xmlFree((char *) entity->SystemID);
    119         if ((entity->URI != NULL) && (!xmlDictOwns(dict, entity->URI)))
    120             xmlFree((char *) entity->URI);
    121         if ((entity->content != NULL)
    122             && (!xmlDictOwns(dict, entity->content)))
    123             xmlFree((char *) entity->content);
    124         if ((entity->orig != NULL) && (!xmlDictOwns(dict, entity->orig)))
    125             xmlFree((char *) entity->orig);
    126     } else {
    127         if (entity->name != NULL)
    128             xmlFree((char *) entity->name);
    129         if (entity->ExternalID != NULL)
    130             xmlFree((char *) entity->ExternalID);
    131         if (entity->SystemID != NULL)
    132             xmlFree((char *) entity->SystemID);
    133         if (entity->URI != NULL)
    134             xmlFree((char *) entity->URI);
    135         if (entity->content != NULL)
    136             xmlFree((char *) entity->content);
    137         if (entity->orig != NULL)
    138             xmlFree((char *) entity->orig);
    139     }
    140     xmlFree(entity);
    141 }
    142 
    143 /*
    144  * xmlCreateEntity:
    145  *
    146  * internal routine doing the entity node strutures allocations
    147  */
    148 static xmlEntityPtr
    149 xmlCreateEntity(xmlDictPtr dict, const xmlChar *name, int type,
    150 	        const xmlChar *ExternalID, const xmlChar *SystemID,
    151 	        const xmlChar *content) {
    152     xmlEntityPtr ret;
    153 
    154     ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
    155     if (ret == NULL) {
    156         xmlEntitiesErrMemory("xmlCreateEntity: malloc failed");
    157 	return(NULL);
    158     }
    159     memset(ret, 0, sizeof(xmlEntity));
    160     ret->type = XML_ENTITY_DECL;
    161     ret->checked = 0;
    162 
    163     /*
    164      * fill the structure.
    165      */
    166     ret->etype = (xmlEntityType) type;
    167     if (dict == NULL) {
    168 	ret->name = xmlStrdup(name);
    169 	if (ExternalID != NULL)
    170 	    ret->ExternalID = xmlStrdup(ExternalID);
    171 	if (SystemID != NULL)
    172 	    ret->SystemID = xmlStrdup(SystemID);
    173     } else {
    174         ret->name = xmlDictLookup(dict, name, -1);
    175 	if (ExternalID != NULL)
    176 	    ret->ExternalID = xmlDictLookup(dict, ExternalID, -1);
    177 	if (SystemID != NULL)
    178 	    ret->SystemID = xmlDictLookup(dict, SystemID, -1);
    179     }
    180     if (content != NULL) {
    181         ret->length = xmlStrlen(content);
    182 	if ((dict != NULL) && (ret->length < 5))
    183 	    ret->content = (xmlChar *)
    184 	                   xmlDictLookup(dict, content, ret->length);
    185 	else
    186 	    ret->content = xmlStrndup(content, ret->length);
    187      } else {
    188         ret->length = 0;
    189         ret->content = NULL;
    190     }
    191     ret->URI = NULL; /* to be computed by the layer knowing
    192 			the defining entity */
    193     ret->orig = NULL;
    194     ret->owner = 0;
    195 
    196     return(ret);
    197 }
    198 
    199 /*
    200  * xmlAddEntity : register a new entity for an entities table.
    201  */
    202 static xmlEntityPtr
    203 xmlAddEntity(xmlDtdPtr dtd, const xmlChar *name, int type,
    204 	  const xmlChar *ExternalID, const xmlChar *SystemID,
    205 	  const xmlChar *content) {
    206     xmlDictPtr dict = NULL;
    207     xmlEntitiesTablePtr table = NULL;
    208     xmlEntityPtr ret;
    209 
    210     if (name == NULL)
    211 	return(NULL);
    212     if (dtd == NULL)
    213 	return(NULL);
    214     if (dtd->doc != NULL)
    215         dict = dtd->doc->dict;
    216 
    217     switch (type) {
    218         case XML_INTERNAL_GENERAL_ENTITY:
    219         case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
    220         case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
    221 	    if (dtd->entities == NULL)
    222 		dtd->entities = xmlHashCreateDict(0, dict);
    223 	    table = dtd->entities;
    224 	    break;
    225         case XML_INTERNAL_PARAMETER_ENTITY:
    226         case XML_EXTERNAL_PARAMETER_ENTITY:
    227 	    if (dtd->pentities == NULL)
    228 		dtd->pentities = xmlHashCreateDict(0, dict);
    229 	    table = dtd->pentities;
    230 	    break;
    231         case XML_INTERNAL_PREDEFINED_ENTITY:
    232 	    return(NULL);
    233     }
    234     if (table == NULL)
    235 	return(NULL);
    236     ret = xmlCreateEntity(dict, name, type, ExternalID, SystemID, content);
    237     if (ret == NULL)
    238         return(NULL);
    239     ret->doc = dtd->doc;
    240 
    241     if (xmlHashAddEntry(table, name, ret)) {
    242 	/*
    243 	 * entity was already defined at another level.
    244 	 */
    245         xmlFreeEntity(ret);
    246 	return(NULL);
    247     }
    248     return(ret);
    249 }
    250 
    251 /**
    252  * xmlGetPredefinedEntity:
    253  * @name:  the entity name
    254  *
    255  * Check whether this name is an predefined entity.
    256  *
    257  * Returns NULL if not, otherwise the entity
    258  */
    259 xmlEntityPtr
    260 xmlGetPredefinedEntity(const xmlChar *name) {
    261     if (name == NULL) return(NULL);
    262     switch (name[0]) {
    263         case 'l':
    264 	    if (xmlStrEqual(name, BAD_CAST "lt"))
    265 	        return(&xmlEntityLt);
    266 	    break;
    267         case 'g':
    268 	    if (xmlStrEqual(name, BAD_CAST "gt"))
    269 	        return(&xmlEntityGt);
    270 	    break;
    271         case 'a':
    272 	    if (xmlStrEqual(name, BAD_CAST "amp"))
    273 	        return(&xmlEntityAmp);
    274 	    if (xmlStrEqual(name, BAD_CAST "apos"))
    275 	        return(&xmlEntityApos);
    276 	    break;
    277         case 'q':
    278 	    if (xmlStrEqual(name, BAD_CAST "quot"))
    279 	        return(&xmlEntityQuot);
    280 	    break;
    281 	default:
    282 	    break;
    283     }
    284     return(NULL);
    285 }
    286 
    287 /**
    288  * xmlAddDtdEntity:
    289  * @doc:  the document
    290  * @name:  the entity name
    291  * @type:  the entity type XML_xxx_yyy_ENTITY
    292  * @ExternalID:  the entity external ID if available
    293  * @SystemID:  the entity system ID if available
    294  * @content:  the entity content
    295  *
    296  * Register a new entity for this document DTD external subset.
    297  *
    298  * Returns a pointer to the entity or NULL in case of error
    299  */
    300 xmlEntityPtr
    301 xmlAddDtdEntity(xmlDocPtr doc, const xmlChar *name, int type,
    302 	        const xmlChar *ExternalID, const xmlChar *SystemID,
    303 		const xmlChar *content) {
    304     xmlEntityPtr ret;
    305     xmlDtdPtr dtd;
    306 
    307     if (doc == NULL) {
    308 	xmlEntitiesErr(XML_DTD_NO_DOC,
    309 	        "xmlAddDtdEntity: document is NULL");
    310 	return(NULL);
    311     }
    312     if (doc->extSubset == NULL) {
    313 	xmlEntitiesErr(XML_DTD_NO_DTD,
    314 	        "xmlAddDtdEntity: document without external subset");
    315 	return(NULL);
    316     }
    317     dtd = doc->extSubset;
    318     ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content);
    319     if (ret == NULL) return(NULL);
    320 
    321     /*
    322      * Link it to the DTD
    323      */
    324     ret->parent = dtd;
    325     ret->doc = dtd->doc;
    326     if (dtd->last == NULL) {
    327 	dtd->children = dtd->last = (xmlNodePtr) ret;
    328     } else {
    329         dtd->last->next = (xmlNodePtr) ret;
    330 	ret->prev = dtd->last;
    331 	dtd->last = (xmlNodePtr) ret;
    332     }
    333     return(ret);
    334 }
    335 
    336 /**
    337  * xmlAddDocEntity:
    338  * @doc:  the document
    339  * @name:  the entity name
    340  * @type:  the entity type XML_xxx_yyy_ENTITY
    341  * @ExternalID:  the entity external ID if available
    342  * @SystemID:  the entity system ID if available
    343  * @content:  the entity content
    344  *
    345  * Register a new entity for this document.
    346  *
    347  * Returns a pointer to the entity or NULL in case of error
    348  */
    349 xmlEntityPtr
    350 xmlAddDocEntity(xmlDocPtr doc, const xmlChar *name, int type,
    351 	        const xmlChar *ExternalID, const xmlChar *SystemID,
    352 	        const xmlChar *content) {
    353     xmlEntityPtr ret;
    354     xmlDtdPtr dtd;
    355 
    356     if (doc == NULL) {
    357 	xmlEntitiesErr(XML_DTD_NO_DOC,
    358 	        "xmlAddDocEntity: document is NULL");
    359 	return(NULL);
    360     }
    361     if (doc->intSubset == NULL) {
    362 	xmlEntitiesErr(XML_DTD_NO_DTD,
    363 	        "xmlAddDocEntity: document without internal subset");
    364 	return(NULL);
    365     }
    366     dtd = doc->intSubset;
    367     ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content);
    368     if (ret == NULL) return(NULL);
    369 
    370     /*
    371      * Link it to the DTD
    372      */
    373     ret->parent = dtd;
    374     ret->doc = dtd->doc;
    375     if (dtd->last == NULL) {
    376 	dtd->children = dtd->last = (xmlNodePtr) ret;
    377     } else {
    378 	dtd->last->next = (xmlNodePtr) ret;
    379 	ret->prev = dtd->last;
    380 	dtd->last = (xmlNodePtr) ret;
    381     }
    382     return(ret);
    383 }
    384 
    385 /**
    386  * xmlNewEntity:
    387  * @doc:  the document
    388  * @name:  the entity name
    389  * @type:  the entity type XML_xxx_yyy_ENTITY
    390  * @ExternalID:  the entity external ID if available
    391  * @SystemID:  the entity system ID if available
    392  * @content:  the entity content
    393  *
    394  * Create a new entity, this differs from xmlAddDocEntity() that if
    395  * the document is NULL or has no internal subset defined, then an
    396  * unlinked entity structure will be returned, it is then the responsability
    397  * of the caller to link it to the document later or free it when not needed
    398  * anymore.
    399  *
    400  * Returns a pointer to the entity or NULL in case of error
    401  */
    402 xmlEntityPtr
    403 xmlNewEntity(xmlDocPtr doc, const xmlChar *name, int type,
    404 	     const xmlChar *ExternalID, const xmlChar *SystemID,
    405 	     const xmlChar *content) {
    406     xmlEntityPtr ret;
    407     xmlDictPtr dict;
    408 
    409     if ((doc != NULL) && (doc->intSubset != NULL)) {
    410 	return(xmlAddDocEntity(doc, name, type, ExternalID, SystemID, content));
    411     }
    412     if (doc != NULL)
    413         dict = doc->dict;
    414     else
    415         dict = NULL;
    416     ret = xmlCreateEntity(dict, name, type, ExternalID, SystemID, content);
    417     if (ret == NULL)
    418         return(NULL);
    419     ret->doc = doc;
    420     return(ret);
    421 }
    422 
    423 /**
    424  * xmlGetEntityFromTable:
    425  * @table:  an entity table
    426  * @name:  the entity name
    427  * @parameter:  look for parameter entities
    428  *
    429  * Do an entity lookup in the table.
    430  * returns the corresponding parameter entity, if found.
    431  *
    432  * Returns A pointer to the entity structure or NULL if not found.
    433  */
    434 static xmlEntityPtr
    435 xmlGetEntityFromTable(xmlEntitiesTablePtr table, const xmlChar *name) {
    436     return((xmlEntityPtr) xmlHashLookup(table, name));
    437 }
    438 
    439 /**
    440  * xmlGetParameterEntity:
    441  * @doc:  the document referencing the entity
    442  * @name:  the entity name
    443  *
    444  * Do an entity lookup in the internal and external subsets and
    445  * returns the corresponding parameter entity, if found.
    446  *
    447  * Returns A pointer to the entity structure or NULL if not found.
    448  */
    449 xmlEntityPtr
    450 xmlGetParameterEntity(xmlDocPtr doc, const xmlChar *name) {
    451     xmlEntitiesTablePtr table;
    452     xmlEntityPtr ret;
    453 
    454     if (doc == NULL)
    455 	return(NULL);
    456     if ((doc->intSubset != NULL) && (doc->intSubset->pentities != NULL)) {
    457 	table = (xmlEntitiesTablePtr) doc->intSubset->pentities;
    458 	ret = xmlGetEntityFromTable(table, name);
    459 	if (ret != NULL)
    460 	    return(ret);
    461     }
    462     if ((doc->extSubset != NULL) && (doc->extSubset->pentities != NULL)) {
    463 	table = (xmlEntitiesTablePtr) doc->extSubset->pentities;
    464 	return(xmlGetEntityFromTable(table, name));
    465     }
    466     return(NULL);
    467 }
    468 
    469 /**
    470  * xmlGetDtdEntity:
    471  * @doc:  the document referencing the entity
    472  * @name:  the entity name
    473  *
    474  * Do an entity lookup in the DTD entity hash table and
    475  * returns the corresponding entity, if found.
    476  * Note: the first argument is the document node, not the DTD node.
    477  *
    478  * Returns A pointer to the entity structure or NULL if not found.
    479  */
    480 xmlEntityPtr
    481 xmlGetDtdEntity(xmlDocPtr doc, const xmlChar *name) {
    482     xmlEntitiesTablePtr table;
    483 
    484     if (doc == NULL)
    485 	return(NULL);
    486     if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
    487 	table = (xmlEntitiesTablePtr) doc->extSubset->entities;
    488 	return(xmlGetEntityFromTable(table, name));
    489     }
    490     return(NULL);
    491 }
    492 
    493 /**
    494  * xmlGetDocEntity:
    495  * @doc:  the document referencing the entity
    496  * @name:  the entity name
    497  *
    498  * Do an entity lookup in the document entity hash table and
    499  * returns the corresponding entity, otherwise a lookup is done
    500  * in the predefined entities too.
    501  *
    502  * Returns A pointer to the entity structure or NULL if not found.
    503  */
    504 xmlEntityPtr
    505 xmlGetDocEntity(const xmlDoc *doc, const xmlChar *name) {
    506     xmlEntityPtr cur;
    507     xmlEntitiesTablePtr table;
    508 
    509     if (doc != NULL) {
    510 	if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
    511 	    table = (xmlEntitiesTablePtr) doc->intSubset->entities;
    512 	    cur = xmlGetEntityFromTable(table, name);
    513 	    if (cur != NULL)
    514 		return(cur);
    515 	}
    516 	if (doc->standalone != 1) {
    517 	    if ((doc->extSubset != NULL) &&
    518 		(doc->extSubset->entities != NULL)) {
    519 		table = (xmlEntitiesTablePtr) doc->extSubset->entities;
    520 		cur = xmlGetEntityFromTable(table, name);
    521 		if (cur != NULL)
    522 		    return(cur);
    523 	    }
    524 	}
    525     }
    526     return(xmlGetPredefinedEntity(name));
    527 }
    528 
    529 /*
    530  * Macro used to grow the current buffer.
    531  */
    532 #define growBufferReentrant() {						\
    533     xmlChar *tmp;                                                       \
    534     size_t new_size = buffer_size * 2;                                  \
    535     if (new_size < buffer_size) goto mem_error;                         \
    536     tmp = (xmlChar *) xmlRealloc(buffer, new_size);	                \
    537     if (tmp == NULL) goto mem_error;                                    \
    538     buffer = tmp;							\
    539     buffer_size = new_size;						\
    540 }
    541 
    542 /**
    543  * xmlEncodeEntitiesInternal:
    544  * @doc:  the document containing the string
    545  * @input:  A string to convert to XML.
    546  * @attr: are we handling an atrbute value
    547  *
    548  * Do a global encoding of a string, replacing the predefined entities
    549  * and non ASCII values with their entities and CharRef counterparts.
    550  * Contrary to xmlEncodeEntities, this routine is reentrant, and result
    551  * must be deallocated.
    552  *
    553  * Returns A newly allocated string with the substitution done.
    554  */
    555 static xmlChar *
    556 xmlEncodeEntitiesInternal(xmlDocPtr doc, const xmlChar *input, int attr) {
    557     const xmlChar *cur = input;
    558     xmlChar *buffer = NULL;
    559     xmlChar *out = NULL;
    560     size_t buffer_size = 0;
    561     int html = 0;
    562 
    563     if (input == NULL) return(NULL);
    564     if (doc != NULL)
    565         html = (doc->type == XML_HTML_DOCUMENT_NODE);
    566 
    567     /*
    568      * allocate an translation buffer.
    569      */
    570     buffer_size = 1000;
    571     buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
    572     if (buffer == NULL) {
    573         xmlEntitiesErrMemory("xmlEncodeEntities: malloc failed");
    574 	return(NULL);
    575     }
    576     out = buffer;
    577 
    578     while (*cur != '\0') {
    579         size_t indx = out - buffer;
    580         if (indx + 100 > buffer_size) {
    581 
    582 	    growBufferReentrant();
    583 	    out = &buffer[indx];
    584 	}
    585 
    586 	/*
    587 	 * By default one have to encode at least '<', '>', '"' and '&' !
    588 	 */
    589 	if (*cur == '<') {
    590 	    const xmlChar *end;
    591 
    592 	    /*
    593 	     * Special handling of server side include in HTML attributes
    594 	     */
    595 	    if (html && attr &&
    596 	        (cur[1] == '!') && (cur[2] == '-') && (cur[3] == '-') &&
    597 	        ((end = xmlStrstr(cur, BAD_CAST "-->")) != NULL)) {
    598 	        while (cur != end) {
    599 		    *out++ = *cur++;
    600 		    indx = out - buffer;
    601 		    if (indx + 100 > buffer_size) {
    602 			growBufferReentrant();
    603 			out = &buffer[indx];
    604 		    }
    605 		}
    606 		*out++ = *cur++;
    607 		*out++ = *cur++;
    608 		*out++ = *cur++;
    609 		continue;
    610 	    }
    611 	    *out++ = '&';
    612 	    *out++ = 'l';
    613 	    *out++ = 't';
    614 	    *out++ = ';';
    615 	} else if (*cur == '>') {
    616 	    *out++ = '&';
    617 	    *out++ = 'g';
    618 	    *out++ = 't';
    619 	    *out++ = ';';
    620 	} else if (*cur == '&') {
    621 	    /*
    622 	     * Special handling of &{...} construct from HTML 4, see
    623 	     * http://www.w3.org/TR/html401/appendix/notes.html#h-B.7.1
    624 	     */
    625 	    if (html && attr && (cur[1] == '{') &&
    626 	        (strchr((const char *) cur, '}'))) {
    627 	        while (*cur != '}') {
    628 		    *out++ = *cur++;
    629 		    indx = out - buffer;
    630 		    if (indx + 100 > buffer_size) {
    631 			growBufferReentrant();
    632 			out = &buffer[indx];
    633 		    }
    634 		}
    635 		*out++ = *cur++;
    636 		continue;
    637 	    }
    638 	    *out++ = '&';
    639 	    *out++ = 'a';
    640 	    *out++ = 'm';
    641 	    *out++ = 'p';
    642 	    *out++ = ';';
    643 	} else if (((*cur >= 0x20) && (*cur < 0x80)) ||
    644 	    (*cur == '\n') || (*cur == '\t') || ((html) && (*cur == '\r'))) {
    645 	    /*
    646 	     * default case, just copy !
    647 	     */
    648 	    *out++ = *cur;
    649 	} else if (*cur >= 0x80) {
    650 	    if (((doc != NULL) && (doc->encoding != NULL)) || (html)) {
    651 		/*
    652 		 * Bjrn Reese <br (at) sseusa.com> provided the patch
    653 	        xmlChar xc;
    654 	        xc = (*cur & 0x3F) << 6;
    655 	        if (cur[1] != 0) {
    656 		    xc += *(++cur) & 0x3F;
    657 		    *out++ = xc;
    658 	        } else
    659 		 */
    660 		*out++ = *cur;
    661 	    } else {
    662 		/*
    663 		 * We assume we have UTF-8 input.
    664 		 */
    665 		char buf[11], *ptr;
    666 		int val = 0, l = 1;
    667 
    668 		if (*cur < 0xC0) {
    669 		    xmlEntitiesErr(XML_CHECK_NOT_UTF8,
    670 			    "xmlEncodeEntities: input not UTF-8");
    671 		    if (doc != NULL)
    672 			doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
    673 		    snprintf(buf, sizeof(buf), "&#%d;", *cur);
    674 		    buf[sizeof(buf) - 1] = 0;
    675 		    ptr = buf;
    676 		    while (*ptr != 0) *out++ = *ptr++;
    677 		    cur++;
    678 		    continue;
    679 		} else if (*cur < 0xE0) {
    680                     val = (cur[0]) & 0x1F;
    681 		    val <<= 6;
    682 		    val |= (cur[1]) & 0x3F;
    683 		    l = 2;
    684 		} else if (*cur < 0xF0) {
    685                     val = (cur[0]) & 0x0F;
    686 		    val <<= 6;
    687 		    val |= (cur[1]) & 0x3F;
    688 		    val <<= 6;
    689 		    val |= (cur[2]) & 0x3F;
    690 		    l = 3;
    691 		} else if (*cur < 0xF8) {
    692                     val = (cur[0]) & 0x07;
    693 		    val <<= 6;
    694 		    val |= (cur[1]) & 0x3F;
    695 		    val <<= 6;
    696 		    val |= (cur[2]) & 0x3F;
    697 		    val <<= 6;
    698 		    val |= (cur[3]) & 0x3F;
    699 		    l = 4;
    700 		}
    701 		if ((l == 1) || (!IS_CHAR(val))) {
    702 		    xmlEntitiesErr(XML_ERR_INVALID_CHAR,
    703 			"xmlEncodeEntities: char out of range\n");
    704 		    if (doc != NULL)
    705 			doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
    706 		    snprintf(buf, sizeof(buf), "&#%d;", *cur);
    707 		    buf[sizeof(buf) - 1] = 0;
    708 		    ptr = buf;
    709 		    while (*ptr != 0) *out++ = *ptr++;
    710 		    cur++;
    711 		    continue;
    712 		}
    713 		/*
    714 		 * We could do multiple things here. Just save as a char ref
    715 		 */
    716 		snprintf(buf, sizeof(buf), "&#x%X;", val);
    717 		buf[sizeof(buf) - 1] = 0;
    718 		ptr = buf;
    719 		while (*ptr != 0) *out++ = *ptr++;
    720 		cur += l;
    721 		continue;
    722 	    }
    723 	} else if (IS_BYTE_CHAR(*cur)) {
    724 	    char buf[11], *ptr;
    725 
    726 	    snprintf(buf, sizeof(buf), "&#%d;", *cur);
    727 	    buf[sizeof(buf) - 1] = 0;
    728             ptr = buf;
    729 	    while (*ptr != 0) *out++ = *ptr++;
    730 	}
    731 	cur++;
    732     }
    733     *out = 0;
    734     return(buffer);
    735 
    736 mem_error:
    737     xmlEntitiesErrMemory("xmlEncodeEntities: realloc failed");
    738     xmlFree(buffer);
    739     return(NULL);
    740 }
    741 
    742 /**
    743  * xmlEncodeAttributeEntities:
    744  * @doc:  the document containing the string
    745  * @input:  A string to convert to XML.
    746  *
    747  * Do a global encoding of a string, replacing the predefined entities
    748  * and non ASCII values with their entities and CharRef counterparts for
    749  * attribute values.
    750  *
    751  * Returns A newly allocated string with the substitution done.
    752  */
    753 xmlChar *
    754 xmlEncodeAttributeEntities(xmlDocPtr doc, const xmlChar *input) {
    755     return xmlEncodeEntitiesInternal(doc, input, 1);
    756 }
    757 
    758 /**
    759  * xmlEncodeEntitiesReentrant:
    760  * @doc:  the document containing the string
    761  * @input:  A string to convert to XML.
    762  *
    763  * Do a global encoding of a string, replacing the predefined entities
    764  * and non ASCII values with their entities and CharRef counterparts.
    765  * Contrary to xmlEncodeEntities, this routine is reentrant, and result
    766  * must be deallocated.
    767  *
    768  * Returns A newly allocated string with the substitution done.
    769  */
    770 xmlChar *
    771 xmlEncodeEntitiesReentrant(xmlDocPtr doc, const xmlChar *input) {
    772     return xmlEncodeEntitiesInternal(doc, input, 0);
    773 }
    774 
    775 /**
    776  * xmlEncodeSpecialChars:
    777  * @doc:  the document containing the string
    778  * @input:  A string to convert to XML.
    779  *
    780  * Do a global encoding of a string, replacing the predefined entities
    781  * this routine is reentrant, and result must be deallocated.
    782  *
    783  * Returns A newly allocated string with the substitution done.
    784  */
    785 xmlChar *
    786 xmlEncodeSpecialChars(const xmlDoc *doc ATTRIBUTE_UNUSED, const xmlChar *input) {
    787     const xmlChar *cur = input;
    788     xmlChar *buffer = NULL;
    789     xmlChar *out = NULL;
    790     size_t buffer_size = 0;
    791     if (input == NULL) return(NULL);
    792 
    793     /*
    794      * allocate an translation buffer.
    795      */
    796     buffer_size = 1000;
    797     buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
    798     if (buffer == NULL) {
    799         xmlEntitiesErrMemory("xmlEncodeSpecialChars: malloc failed");
    800 	return(NULL);
    801     }
    802     out = buffer;
    803 
    804     while (*cur != '\0') {
    805         size_t indx = out - buffer;
    806         if (indx + 10 > buffer_size) {
    807 
    808 	    growBufferReentrant();
    809 	    out = &buffer[indx];
    810 	}
    811 
    812 	/*
    813 	 * By default one have to encode at least '<', '>', '"' and '&' !
    814 	 */
    815 	if (*cur == '<') {
    816 	    *out++ = '&';
    817 	    *out++ = 'l';
    818 	    *out++ = 't';
    819 	    *out++ = ';';
    820 	} else if (*cur == '>') {
    821 	    *out++ = '&';
    822 	    *out++ = 'g';
    823 	    *out++ = 't';
    824 	    *out++ = ';';
    825 	} else if (*cur == '&') {
    826 	    *out++ = '&';
    827 	    *out++ = 'a';
    828 	    *out++ = 'm';
    829 	    *out++ = 'p';
    830 	    *out++ = ';';
    831 	} else if (*cur == '"') {
    832 	    *out++ = '&';
    833 	    *out++ = 'q';
    834 	    *out++ = 'u';
    835 	    *out++ = 'o';
    836 	    *out++ = 't';
    837 	    *out++ = ';';
    838 	} else if (*cur == '\r') {
    839 	    *out++ = '&';
    840 	    *out++ = '#';
    841 	    *out++ = '1';
    842 	    *out++ = '3';
    843 	    *out++ = ';';
    844 	} else {
    845 	    /*
    846 	     * Works because on UTF-8, all extended sequences cannot
    847 	     * result in bytes in the ASCII range.
    848 	     */
    849 	    *out++ = *cur;
    850 	}
    851 	cur++;
    852     }
    853     *out = 0;
    854     return(buffer);
    855 
    856 mem_error:
    857     xmlEntitiesErrMemory("xmlEncodeSpecialChars: realloc failed");
    858     xmlFree(buffer);
    859     return(NULL);
    860 }
    861 
    862 /**
    863  * xmlCreateEntitiesTable:
    864  *
    865  * create and initialize an empty entities hash table.
    866  * This really doesn't make sense and should be deprecated
    867  *
    868  * Returns the xmlEntitiesTablePtr just created or NULL in case of error.
    869  */
    870 xmlEntitiesTablePtr
    871 xmlCreateEntitiesTable(void) {
    872     return((xmlEntitiesTablePtr) xmlHashCreate(0));
    873 }
    874 
    875 /**
    876  * xmlFreeEntityWrapper:
    877  * @entity:  An entity
    878  * @name:  its name
    879  *
    880  * Deallocate the memory used by an entities in the hash table.
    881  */
    882 static void
    883 xmlFreeEntityWrapper(xmlEntityPtr entity,
    884 	               const xmlChar *name ATTRIBUTE_UNUSED) {
    885     if (entity != NULL)
    886 	xmlFreeEntity(entity);
    887 }
    888 
    889 /**
    890  * xmlFreeEntitiesTable:
    891  * @table:  An entity table
    892  *
    893  * Deallocate the memory used by an entities hash table.
    894  */
    895 void
    896 xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
    897     xmlHashFree(table, (xmlHashDeallocator) xmlFreeEntityWrapper);
    898 }
    899 
    900 #ifdef LIBXML_TREE_ENABLED
    901 /**
    902  * xmlCopyEntity:
    903  * @ent:  An entity
    904  *
    905  * Build a copy of an entity
    906  *
    907  * Returns the new xmlEntitiesPtr or NULL in case of error.
    908  */
    909 static xmlEntityPtr
    910 xmlCopyEntity(xmlEntityPtr ent) {
    911     xmlEntityPtr cur;
    912 
    913     cur = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
    914     if (cur == NULL) {
    915         xmlEntitiesErrMemory("xmlCopyEntity:: malloc failed");
    916 	return(NULL);
    917     }
    918     memset(cur, 0, sizeof(xmlEntity));
    919     cur->type = XML_ENTITY_DECL;
    920 
    921     cur->etype = ent->etype;
    922     if (ent->name != NULL)
    923 	cur->name = xmlStrdup(ent->name);
    924     if (ent->ExternalID != NULL)
    925 	cur->ExternalID = xmlStrdup(ent->ExternalID);
    926     if (ent->SystemID != NULL)
    927 	cur->SystemID = xmlStrdup(ent->SystemID);
    928     if (ent->content != NULL)
    929 	cur->content = xmlStrdup(ent->content);
    930     if (ent->orig != NULL)
    931 	cur->orig = xmlStrdup(ent->orig);
    932     if (ent->URI != NULL)
    933 	cur->URI = xmlStrdup(ent->URI);
    934     return(cur);
    935 }
    936 
    937 /**
    938  * xmlCopyEntitiesTable:
    939  * @table:  An entity table
    940  *
    941  * Build a copy of an entity table.
    942  *
    943  * Returns the new xmlEntitiesTablePtr or NULL in case of error.
    944  */
    945 xmlEntitiesTablePtr
    946 xmlCopyEntitiesTable(xmlEntitiesTablePtr table) {
    947     return(xmlHashCopy(table, (xmlHashCopier) xmlCopyEntity));
    948 }
    949 #endif /* LIBXML_TREE_ENABLED */
    950 
    951 #ifdef LIBXML_OUTPUT_ENABLED
    952 
    953 /**
    954  * xmlDumpEntityContent:
    955  * @buf:  An XML buffer.
    956  * @content:  The entity content.
    957  *
    958  * This will dump the quoted string value, taking care of the special
    959  * treatment required by %
    960  */
    961 static void
    962 xmlDumpEntityContent(xmlBufferPtr buf, const xmlChar *content) {
    963     if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
    964     if (xmlStrchr(content, '%')) {
    965         const xmlChar * base, *cur;
    966 
    967 	xmlBufferCCat(buf, "\"");
    968 	base = cur = content;
    969 	while (*cur != 0) {
    970 	    if (*cur == '"') {
    971 		if (base != cur)
    972 		    xmlBufferAdd(buf, base, cur - base);
    973 		xmlBufferAdd(buf, BAD_CAST "&quot;", 6);
    974 		cur++;
    975 		base = cur;
    976 	    } else if (*cur == '%') {
    977 		if (base != cur)
    978 		    xmlBufferAdd(buf, base, cur - base);
    979 		xmlBufferAdd(buf, BAD_CAST "&#x25;", 6);
    980 		cur++;
    981 		base = cur;
    982 	    } else {
    983 		cur++;
    984 	    }
    985 	}
    986 	if (base != cur)
    987 	    xmlBufferAdd(buf, base, cur - base);
    988 	xmlBufferCCat(buf, "\"");
    989     } else {
    990         xmlBufferWriteQuotedString(buf, content);
    991     }
    992 }
    993 
    994 /**
    995  * xmlDumpEntityDecl:
    996  * @buf:  An XML buffer.
    997  * @ent:  An entity table
    998  *
    999  * This will dump the content of the entity table as an XML DTD definition
   1000  */
   1001 void
   1002 xmlDumpEntityDecl(xmlBufferPtr buf, xmlEntityPtr ent) {
   1003     if ((buf == NULL) || (ent == NULL)) return;
   1004     switch (ent->etype) {
   1005 	case XML_INTERNAL_GENERAL_ENTITY:
   1006 	    xmlBufferWriteChar(buf, "<!ENTITY ");
   1007 	    xmlBufferWriteCHAR(buf, ent->name);
   1008 	    xmlBufferWriteChar(buf, " ");
   1009 	    if (ent->orig != NULL)
   1010 		xmlBufferWriteQuotedString(buf, ent->orig);
   1011 	    else
   1012 		xmlDumpEntityContent(buf, ent->content);
   1013 	    xmlBufferWriteChar(buf, ">\n");
   1014 	    break;
   1015 	case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
   1016 	    xmlBufferWriteChar(buf, "<!ENTITY ");
   1017 	    xmlBufferWriteCHAR(buf, ent->name);
   1018 	    if (ent->ExternalID != NULL) {
   1019 		 xmlBufferWriteChar(buf, " PUBLIC ");
   1020 		 xmlBufferWriteQuotedString(buf, ent->ExternalID);
   1021 		 xmlBufferWriteChar(buf, " ");
   1022 		 xmlBufferWriteQuotedString(buf, ent->SystemID);
   1023 	    } else {
   1024 		 xmlBufferWriteChar(buf, " SYSTEM ");
   1025 		 xmlBufferWriteQuotedString(buf, ent->SystemID);
   1026 	    }
   1027 	    xmlBufferWriteChar(buf, ">\n");
   1028 	    break;
   1029 	case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
   1030 	    xmlBufferWriteChar(buf, "<!ENTITY ");
   1031 	    xmlBufferWriteCHAR(buf, ent->name);
   1032 	    if (ent->ExternalID != NULL) {
   1033 		 xmlBufferWriteChar(buf, " PUBLIC ");
   1034 		 xmlBufferWriteQuotedString(buf, ent->ExternalID);
   1035 		 xmlBufferWriteChar(buf, " ");
   1036 		 xmlBufferWriteQuotedString(buf, ent->SystemID);
   1037 	    } else {
   1038 		 xmlBufferWriteChar(buf, " SYSTEM ");
   1039 		 xmlBufferWriteQuotedString(buf, ent->SystemID);
   1040 	    }
   1041 	    if (ent->content != NULL) { /* Should be true ! */
   1042 		xmlBufferWriteChar(buf, " NDATA ");
   1043 		if (ent->orig != NULL)
   1044 		    xmlBufferWriteCHAR(buf, ent->orig);
   1045 		else
   1046 		    xmlBufferWriteCHAR(buf, ent->content);
   1047 	    }
   1048 	    xmlBufferWriteChar(buf, ">\n");
   1049 	    break;
   1050 	case XML_INTERNAL_PARAMETER_ENTITY:
   1051 	    xmlBufferWriteChar(buf, "<!ENTITY % ");
   1052 	    xmlBufferWriteCHAR(buf, ent->name);
   1053 	    xmlBufferWriteChar(buf, " ");
   1054 	    if (ent->orig == NULL)
   1055 		xmlDumpEntityContent(buf, ent->content);
   1056 	    else
   1057 		xmlBufferWriteQuotedString(buf, ent->orig);
   1058 	    xmlBufferWriteChar(buf, ">\n");
   1059 	    break;
   1060 	case XML_EXTERNAL_PARAMETER_ENTITY:
   1061 	    xmlBufferWriteChar(buf, "<!ENTITY % ");
   1062 	    xmlBufferWriteCHAR(buf, ent->name);
   1063 	    if (ent->ExternalID != NULL) {
   1064 		 xmlBufferWriteChar(buf, " PUBLIC ");
   1065 		 xmlBufferWriteQuotedString(buf, ent->ExternalID);
   1066 		 xmlBufferWriteChar(buf, " ");
   1067 		 xmlBufferWriteQuotedString(buf, ent->SystemID);
   1068 	    } else {
   1069 		 xmlBufferWriteChar(buf, " SYSTEM ");
   1070 		 xmlBufferWriteQuotedString(buf, ent->SystemID);
   1071 	    }
   1072 	    xmlBufferWriteChar(buf, ">\n");
   1073 	    break;
   1074 	default:
   1075 	    xmlEntitiesErr(XML_DTD_UNKNOWN_ENTITY,
   1076 		"xmlDumpEntitiesDecl: internal: unknown type entity type");
   1077     }
   1078 }
   1079 
   1080 /**
   1081  * xmlDumpEntityDeclScan:
   1082  * @ent:  An entity table
   1083  * @buf:  An XML buffer.
   1084  *
   1085  * When using the hash table scan function, arguments need to be reversed
   1086  */
   1087 static void
   1088 xmlDumpEntityDeclScan(xmlEntityPtr ent, xmlBufferPtr buf) {
   1089     xmlDumpEntityDecl(buf, ent);
   1090 }
   1091 
   1092 /**
   1093  * xmlDumpEntitiesTable:
   1094  * @buf:  An XML buffer.
   1095  * @table:  An entity table
   1096  *
   1097  * This will dump the content of the entity table as an XML DTD definition
   1098  */
   1099 void
   1100 xmlDumpEntitiesTable(xmlBufferPtr buf, xmlEntitiesTablePtr table) {
   1101     xmlHashScan(table, (xmlHashScanner)xmlDumpEntityDeclScan, buf);
   1102 }
   1103 #endif /* LIBXML_OUTPUT_ENABLED */
   1104 #define bottom_entities
   1105 #include "elfgcchack.h"
   1106