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